LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_oth.c
// Function: ft_conversion_double
char		*ft_conversion_double(long double nb, t_flag *flag, char c)
{
	char	*s;
	int		len;

	s = ft_dtoa(&nb, flag->dot ? flag->precision : 6);
	ft_nan_inf(s, flag);
	ft_double_flag_neg(&s, flag);
	len = ft_strlen(s);
	if (flag->dot && !flag->precision && flag->sharp && s[len - 1] != '.')
		ft_join_free(&s, ".", 1, 0);
	if (s[len - 1] == '.' && !flag->sharp)
		s[len - 1] = '\0';
	if (flag->plus || flag->neg)
		flag->space = 0;
	if (c == 'F' && s
		&& (*s == 'n' || (*s == 'i' || (flag->neg && *(s + 1) == 'i'))))
		ft_strupcase(s);
	flag->precision -= len;
	flag->precision < 0 ? flag->precision = 0 : flag->precision;
	flag->field -= flag->precision + ft_strlen(s)
				+ flag->space + flag->plus + flag->neg;
	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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
fldt 0x50(%rsp)
fstpt 0x10(%rsp)
cmpl $0x0, 0x2c(%rdi)
je 0x36c2
movl 0x34(%rbx), %esi
jmp 0x36c7
movl $0x6, %esi
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
leaq 0x10(%rsp), %rdi
callq 0x3eac
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e57
movq (%r14), %rdi
callq 0x5594
movq %rax, %r14
cmpl $0x0, 0x2c(%rbx)
je 0x3714
cmpl $0x0, 0x34(%rbx)
je 0x37fb
movq 0x8(%rsp), %rax
movq %r14, %rcx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
cmpb $0x2e, (%rax,%rcx)
jne 0x3737
cmpl $0x0, 0x8(%rbx)
jne 0x3737
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x14(%rbx)
jne 0x3743
cmpl $0x0, 0x3c(%rbx)
je 0x374a
movl $0x0, 0x30(%rbx)
cmpb $0x46, %bpl
sete %al
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3781
movzbl (%rdi), %eax
cmpl $0x69, %eax
je 0x377c
cmpl $0x6e, %eax
je 0x377c
cmpl $0x0, 0x3c(%rbx)
je 0x3781
cmpb $0x69, 0x1(%rdi)
jne 0x3781
callq 0x5618
movl 0x34(%rbx), %eax
subl %r14d, %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
movl %r15d, 0x34(%rbx)
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
callq 0x5594
addl %r15d, %eax
addl 0x30(%rbx), %eax
addl 0x14(%rbx), %eax
addl 0x3c(%rbx), %eax
subl %eax, 0x38(%rbx)
movsbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3458
movslq 0x38(%rbx), %rdi
testq %rdi, %rdi
js 0x37eb
cmpl $0x0, 0xc(%rbx)
jne 0x37eb
movl $0x20, %esi
callq 0x31de
movl 0x10(%rbx), %edx
movl 0x44(%rbx), %ecx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3221
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x8(%rbx)
je 0x3714
movq 0x8(%rsp), %rax
movq %r14, %rcx
shlq $0x20, %rcx
addq %r15, %rcx
sarq $0x20, %rcx
cmpb $0x2e, (%rax,%rcx)
je 0x3714
leaq 0x29cd(%rip), %rsi      # 0x61f6
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x327c
jmp 0x3714
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %esi, %esi
callq 0x3180
testl %eax, %eax
je 0x3bb5
movl %ebp, %edi
callq 0x31b5
movl %ebp, %edi
cmpl $0x1, %eax
jne 0x3bbc
movq %r14, %rsi
callq 0x3586
movq %rax, (%rbx)
jmp 0x3bdf
movl $0x1, %eax
jmp 0x3be1
movl %eax, %esi
callq 0x3bec
movq %rsp, %r15
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
callq 0x35ea
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1d5c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r15d
movslq %esi, %r14
movq %r14, %rdi
callq 0x55d8
cmpl $0x1, %r14d
je 0x3c63
cmpl $0x3, %ebx
je 0x3c37
cmpl $0x2, %ebx
jne 0x3c6b
movl %r15d, %ecx
andl $0x3fc0, %ecx           # imm = 0x3FC0
leal 0xc080(,%rcx,4), %ecx
andb $0x3f, %r15b
orb $-0x80, %r15b
movb %r15b, 0x1(%rax)
shrl $0x8, %ecx
movl %ecx, %edx
jmp 0x3cf3
movl %r15d, %ecx
andl $0x3f, %ecx
orl $0xe08080, %ecx         # imm = 0xE08080
leal (,%r15,4), %edx
andl $0x3f00, %edx           # imm = 0x3F00
cmpl $0xfff, %r15d           # imm = 0xFFF
ja 0x3cd6
orl %edx, %ecx
movl %ecx, %edx
jmp 0x3ce6
movq %r15, %rdx
jmp 0x3cf3
leal (,%r15,4), %ecx
movl %ecx, %edx
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
andl $0x3f00, %ecx           # imm = 0x3F00
subl %ecx, %edx
leal (,%rdx,4), %esi
movl %esi, %edi
andl $0x3ffc00, %edi         # imm = 0x3FFC00
shll $0x4, %edx
andl $0xff000000, %edx       # imm = 0xFF000000
orl %edi, %edx
cmpl $0x40000, %r15d         # imm = 0x40000
cmovbl %esi, %edx
andl $0x3f, %r15d
leal (%r15,%rcx), %esi
addl $0xf0808080, %esi       # imm = 0xF0808080
movl %r15d, %edi
orl %ecx, %edi
addl %edi, %edx
addl $0xf0808080, %edx       # imm = 0xF0808080
movb %sil, 0x3(%rax)
movb %dh, 0x2(%rax)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, 0x1(%rax)
shrl $0x18, %edx
jmp 0x3cf3
shll $0x4, %r15d
andl $0xffff0000, %r15d      # imm = 0xFFFF0000
orl %r15d, %edx
addl %ecx, %edx
movl %edx, %ecx
rolw $0x8, %cx
movw %cx, 0x1(%rax)
shrl $0x10, %edx
movb %dl, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x3db2
movq %rdi, %r15
movl 0x34(%r14), %ebp
xorl %ebx, %ebx
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movl (%r15,%rbx), %edi
testl %edi, %edi
je 0x3dac
movq %r12, %rsi
callq 0x3180
testl %eax, %eax
je 0x3dd8
movl (%r15,%rbx), %edi
callq 0x31b5
cmpl $0x0, 0x2c(%r14)
je 0x3d62
subl %eax, %ebp
js 0x3d97
movl (%r15,%rbx), %edi
movl %eax, %esi
callq 0x3bec
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %rax, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x327c
movq %r13, %rdi
callq 0x1d5c
addq $0x4, %rbx
testq %r15, %r15
jne 0x3d36
jmp 0x3db2
testq %rbx, %rbx
jne 0x3d84
movl $0x1, %edi
callq 0x55d8
movq %rax, (%rsp)
jmp 0x3d84
cmpl $0x0, (%r15)
je 0x3dec
movq (%rsp), %rdi
movq %rsp, %r15
movq %rdi, (%r15)
movq %r14, %rsi
callq 0x35ea
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %r15, %rdi
callq 0x1d5c
xorl %eax, %eax
jmp 0x3ddd
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x55d8
movq %rax, %rdi
jmp 0x3db6
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x23db(%rip), %rsi      # 0x61e8
callq 0x535c
testl %eax, %eax
je 0x3e3c
leaq 0x23c6(%rip), %rsi      # 0x61e3
movq %r14, %rdi
callq 0x535c
testl %eax, %eax
je 0x3e3c
leaq 0x23b7(%rip), %rsi      # 0x61e7
movq %r14, %rdi
callq 0x535c
testl %eax, %eax
jne 0x3e4f
xorl %eax, %eax
movl %eax, 0x34(%rbx)
movq $0x0, 0x2c(%rbx)
movl %eax, 0x14(%rbx)
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x237c(%rip), %rsi      # 0x61e7
callq 0x535c
testl %eax, %eax
je 0x3ea2
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3ea2
cmpb $0x2d, (%rdi)
jne 0x3ea2
incq %rdi
callq 0x543c
movq %r14, %rdi
movq %rax, %rsi
callq 0x420c
movl $0x1, 0x3c(%rbx)
movl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, (%rsp)
leaq 0x120(%rsp), %r15
movq %r15, %rsi
callq 0x40b4
leaq 0x1c(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4064
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movl $0x40, %edx
callq 0x409c
movslq (%r12), %r15
cmpq $0x4000, %r15           # imm = 0x4000
jl 0x3f32
leaq 0x20(%rsp), %rdi
callq 0x43e8
testl %eax, %eax
leaq 0x22ca(%rip), %rax      # 0x61e3
leaq 0x22c8(%rip), %rdi      # 0x61e8
cmoveq %rax, %rdi
callq 0x543c
movq %rax, (%rsp)
jmp 0x4029
cmpl $0xffffc001, %r15d      # imm = 0xFFFFC001
jne 0x3f50
leaq 0x22aa(%rip), %rdi      # 0x61ec
callq 0x543c
movq %rax, (%rsp)
jmp 0x401f
testl %r15d, %r15d
js 0x3fd4
leal 0x1(%r15), %esi
leaq 0x20(%rsp), %rdi
movl $0x40, %edx
callq 0x4451
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x227b(%rip), %rsi      # 0x61f6
movq %rax, %rdi
callq 0x54c0
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x1d5c
xorl %edi, %edi
cmpl $0x40, %r15d
leaq 0x24(%rsp,%r15,4), %rax
cmovlq %rax, %rdi
movl $0x3f, %esi
subl %r15d, %esi
callq 0x4850
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq (%rsp), %rdi
movq %rdi, (%r14)
leaq 0x1(%rax), %rsi
callq 0x54c0
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x1d5c
movq %r15, %rdi
jmp 0x401a
movq %r14, %rdi
callq 0x40f6
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq (%rsp), %rsi
leaq 0x2206(%rip), %rdi      # 0x61f5
callq 0x54c0
movq %rax, (%rsp)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq (%r14), %rsi
movq %rax, %rdi
callq 0x54c0
movq %rax, (%rsp)
movq %r15, %rdi
callq 0x1d5c
movq %r14, %rdi
callq 0x1d5c
movq %rsp, %rdi
movl %ebx, %esi
callq 0x4640
movq (%rsp), %rax
cmpb $0x6e, (%rax)
je 0x404f
cmpl $0x1, 0x120(%rsp)
jne 0x404f
leaq 0x1fc1(%rip), %rsi      # 0x6004
movq %rsp, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x327c
movq (%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
cmpl $0x1, 0x3c(%rdi)
sete %al
movl $0x1, %ecx
movl $0xf, %edx
addl %ecx, %ecx
cmpl $0x1, -0x4(%rdi,%rdx,4)
movl $0x0, %r8d
cmovel %ecx, %r8d
addl %r8d, %eax
decq %rdx
cmpq $0x1, %rdx
ja 0x4077
addl $0xffffc001, %eax       # imm = 0xFFFFC001
movl %eax, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_set.c
// Function: ft_set_ptr
void		ft_set_ptr(void *ptr, int *tab)
{
	int				i;
	int				j;
	char			tmp;
	unsigned char	*c_ptr;

	i = 79;
	c_ptr = (unsigned char *)ptr;
	while (i >= 0)
	{
		j = 0;
		while (j < 8 && i >= 0)
		{
			tmp = *c_ptr;
			tmp = (tmp >> j++) & 1;
			tab[i--] = tmp && 1 ? 1 : 0;
		}
		c_ptr++;
	}
}

// Assembly:
movl $0x4f, %ecx
movq %rcx, %rax
movl %eax, %r8d
xorl %edx, %edx
movsbl (%rdi), %ecx
movl %edx, %r9d
xorl %r10d, %r10d
btl %edx, %ecx
setb %r10b
leaq -0x1(%r8), %rcx
movl %r10d, (%rsi,%r8,4)
incq %rdx
cmpl $0x6, %r9d
ja 0x40ea
testl %r8d, %r8d
movq %rcx, %r8
jg 0x40c1
subl %edx, %eax
incl %eax
incq %rdi
testl %eax, %eax
jg 0x40b9
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_set.c
// Function: ft_zero
char		*ft_zero(void *ptr)
{
	long double zero;
	int			count;
	char		*tab_z;
	char		tab[65];

	zero = *(long double *)ptr;
	count = 0;
	if (zero < 0)
		zero = -zero;
	while ((int)zero == 0)
	{
		zero -= (int)zero;
		zero *= 10.0;
		count++;
	}
	tab_z = ft_strnew(count);
	tab_z[count-- - 1] = '\0';
	ft_zero_extend(tab, zero);
	while (count-- > 0)
		tab_z[count] = '0';
	ft_join_free(&tab_z, tab, 1, 0);
	return (tab_z);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x88, %rsp
fldt (%rdi)
fld %st(0)
fchs
fucomi %st(1), %st
fxch %st(1)
fcmovnbe %st(1), %st
fstp %st(1)
fnstcw 0x10(%rsp)
movzwl 0x10(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0x16(%rsp)
fldcw 0x16(%rsp)
fistl 0x24(%rsp)
fldcw 0x10(%rsp)
xorl %ebp, %ebp
cmpl $0x0, 0x24(%rsp)
jne 0x4165
xorl %ebp, %ebp
fmuls 0x20bb(%rip)            # 0x61f8
fnstcw 0xe(%rsp)
movzwl 0xe(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0x14(%rsp)
fldcw 0x14(%rsp)
fistl 0x20(%rsp)
fldcw 0xe(%rsp)
incl %ebp
cmpl $0x0, 0x20(%rsp)
je 0x4137
fstpt 0x34(%rsp)
movl %ebp, %ebx
movq %rbx, %rdi
callq 0x55d8
fldt 0x34(%rsp)
movq %rax, 0x28(%rsp)
xorl %ecx, %ecx
movb %cl, -0x1(%rax,%rbx)
movb %cl, 0x80(%rsp)
fnstcw 0xc(%rsp)
movzwl 0xc(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0x12(%rsp)
fldcw 0x12(%rsp)
fistl 0x18(%rsp)
fldcw 0xc(%rsp)
movl 0x18(%rsp), %eax
leal 0x30(%rax), %edx
movb %dl, 0x40(%rsp,%rcx)
movl %eax, 0x1c(%rsp)
fisubl 0x1c(%rsp)
incq %rcx
fmuls 0x2034(%rip)            # 0x61f8
cmpq $0x40, %rcx
jne 0x4189
fstp %st(0)
cmpl $0x2, %ebp
jl 0x41e4
movq 0x28(%rsp), %rax
movb $0x30, -0x2(%rax,%rbx)
decq %rbx
cmpq $0x1, %rbx
jg 0x41d1
leaq 0x28(%rsp), %rbx
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x327c
movq (%rbx), %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_extend.c
// Function: ft_str_rev_cpy
void		ft_str_rev_cpy(char *dest, char *src)
{
	int		len_src;
	int		len;

	len_src = ft_strlen(src);
	len = ft_strlen(dest);
	while (len_src)
		dest[--len] = src[--len_src];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5594
movq %rax, %r15
movq %rbx, %rdi
callq 0x5594
testl %r15d, %r15d
je 0x428e
movslq %eax, %rdx
movslq %r15d, %rax
leaq (%rax,%r14), %rcx
decq %rcx
negq %rax
addq %rbx, %rdx
decq %rdx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
movb %dil, (%rdx,%rsi)
decq %rsi
cmpq %rsi, %rax
jne 0x427e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_extend.c
// Function: ft_addition
char		*ft_addition(char *m, char *s)
{
	int		len;

	len = ft_strlen(m);
	ft_process_addition(m, s, len);
	ft_strdel(&s);
	return (m);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
callq 0x5594
movq (%r14), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x42c6
movq %r14, %rdi
callq 0x1d5c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_extend.c
// Function: ft_process_addition
static void	ft_process_addition(char *m, char *s, int size)
{
	char	*carry;
	int		res;
	char	*empty;
	int		tmp;

	tmp = size;
	carry = ft_strnew(size);
	ft_fill_with_zero(carry, size);
	empty = ft_strnew(size);
	ft_fill_with_zero(empty, size);
	while (size-- > 0)
	{
		if ((res = (m[size] - '0' + s[size] - '0')) > 9)
		{
			m[size] = res % 10 + '0';
			if (size - 1 > 0)
				carry[size - 1] = res / 10 + '0';
		}
		else
			m[size] = res + '0';
	}
	if (ft_strcmp(carry, empty) && tmp)
		ft_process_addition(m, carry, tmp);
	ft_strdel(&carry);
	ft_strdel(&empty);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %r13
movq %r13, %rdi
callq 0x55d8
movq %rax, (%rsp)
movl %ebx, %r12d
testl %r13d, %r13d
je 0x430e
leal -0x1(%rbx), %ecx
movslq %ecx, %rdx
subq %rcx, %rdx
addq %rdx, %rax
movq %rax, %rdi
movl $0x30, %esi
movq %r12, %rdx
callq 0x1050
movq %r13, %rdi
callq 0x55d8
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
je 0x433b
leal -0x1(%rbx), %ecx
movslq %ecx, %rdx
subq %rcx, %rdx
addq %rdx, %rax
movq %rax, %rdi
movl $0x30, %esi
movq %r12, %rdx
callq 0x1050
testl %ebx, %ebx
jle 0x43a1
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
movsbl -0x1(%r14,%r12), %ecx
movsbl -0x1(%r15,%r12), %edx
leal (%rcx,%rdx), %esi
addl $-0x30, %esi
cmpl $0x3a, %esi
jl 0x438e
addl %ecx, %edx
addl $-0x60, %edx
movl %edx, %ecx
imulq %rax, %rcx
shrq $0x23, %rcx
leal (%rcx,%rcx), %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %edx
orb $0x30, %dl
movb %dl, -0x1(%r14,%r12)
cmpq $0x3, %r12
jl 0x4393
addb $0x30, %cl
movq (%rsp), %rdx
movb %cl, -0x2(%rdx,%r12)
jmp 0x4393
movb %sil, -0x1(%r14,%r12)
decq %r12
leaq 0x1(%r12), %rcx
cmpq $0x1, %rcx
jg 0x4344
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x533c
testl %ebx, %ebx
je 0x43c5
testl %eax, %eax
je 0x43c5
movq (%rsp), %rsi
movq %r14, %rdi
movl %ebx, %edx
callq 0x42c6
movq %rsp, %rdi
callq 0x1d5c
leaq 0x8(%rsp), %rdi
callq 0x1d5c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_operate.c
// Function: ft_power_of_two
char		*ft_power_of_two(char *s)
{
	char	*ret;
	int		len;

	len = ft_strlen(s) + 1;
	ret = ft_strnew(len);
	ft_fill_with_zero(ret, len);
	ft_str_rev_cpy(ret, s);
	ret = ft_addition(ret, ft_strdup(ret));
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5594
incl %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x55d8
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
callq 0x4226
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4243
movq %r15, %rdi
callq 0x543c
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4294
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_operate.c
// Function: ft_get_int
char		*ft_get_int(int *tab, int size, int max)
{
	char		*nb;
	char		*tmp;
	char		*tmp_ret;

	nb = ft_strdup("0");
	tmp = ft_strdup("1");
	while (--size > max)
		ft_dup(&tmp, ft_power_of_two(tmp));
	while (size >= 0)
	{
		if (tab[size--])
		{
			tmp_ret = ft_strdup(tmp);
			ft_align(&tmp, &nb);
			nb = ft_addition(tmp_ret, nb);
		}
		ft_dup(&tmp, ft_power_of_two(tmp));
	}
	tmp_ret = nb;
	while (*nb == '0')
		nb++;
	nb = ft_strdup(nb);
	ft_strdel(&tmp_ret);
	ft_strdel(&tmp);
	return (nb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1d85(%rip), %rdi      # 0x61f3
callq 0x543c
movq %rax, 0x8(%rsp)
leaq 0x1d7d(%rip), %rdi      # 0x61fc
callq 0x543c
movq %rax, 0x10(%rsp)
decl %ebp
cmpl %r14d, %ebp
jle 0x44b4
leaq 0x10(%rsp), %r15
movq 0x10(%rsp), %rdi
callq 0x4406
movq %r15, %rdi
movq %rax, %rsi
callq 0x420c
decl %ebp
cmpl %r14d, %ebp
jg 0x4495
movl %r14d, %ebp
testl %ebp, %ebp
js 0x45e9
movl %ebp, %r12d
incq %r12
leaq 0x10(%rsp), %r14
cmpl $0x0, -0x4(%rbx,%r12,4)
je 0x45cb
movq 0x10(%rsp), %rdi
callq 0x543c
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5594
movq %rax, %rbp
movq 0x8(%rsp), %rdi
callq 0x5594
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x5594
movq %rax, %r13
cmpq %r15, %rbp
jbe 0x4553
movslq %r13d, %r15
movq %r15, %rdi
callq 0x55d8
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movl %r15d, %esi
callq 0x4226
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4243
leaq 0x8(%rsp), %rdi
callq 0x1d5c
movq 0x18(%rsp), %rdi
callq 0x543c
movq %rax, 0x8(%rsp)
jmp 0x45ad
movq 0x8(%rsp), %rdi
callq 0x5594
cmpq %rax, %r13
jae 0x45b7
movq 0x8(%rsp), %rdi
callq 0x5594
movslq %eax, %r15
movq %r15, %rdi
callq 0x55d8
movq %rax, 0x18(%rsp)
movq %rax, %rdi
movl %r15d, %esi
callq 0x4226
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4243
movq %r14, %rdi
callq 0x1d5c
movq 0x18(%rsp), %rdi
callq 0x543c
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1d5c
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4294
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4406
movq %r14, %rdi
movq %rax, %rsi
callq 0x420c
decq %r12
jg 0x44c7
movq 0x8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
cmpb $0x30, (%rdi)
jne 0x460c
incq %rdi
movq %rdi, 0x8(%rsp)
cmpb $0x30, (%rdi)
leaq 0x1(%rdi), %rdi
je 0x45fb
decq %rdi
callq 0x543c
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1d5c
leaq 0x10(%rsp), %rdi
callq 0x1d5c
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_precision.c
// Function: ft_get_prec
void		ft_get_prec(char **exp, int prec)
{
	char	*tmp;
	int		i;

	i = 0;
	tmp = ft_strdup(*exp);
	while (tmp[i] && tmp[i] != '.')
		i++;
	i++;
	while (tmp[i] && prec)
	{
		i++;
		prec--;
	}
	if (tmp[i])
		ft_prepare_carry(&tmp, i);
	else
		tmp[i] = '\0';
	while (prec-- > 0)
		ft_join_free(&tmp, "0", 1, 0);
	ft_dup(exp, ft_strdup(tmp));
	ft_strdel(&tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x543c
movq %rax, 0x8(%rsp)
xorl %ecx, %ecx
movzbl (%rax,%rcx), %edx
cmpl $0x2e, %edx
je 0x4674
testl %edx, %edx
je 0x4674
incq %rcx
jmp 0x4662
movl %ebp, %r12d
xorl %esi, %esi
leaq (%rax,%rsi), %rdx
movb 0x1(%rcx,%rdx), %dil
leaq 0x1(%rsi), %rdx
testb %dil, %dil
je 0x4693
cmpl %esi, %r12d
movq %rdx, %rsi
jne 0x4679
subq %rdx, %r12
leaq 0x1(%r12), %r13
testb %dil, %dil
je 0x47e4
leaq (%rcx,%rdx), %rsi
movl %esi, %esi
cmpb $0x35, (%rax,%rsi)
jl 0x46dc
leal (%rcx,%rdx), %edi
addq %rax, %rdi
incq %rdi
movzbl (%rdi), %r8d
incq %rdi
cmpl $0x30, %r8d
je 0x46b9
testl %r8d, %r8d
jne 0x46dc
movq %rax, %rdi
addq %rdx, %rdi
cmpb $0x34, -0x1(%rcx,%rdi)
jg 0x46dc
movb $0x30, (%rax,%rsi)
movq 0x8(%rsp), %rax
cmpb $0x35, (%rax,%rsi)
jl 0x47ed
movb $0x0, 0x1(%rax,%rsi)
movq 0x8(%rsp), %rax
movb $0x39, (%rax,%rsi)
movq 0x8(%rsp), %rdi
callq 0x5594
leaq 0x1(%rax), %rdi
callq 0x55d8
movq %rax, %r14
movb $0x30, (%rax)
movq 0x8(%rsp), %rax
movb (%rax), %al
testb %al, %al
je 0x4735
movl $0x1, %ecx
movb %al, (%r14,%rcx)
movq 0x8(%rsp), %rax
movb (%rax,%rcx), %al
incq %rcx
testb %al, %al
jne 0x4722
leaq 0x8(%rsp), %rdi
callq 0x1d5c
movq %r14, %rdi
callq 0x5594
leal -0x1(%rax), %edx
testl %edx, %edx
jle 0x47ab
movl $0x1, %ecx
cmpl $0x1, %ecx
jne 0x47ab
movl %edx, %ecx
cmpb $0x39, (%r14,%rcx)
jne 0x47ab
addl $-0x2, %eax
cmpb $0x2e, (%r14,%rax)
je 0x476d
movl %edx, %eax
movslq %eax, %rcx
leaq (%r14,%rcx), %rdx
movb -0x1(%r14,%rcx), %sil
movl $0x1, %ecx
cmpb $0x38, %sil
jg 0x478d
incb %sil
movb %sil, -0x1(%rdx)
xorl %ecx, %ecx
movl %eax, %esi
cmpb $0x2e, (%r14,%rsi)
je 0x479e
addq %r14, %rsi
movq %rsi, %rdx
jmp 0x47a1
incq %rdx
movb $0x30, (%rdx)
leal -0x1(%rax), %edx
testl %edx, %edx
jg 0x4753
cmpb $0x30, (%r14)
jne 0x47cf
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
incq %r14
movq %r14, %rdi
callq 0x543c
movq %rax, %r14
movq %r15, %rdi
callq 0x1d5c
movq %r14, %rdi
callq 0x5594
movb $0x0, -0x1(%rax,%r14)
movq %r14, 0x8(%rsp)
jmp 0x47f1
addq %rdx, %rax
movb $0x0, (%rcx,%rax)
jmp 0x47f1
movb $0x0, (%rax,%rsi)
testl %r13d, %r13d
jle 0x4821
addq $0x2, %r12
leaq 0x19f2(%rip), %r14      # 0x61f3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x327c
decl %r12d
cmpl $0x1, %r12d
jg 0x4806
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
callq 0x543c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x420c
movq %r14, %rdi
callq 0x1d5c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	size_t		i;

	i = 0;
	while (s1[i] && s1[i] == s2[i])
		i++;
	return ((int)((unsigned char)s1[i] - (unsigned char)s2[i]));
}

// Assembly:
movb (%rdi), %al
xorl %ecx, %ecx
testb %al, %al
je 0x5352
cmpb (%rsi,%rcx), %al
jne 0x5352
movb 0x1(%rdi,%rcx), %al
incq %rcx
jmp 0x5340
movzbl %al, %eax
movzbl (%rsi,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strcasecmp.c
// Function: ft_strcasecmp
int					ft_strcasecmp(const char *s1, const char *s2)
{
	size_t	i;
	int		ret;

	i = 0;
	while (s1[i] != '\0')
	{
		if ((ret = ft_cmp_char(s1[i], s2[i])))
			return (ret);
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb (%rdi), %al
testb %al, %al
je 0x53a9
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl $0xff, %r13d
movsbl (%rbx,%r12), %r15d
movsbl %al, %edi
callq 0x1f44
movl %eax, %ebp
movl %r15d, %edi
callq 0x1f44
andl %r13d, %ebp
andl %r13d, %eax
subl %eax, %ebp
jne 0x53ab
movb 0x1(%r14,%r12), %al
incq %r12
testb %al, %al
jne 0x537c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	size_t			i;
	unsigned char	c_cp;

	i = 0;
	c_cp = (unsigned char)c;
	while (s[i])
	{
		if (c_cp == s[i])
			return ((char *)s + i);
		i++;
	}
	return ((s[i] == c_cp) ? ((char *)s + i) : NULL);
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x53dc
movzbl %sil, %ecx
xorl %eax, %eax
movsbl %dl, %edx
cmpl %edx, %ecx
je 0x53eb
movb 0x1(%rdi,%rax), %dl
incq %rax
testb %dl, %dl
jne 0x53c8
jmp 0x53de
xorl %eax, %eax
addq %rax, %rdi
xorl %eax, %eax
testb %sil, %sil
cmoveq %rdi, %rax
retq
addq %rax, %rdi
movq %rdi, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strncpy.c
// Function: ft_strncpy
char	*ft_strncpy(char *dst, const char *src, size_t len)
{
	size_t	i;

	i = 0;
	while (src[i] && i < len)
	{
		dst[i] = src[i];
		i++;
	}
	while (i < len)
		dst[i++] = '\0';
	return (dst);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rsi), %al
testb %al, %al
sete %cl
testq %rdx, %rdx
sete %dil
orb %cl, %dil
jne 0x5426
xorl %ecx, %ecx
movb %al, (%rbx,%rcx)
leaq 0x1(%rcx), %rdi
cmpq %rdx, %rdi
jae 0x5428
movb 0x1(%rsi,%rcx), %al
movq %rdi, %rcx
testb %al, %al
jne 0x540d
jmp 0x5428
xorl %edi, %edi
subq %rdi, %rdx
jbe 0x5437
addq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strndup.c
// Function: ft_strndup
char	*ft_strndup(const char *s1, size_t n)
{
	char	*new_str;
	size_t	len;

	len = ft_strnlen(s1, n);
	if (!(new_str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	ft_strncpy(new_str, s1, len);
	new_str[len] = '\0';
	return (new_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x55a8
movq %rax, %r15
leaq 0x1(%rax), %rdi
callq 0x1070
testq %rax, %rax
je 0x549a
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x53f4
movb $0x0, (%r14,%r15)
jmp 0x549d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*s_new;
	size_t	len_s1;
	size_t	len_s2;

	if (!s1 && !s2)
		return (NULL);
	if (!s1)
		s_new = ft_strdup((char *)s2);
	else if (!s2)
		s_new = ft_strdup((char *)s1);
	else
	{
		len_s1 = ft_strlen(s1);
		len_s2 = ft_strlen(s2);
		if (!(s_new = (char *)malloc(sizeof(char) * (len_s1 + len_s2 + 1))))
			return (NULL);
		ft_strncpy(s_new, s1, ft_strlen(s1));
		ft_strcpy(s_new + ft_strlen(s1), s2);
	}
	return (s_new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x5532
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x553e
testq %rbx, %rbx
je 0x5543
movq %r14, %rdi
callq 0x5594
movq %rax, %r15
movq %rbx, %rdi
callq 0x5594
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x5532
movq %rax, %r15
movq %r14, %rdi
callq 0x5594
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x53f4
movq %r14, %rdi
callq 0x5594
movq %r15, %rdi
addq %rax, %rdi
movq %rbx, %rsi
callq 0x59cc
jmp 0x5535
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
jmp 0x5546
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x543c
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strsub.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char	*new_str;

	if (!s)
		return (NULL);
	if (!(new_str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	new_str = ft_strncpy(new_str, s + start, len);
	new_str[len] = '\0';
	return (new_str);
}

// Assembly:
testq %rdi, %rdi
je 0x5588
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1(%rdx), %rdi
callq 0x1070
testq %rax, %rax
je 0x558b
movl %ebp, %ecx
addq %rcx, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x53f4
movb $0x0, (%rax,%rbx)
jmp 0x558d
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strupcase.c
// Function: ft_strupcase
char	*ft_strupcase(char *str)
{
	int		i;

	i = 0;
	if (!str)
		return (NULL);
	while (str[i])
	{
		if (ft_islower(str[i]))
			str[i] -= 32;
		i++;
	}
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x564a
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x564c
movq %rbx, %r14
movsbl %al, %edi
callq 0x5698
testl %eax, %eax
je 0x563d
addb $-0x20, (%r14)
movb 0x1(%r14), %al
incq %r14
testb %al, %al
jne 0x562d
jmp 0x564c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/string/ft_strlowcase.c
// Function: ft_strlowcase
char	*ft_strlowcase(char *str)
{
	int		i;

	i = 0;
	if (!str)
		return (NULL);
	while (str[i])
	{
		if (ft_isupper(str[i]))
			str[i] += 32;
		i++;
	}
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x568a
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x568c
movq %rbx, %r14
movsbl %al, %edi
callq 0x56a4
testl %eax, %eax
je 0x567d
addb $0x20, (%r14)
movb 0x1(%r14), %al
incq %r14
testb %al, %al
jne 0x566d
jmp 0x568c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/memory/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	unsigned char	*dst_cp;
	unsigned char	*src_cp;

	dst_cp = (unsigned char *)dst;
	src_cp = (unsigned char *)src;
	while (n-- > 0)
		*dst_cp++ = *src_cp++;
	return (dst);
}

// Assembly:
movq %rdi, %rax
testq %rdx, %rdx
je 0x56ca
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x56ba
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/conversion/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	long		nbr;
	size_t		i;

	nbr = 0;
	i = 0;
	while (*str == ' ' || (*str >= 9 && *str <= 13))
		str++;
	if (*str == '-' || *str == '+')
		i++;
	while (str[i] != '\0')
	{
		if (str[i] < '0' || str[i] > '9')
			break ;
		nbr = nbr * 10 + str[i++] - '0';
	}
	if (str[0] == '-')
	{
		if (nbr + 1 > LONG_MAX)
			return (0);
		return ((int)nbr * -1);
	}	
	if (nbr > LONG_MAX)
		return (-1);
	return ((int)nbr);
}

// Assembly:
incq %rdi
movb -0x1(%rdi), %cl
movzbl %cl, %eax
leal -0x9(%rax), %edx
cmpl $0x5, %edx
jb 0x56cc
cmpl $0x20, %eax
je 0x56cc
leal -0x2b(%rcx), %eax
xorl %esi, %esi
testb $-0x3, %al
sete %sil
movb -0x1(%rdi,%rsi), %al
leal -0x3a(%rax), %r8d
xorl %edx, %edx
cmpb $-0xa, %r8b
jb 0x571f
addq %rsi, %rdi
xorl %edx, %edx
leaq (%rdx,%rdx,4), %rdx
movzbl %al, %eax
leaq (%rax,%rdx,2), %rdx
addq $-0x30, %rdx
movb (%rdi), %al
leal -0x3a(%rax), %esi
incq %rdi
cmpb $-0xb, %sil
ja 0x5702
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/list/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void const *content, size_t content_size)
{
	t_list	*list;

	if (!(list = (t_list *)malloc(sizeof(t_list))))
		return (NULL);
	list->next = NULL;
	if (!content)
	{
		list->content = NULL;
		list->content_size = 0;
	}
	else
	{
		if (!(list->content = malloc(content_size)))
		{
			free(list);
			list = NULL;
			return (NULL);
		}
		list->content_size = content_size;
		list->content = ft_memcpy(list->content, content, content_size);
	}
	return (list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1070
testq %rax, %rax
je 0x578d
movq %rax, %rbx
movq $0x0, 0x10(%rax)
testq %r15, %r15
je 0x577d
movq %r14, %rdi
callq 0x1070
movq %rax, (%rbx)
testq %rax, %rax
je 0x5785
movq %r14, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x56b0
movq %rax, (%rbx)
jmp 0x578f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x578f
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_functions_nb.c
// Function: ft_itoa_base_l
char		*ft_itoa_base_l(long long int value, int base)
{
	size_t				i;
	long long int		tmp;
	char				*str;

	i = 0;
	if (value <= 0)
		i++;
	tmp = value;
	while (tmp)
	{
		tmp /= base;
		i++;
	}
	if (!(str = (char *)malloc(sizeof(char) * (i + 1))))
		return (NULL);
	i = 0;
	fill_str(str, value, &i, base);
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
testq %r14, %r14
setle %dil
je 0x57c3
movslq %ebx, %rcx
movq %r14, %rax
cqto
idivq %rcx
incq %rdi
testq %rax, %rax
jne 0x57b6
movq %rdi, (%rsp)
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x57fd
movq %rax, %r15
movq %rsp, %r12
movq $0x0, (%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x580f
movq (%r12), %rax
movb $0x0, (%r15,%rax)
jmp 0x5800
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_functions_nb.c
// Function: fill_str
static void	fill_str(char *str, long long int nbr, size_t *i, int base)
{
	if (nbr < 0)
	{
		if (base == 10)
		{
			str[(*i)++] = '-';
			if (nbr < -9223372036854775807)
			{
				str[1] = '9';
				nbr /= 10;
				(*i)++;
			}
		}
		fill_str(str, nbr * -1, i, base);
	}
	else if (nbr < base)
	{
		str[*i] = nbr < 10 ? (char)nbr + '0' : (char)nbr % 10 + 'A';
		(*i)++;
	}
	else
	{
		fill_str(str, nbr / base, i, base);
		fill_str(str, nbr % base, i, base);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq %ecx, %r12
movabsq $-0xccccccccccccccc, %r13 # imm = 0xF333333333333334
testq %r15, %r15
js 0x585a
cmpq %r15, %r12
jg 0x5886
movq %r15, %rax
cqto
idivq %r12
movq %rdx, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x580f
jmp 0x5832
cmpl $0xa, %ebp
jne 0x5881
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0x2d, (%r14,%rax)
movq %r15, %rax
negq %rax
jno 0x5881
movb $0x39, 0x1(%r14)
incq (%rbx)
movq %r13, %r15
negq %r15
jmp 0x5832
cmpq $0x9, %r15
jg 0x5892
addl $0x30, %r15d
jmp 0x58bb
movsbq %r15b, %rax
movsbl %r15b, %ecx
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rax
addl %edx, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %ecx
addl $0x41, %ecx
movl %ecx, %r15d
movq (%rbx), %rax
movb %r15b, (%r14,%rax)
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_functions_nb.c
// Function: ft_itoa_base_lu
char		*ft_itoa_base_lu(unsigned long long int value, unsigned int base)
{
	size_t					i;
	unsigned long long int	tmp;
	char					*str;

	i = 0;
	if (value <= 0)
		i++;
	tmp = value;
	while (tmp)
	{
		tmp /= base;
		i++;
	}
	if (!(str = (char *)malloc(sizeof(char) * (i + 1))))
		return (NULL);
	i = 0;
	fill_str_lu(str, value, &i, base);
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
testq %r14, %r14
sete %dil
je 0x5904
movl %ebx, %esi
movq %r14, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
incq %rdi
cmpq %rsi, %rcx
movq %rax, %rcx
jae 0x58f1
movq %rdi, (%rsp)
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x593e
movq %rax, %r15
movq %rsp, %r12
movq $0x0, (%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x5950
movq (%r12), %rax
movb $0x0, (%r15,%rax)
jmp 0x5941
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_functions_nb.c
// Function: fill_str_lu
static void	fill_str_lu(char *str, unsigned long long int nbr,
			size_t *i, unsigned int base)
{
	if (nbr < base)
	{
		if (nbr < 10)
			str[*i] = (char)nbr + '0';
		else
			str[*i] = (char)nbr % 10 + 'A';
		(*i)++;
	}
	else
	{
		fill_str_lu(str, nbr / base, i, base);
		fill_str_lu(str, nbr % base, i, base);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl %ecx, %r12d
cmpq %r15, %r12
ja 0x5988
movq %r15, %rax
xorl %edx, %edx
divq %r12
movq %rdx, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x5950
jmp 0x5966
cmpq $0x9, %r15
ja 0x5994
orb $0x30, %r15b
jmp 0x59b8
movsbq %r15b, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x22, %rax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %r15d
addb $0x41, %r15b
movq (%rbx), %rax
movb %r15b, (%r14,%rax)
incq (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/mime.c
// Function: MIME_version
int MIME_version( void )
{
    fprintf(stderr,"ripMIME: %s\n", LIBMIME_VERSION);
    MIMEH_version();
#ifdef RIPOLE
    OLE_version();
#endif

    return 0;
}

// Assembly:
pushq %rax
movq 0x1dbba(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x10328(%rip), %rsi     # 0x12770
leaq 0x1032e(%rip), %rdx     # 0x1277d
xorl %eax, %eax
callq 0x2220
callq 0x7ea8
callq 0x2464
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/ripmime.c
// Function: RIPMIME_report_filename_decoded
int RIPMIME_report_filename_decoded (char *filename, char *contenttype)
{
   char *p;

   p = strrchr(filename,'/');
   if (!p) p = filename; else p++;

   if (contenttype != NULL)
   {
       LOGGER_log ("Decoding content-type=%s filename=%s", contenttype, p);
   }
   else
   {
       LOGGER_log ("Decoding filename=%s", p);
   }

   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
testq %rbx, %rbx
je 0x25b3
leaq 0xfa95(%rip), %rdi      # 0x1203c
movq %rbx, %rsi
xorl %eax, %eax
callq 0xc960
jmp 0x25c4
leaq 0xfaa7(%rip), %rdi      # 0x12061
movq %rdx, %rsi
xorl %eax, %eax
callq 0xc960
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/ripmime.c
// Function: RIPMIME_unpack_single
int RIPMIME_unpack_single( struct RIPMIME_globals *glb, char *fname )
{
   int result = 0;

   /** Set the alarm timeout feature. **/
   if (glb->timeout > 0) {
       signal(SIGALRM, RIPMIME_signal_alarm);
       alarm(glb->timeout);
   }

   MIMEH_set_outputdir (glb->dir);
   result = MIME_unpack (glb->dir, fname, 0);

   // do any last minute things

   MIME_close ();

   return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x14(%rdi)
jle 0x2f48
leaq -0x50(%rip), %rsi       # 0x2ee5
movl $0xe, %edi
callq 0x2210
movl 0x14(%r14), %edi
callq 0x2190
movq 0x8(%r14), %rdi
callq 0x7f6f
movq 0x8(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x504d
movl %eax, %ebx
callq 0x76c8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/strstack.c
// Function: SS_done
int SS_done( struct SS_object *ss )
{
	struct SS_node *next;

	while ((ss->stringstack != NULL)&&(ss->count > 0))
	{
		DSS LOGGER_log("%s:%d:SS_done: Popping off %s",FL,ss->stringstack->data);
		next = ss->stringstack->next;
		free(ss->stringstack->data);
		free(ss->stringstack);
		ss->stringstack = next;
		ss->count--;
	}

	ss->stringstack = NULL;
	ss->count = 0;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x32ce
leaq 0xf1fe(%rip), %r14      # 0x1247f
leaq 0xf215(%rip), %r15      # 0x1249d
cmpl $0x0, 0x8(%rbx)
jle 0x32ce
cmpl $0x0, (%rbx)
je 0x32a9
movq (%r12), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl $0x6c, %edx
xorl %eax, %eax
callq 0xc960
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x10(%rax), %r12
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
movq %r12, 0x10(%rbx)
decl 0x8(%rbx)
testq %r12, %r12
jne 0x3288
movq $0x0, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/strstack.c
// Function: SS_dump
int SS_dump( struct SS_object *ss )
{
	struct SS_node *n = ss->stringstack;

	while (n != NULL)
	{
		LOGGER_log("%s",n->data);
		n = n->next;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x3315
leaq 0x14d8e(%rip), %rbx     # 0x1808d
movq (%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc960
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x32ff
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/strstack.c
// Function: SS_push
int SS_push( struct SS_object *ss, char *data, size_t data_length )
{

	struct SS_node *node = malloc(sizeof(struct SS_node));


	if (node)
	{
		DSS LOGGER_log("%s:%d:SS_push: Pushing %s to %p, stack count = %d",FL,data, ss->stringstack, ss->count);
		node->next = ss->stringstack;
		ss->stringstack = node;
		ss->stringstack->data = strdup(data);
		ss->stringstack->data_length = data_length;
		ss->count++;
	}
	else
	    {
		LOGGER_log("%s:%d:SS_push:ERROR: Cannot allocate memory for string stack PUSH, %s", FL, strerror(errno));
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x18, %edi
callq 0x22b0
testq %rax, %rax
je 0x3391
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x336d
movq 0x10(%r14), %r8
movl 0x8(%r14), %r9d
leaq 0xf151(%rip), %rdi      # 0x124a8
leaq 0xf13f(%rip), %rsi      # 0x1249d
movl $0xaf, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xc960
movq 0x10(%r14), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x10(%r14)
movq %r15, %rdi
callq 0x23b0
movq %rax, (%r12)
movq %rbx, 0x8(%r12)
incl 0x8(%r14)
jmp 0x33ba
callq 0x2060
movl (%rax), %edi
callq 0x23c0
leaq 0xf136(%rip), %rdi      # 0x124da
leaq 0xf0f2(%rip), %rsi      # 0x1249d
movl $0xb8, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc960
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/strstack.c
// Function: SS_pop
char *SS_pop( struct SS_object *ss )
{

	struct SS_node *node = ss->stringstack;

	if ((ss->stringstack)&&(ss->count > 0))
	{
		ss->stringstack = ss->stringstack->next;
		PLD_strncpy(ss->datastacksafe,node->data, SS_STRLEN_MAX);
		free(node->data);
		free(node);
		ss->count--;
	} else return NULL;

	return ss->datastacksafe;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x3411
movq %rdi, %r14
cmpl $0x0, 0x8(%rdi)
jle 0x3411
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rbx
movq (%r15), %rsi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0xbfb6
movq (%r15), %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
decl 0x8(%r14)
jmp 0x3413
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/strstack.c
// Function: SS_cmp
char *SS_cmp( struct SS_object *ss, char *find_me, size_t find_me_len )
{
	struct SS_node *n = ss->stringstack;
	int hit=0;

	while ((n != NULL)&&(hit == 0))
	{
		if (strncmp(find_me, n->data, find_me_len) == 0) hit++;
		if (hit == 0) n = n->next;
	}

	if (hit == 0) return NULL;
	else return n->data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x3468
movq %rdx, %rbx
movq %rsi, %r14
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x20a0
testl %eax, %eax
setne %cl
je 0x345d
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x346a
testl %eax, %eax
jne 0x3444
jmp 0x346a
movb $0x1, %cl
testb %cl, %cl
je 0x3472
xorl %eax, %eax
jmp 0x3475
movq (%r15), %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/mime.c
// Function: MIME_set_debug
int MIME_set_debug( int level )
{
    glb.debug = level;

    BS_set_debug(level);
    TNEF_set_debug(level);
    MIMEH_set_debug(level);
    MDECODE_set_debug(level);
    UUENCODE_set_debug(level);
    FNFILTER_set_debug(level);
    return glb.debug;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, 0x1de72(%rip)     # 0x21300
callq 0xd381
movl %ebx, %edi
callq 0xb393
movl %ebx, %edi
callq 0x7f66
movl %ebx, %edi
callq 0xcb27
movl %ebx, %edi
callq 0xd997
movl %ebx, %edi
callq 0xe5ab
movl 0x1de44(%rip), %eax     # 0x21300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/inflex[P]ripMIME/mime.c
// Function: MIME_set_quiet
int MIME_set_quiet( int level )
{
    glb.quiet = level;
    MIME_set_debug(0);
    MIME_set_verbosity(0);
    return glb.quiet;
}

// Assembly:
pushq %rax
movl %edi, 0x1de3f(%rip)     # 0x21304
xorl %edi, %edi
callq 0x3485
xorl %edi, %edi
callq 0x34db
movl 0x1de2b(%rip), %eax     # 0x21304
popq %rcx
retq