LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rsi, %r14
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x3df3
movq %rdi, %r15
movq %rbx, 0x10(%rsp)
movl (%rdi), %edi
testl %edi, %edi
je 0x3de8
movl 0x34(%r14), %ebx
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq %r12, %rsi
callq 0x3194
testl %eax, %eax
je 0x3e21
movl (%r15,%rbp,4), %edi
callq 0x31c9
cmpl $0x0, 0x2c(%r14)
je 0x3d9b
subl %eax, %ebx
js 0x3dd3
movl (%r15,%rbp,4), %edi
movl %eax, %esi
callq 0x3c24
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %rax, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3287
movq %r13, %rdi
callq 0x1d7c
movl 0x4(%r15,%rbp,4), %edi
incq %rbp
testl %edi, %edi
jne 0x3d77
jmp 0x3de8
testq %rbp, %rbp
jne 0x3dbd
movl $0x1, %edi
callq 0x5b30
movq %rax, (%rsp)
jmp 0x3dbd
cmpl $0x0, (%r15)
movq 0x10(%rsp), %rbx
je 0x3e28
movq (%rsp), %rdi
movq %rsp, %r15
movq %rdi, (%r15)
movq %r14, %rsi
callq 0x360a
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x1d7c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x3e12
movl $0x1, %edi
callq 0x5b30
movq %rax, %rdi
jmp 0x3df7
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x239f(%rip), %rsi      # 0x61e8
callq 0x58b4
testl %eax, %eax
je 0x3e78
leaq 0x238a(%rip), %rsi      # 0x61e3
movq %r14, %rdi
callq 0x58b4
testl %eax, %eax
je 0x3e78
leaq 0x237b(%rip), %rsi      # 0x61e7
movq %r14, %rdi
callq 0x58b4
testl %eax, %eax
jne 0x3e8b
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_O3/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 0x2340(%rip), %rsi      # 0x61e7
callq 0x58b4
testl %eax, %eax
je 0x3ede
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3ede
cmpb $0x2d, (%rdi)
jne 0x3ede
incq %rdi
callq 0x598c
movq %r14, %rdi
movq %rax, %rsi
callq 0x4768
movl $0x1, 0x3c(%rbx)
movl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x40ec
leaq 0x1c(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x409c
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
movl $0x40, %edx
callq 0x40d4
movslq (%r12), %r15
cmpq $0x4000, %r15           # imm = 0x4000
jl 0x3f6e
leaq 0x20(%rsp), %rdi
callq 0x496c
testl %eax, %eax
leaq 0x228e(%rip), %rax      # 0x61e3
leaq 0x228c(%rip), %rdi      # 0x61e8
cmoveq %rax, %rdi
callq 0x598c
movq %rax, (%rsp)
jmp 0x4063
cmpl $0xffffc001, %r15d      # imm = 0xFFFFC001
jne 0x3f8c
leaq 0x226e(%rip), %rdi      # 0x61ec
callq 0x598c
movq %rax, (%rsp)
jmp 0x4053
testl %r15d, %r15d
js 0x4004
leal 0x1(%r15), %esi
leaq 0x20(%rsp), %rdi
movl $0x40, %edx
callq 0x49d5
movq %rax, (%rsp)
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
leaq 0x223f(%rip), %rsi      # 0x61f6
movq %rax, %rdi
callq 0x5a0c
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x1d7c
xorl %edi, %edi
movl $0x3f, %esi
subl %r15d, %esi
leaq 0x24(%rsp,%r15,4), %rax
cmovaeq %rax, %rdi
callq 0x4da0
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq (%rsp), %rdi
movq %rdi, (%r14)
leaq 0x1(%rax), %rsi
callq 0x5a0c
movq %rax, (%rsp)
movq %r14, %rdi
jmp 0x4046
movq %r14, %rdi
callq 0x4120
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq (%rsp), %rsi
leaq 0x21d3(%rip), %rdi      # 0x61f5
callq 0x5a0c
movq %rax, (%rsp)
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5a0c
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x1d7c
movq %r15, %rdi
callq 0x1d7c
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x4bac
movq (%r14), %rax
cmpb $0x6e, (%rax)
je 0x408b
cmpl $0x1, 0x120(%rsp)
jne 0x408b
leaq 0x1f8b(%rip), %rsi      # 0x6004
movq %rsp, %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3287
movq (%rbx), %rax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5ae0
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ae0
testl %r15d, %r15d
je 0x47ea
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 0x47da
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
callq 0x5ae0
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x482e
movq %r15, %rdi
callq 0x1d7c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movslq %edx, %rbx
movq %rbx, %rdi
callq 0x5b30
movq %rax, %r15
movq %rax, 0x20(%rsp)
testl %ebx, %ebx
je 0x4910
movl %ebp, 0xc(%rsp)
leal -0x1(%rbx), %eax
movslq %eax, %r13
subq %rax, %r13
movq %r15, 0x10(%rsp)
addq %r13, %r15
movl %ebx, %ebp
movq %r15, %rdi
movl $0x30, %esi
movq %rbp, %rdx
callq 0x1050
movq %rbx, %rdi
callq 0x5b30
movq %rax, %r15
addq %rax, %r13
movq %r13, %rdi
movl $0x30, %esi
movq %rbp, %rdx
callq 0x1050
movq %r15, %rsi
movq %r15, 0x18(%rsp)
testl %ebx, %ebx
jle 0x4922
movq 0x10(%rsp), %r15
movsbl -0x1(%r14,%rbp), %eax
movsbl -0x1(%r12,%rbp), %ecx
addl %ecx, %eax
addl $-0x30, %eax
cmpl $0x3a, %eax
jl 0x48f8
addb $-0x30, %al
movzbl %al, %ecx
imull $0xcd, %ecx, %eax
shrl $0xb, %eax
leal (%rax,%rax), %edx
leal (%rdx,%rdx,4), %edx
subb %dl, %cl
orb $0x30, %cl
movb %cl, -0x1(%r14,%rbp)
cmpq $0x3, %rbp
jb 0x48fd
addb $0x30, %al
movb %al, -0x2(%r15,%rbp)
jmp 0x48fd
movb %al, -0x1(%r14,%rbp)
decq %rbp
leaq 0x1(%rbp), %rax
cmpq $0x1, %rax
ja 0x48b5
movl 0xc(%rsp), %ebp
jmp 0x492b
movq %rbx, %rdi
callq 0x5b30
movq %rax, %rsi
movq %rax, 0x18(%rsp)
jmp 0x492b
movl 0xc(%rsp), %ebp
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x588c
testl %ebp, %ebp
je 0x4948
testl %eax, %eax
je 0x4948
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x482e
leaq 0x20(%rsp), %rdi
callq 0x1d7c
leaq 0x18(%rsp), %rdi
callq 0x1d7c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5ae0
incl %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x5b30
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
callq 0x4782
movq %r15, %rdi
movq %rbx, %rsi
callq 0x479f
movq %r15, %rdi
callq 0x598c
movq %r15, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47f0
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1801(%rip), %rdi      # 0x61f3
callq 0x598c
movq %rax, %r14
movq %rax, 0x8(%rsp)
leaq 0x188a(%rip), %rdi      # 0x6290
callq 0x598c
movq %rax, 0x10(%rsp)
decl %ebp
cmpl %r15d, %ebp
jle 0x4a3b
leaq 0x10(%rsp), %r12
movq 0x10(%rsp), %rdi
callq 0x498a
movq %r12, %rdi
movq %rax, %rsi
callq 0x4768
decl %ebp
cmpl %r15d, %ebp
jg 0x4a1c
movl %r15d, %ebp
testl %ebp, %ebp
js 0x4b55
movl %ebp, %r14d
cmpl $0x0, (%rbx,%r14,4)
movq 0x10(%rsp), %rdi
je 0x4b31
callq 0x598c
movq %rax, %r12
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5ae0
movq %rax, %rbp
movq 0x8(%rsp), %rdi
callq 0x5ae0
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x5ae0
movq %rax, %r13
cmpq %r15, %rbp
jbe 0x4ab4
movslq %r13d, %r15
movq %r15, %rdi
callq 0x5b30
movq %rax, %r13
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl %r15d, %esi
callq 0x4782
leaq 0x8(%rsp), %rbp
jmp 0x4af0
movq 0x8(%rsp), %rdi
callq 0x5ae0
cmpq %rax, %r13
jae 0x4b1a
movq 0x8(%rsp), %rdi
callq 0x5ae0
movslq %eax, %r15
movq %r15, %rdi
callq 0x5b30
movq %rax, %r13
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movl %r15d, %esi
callq 0x4782
leaq 0x10(%rsp), %rbp
movq (%rbp), %rsi
movq %r13, %rdi
callq 0x479f
movq %rbp, %rdi
callq 0x1d7c
movq %r13, %rdi
callq 0x598c
movq %rax, (%rbp)
leaq 0x20(%rsp), %rdi
callq 0x1d7c
movq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x47f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
decq %r14
callq 0x498a
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x4768
cmpq $-0x1, %r14
jne 0x4a46
movq 0x8(%rsp), %r14
movq %r14, 0x18(%rsp)
cmpb $0x30, (%r14)
jne 0x4b75
incq %r14
movq %r14, 0x8(%rsp)
cmpb $0x30, (%r14)
leaq 0x1(%r14), %r14
je 0x4b63
decq %r14
movq %r14, %rdi
callq 0x598c
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1d7c
leaq 0x10(%rsp), %rdi
callq 0x1d7c
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_O3/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 0x598c
movq %rax, %r14
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
cmpl $0x2e, %ecx
je 0x4be4
testl %ecx, %ecx
je 0x4be4
incq %rax
jmp 0x4bd1
movl %ebp, %r12d
xorl %edx, %edx
leaq (%r14,%rdx), %rcx
movb 0x1(%rax,%rcx), %sil
leaq 0x1(%rdx), %rcx
testb %sil, %sil
je 0x4c03
cmpl %edx, %r12d
movq %rcx, %rdx
jne 0x4be9
subq %rcx, %r12
leaq 0x1(%r12), %r13
testb %sil, %sil
je 0x4d3d
leaq (%rax,%rcx), %rdx
movl %edx, %edx
cmpb $0x35, (%r14,%rdx)
jl 0x4d38
leal (%rax,%rcx), %esi
addq %r14, %rsi
incq %rsi
movb (%rsi), %dil
testb %dil, %dil
je 0x4c41
incq %rsi
cmpb $0x30, %dil
je 0x4c2e
jmp 0x4c52
movq %r14, %rsi
addq %rcx, %rsi
cmpb $0x35, -0x1(%rax,%rsi)
jl 0x4d38
movw $0x39, (%r14,%rdx)
movq %r14, %rdi
callq 0x5ae0
leaq 0x1(%rax), %rdi
callq 0x5b30
movq %rax, %r14
movb $0x30, (%rax)
movq 0x8(%rsp), %rax
movb (%rax), %al
testb %al, %al
je 0x4c93
movl $0x1, %ecx
movb %al, (%r14,%rcx)
movq 0x8(%rsp), %rax
movb (%rax,%rcx), %al
incq %rcx
testb %al, %al
jne 0x4c80
leaq 0x8(%rsp), %rdi
callq 0x1d7c
movq %r14, %rdi
callq 0x5ae0
leal -0x1(%rax), %ecx
testl %ecx, %ecx
jle 0x4cff
movl $0x1, %edx
cmpl $0x1, %edx
jne 0x4cff
movl %ecx, %edx
cmpb $0x39, (%r14,%rdx)
jne 0x4cff
movl %eax, %edx
addl $-0x2, %edx
cmpb $0x2e, (%r14,%rdx)
movl %ecx, %eax
cmovel %edx, %eax
leaq (%r14,%rax), %rcx
movb -0x1(%r14,%rax), %sil
movl $0x1, %edx
cmpb $0x38, %sil
jg 0x4ceb
incb %sil
movb %sil, -0x1(%rcx)
xorl %edx, %edx
xorl %esi, %esi
cmpb $0x2e, (%rcx)
sete %sil
movb $0x30, (%rcx,%rsi)
leal -0x1(%rax), %ecx
testl %ecx, %ecx
jg 0x4cb1
cmpb $0x30, (%r14)
jne 0x4d23
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
incq %r14
movq %r14, %rdi
callq 0x598c
movq %rax, %r14
movq %r15, %rdi
callq 0x1d7c
movq %r14, %rdi
callq 0x5ae0
movb $0x0, -0x1(%rax,%r14)
movq %r14, 0x8(%rsp)
jmp 0x4d3d
movb $0x0, (%r14,%rdx)
testl %r13d, %r13d
jle 0x4d72
addq $0x2, %r12
leaq 0x14a6(%rip), %r14      # 0x61f3
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3287
decl %r12d
cmpl $0x1, %r12d
ja 0x4d52
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x598c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4768
leaq 0x8(%rsp), %rdi
callq 0x1d7c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x58ab
cmpb (%rsi,%rcx), %al
jne 0x58a6
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
jne 0x5894
xorl %eax, %eax
movzbl %al, %eax
jmp 0x58ad
xorl %eax, %eax
movzbl (%rsi,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5901
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl $0xff, %r13d
movsbl (%rbx,%r12), %r15d
movsbl %al, %edi
callq 0x1f9c
movl %eax, %ebp
movl %r15d, %edi
callq 0x1f9c
andl %r13d, %ebp
andl %r13d, %eax
subl %eax, %ebp
jne 0x5903
movb 0x1(%r14,%r12), %al
incq %r12
testb %al, %al
jne 0x58d4
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_O3/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
movzbl %sil, %ecx
xorl %eax, %eax
testb %dl, %dl
je 0x5930
movsbl %dl, %edx
cmpl %edx, %ecx
je 0x593c
movb 0x1(%rdi,%rax), %dl
incq %rax
jmp 0x591c
addq %rax, %rdi
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rdi, %rax
retq
addq %rax, %rdi
movq %rdi, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5976
xorl %ecx, %ecx
movb %al, (%rbx,%rcx)
leaq 0x1(%rcx), %rdi
cmpq %rdx, %rdi
jae 0x5978
movb 0x1(%rsi,%rcx), %al
movq %rdi, %rcx
testb %al, %al
jne 0x595d
jmp 0x5978
xorl %edi, %edi
subq %rdi, %rdx
jbe 0x5987
addq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b00
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x1070
movq %rax, %r15
testq %rax, %rax
je 0x59e8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5944
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5a7e
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x5a8a
testq %rbx, %rbx
je 0x5a8f
movq %r14, %rdi
callq 0x5ae0
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ae0
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x5a7e
movq %rax, %r15
movq %r14, %rdi
callq 0x5ae0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5944
movq %r14, %rdi
callq 0x5ae0
movq %r15, %rdi
addq %rax, %rdi
movq %rbx, %rsi
callq 0x5ee0
jmp 0x5a81
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
jmp 0x5a92
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x598c
// File: /workspace/github_c_makefile_star2_O3/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 0x5ad4
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 0x5ad7
movl %ebp, %ecx
addq %rcx, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5944
movb $0x0, (%rax,%rbx)
jmp 0x5ad9
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]push_swap_42/libft/srcs/string/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t	len;

	len = 0;
	while (s && s[len])
		len++;
	return (len);
}

// Assembly:
testq %rdi, %rdi
je 0x5afb
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x5aec
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5b8c
movb (%rbx), %al
testb %al, %al
je 0x5b8c
movq %rbx, %r14
movsbl %al, %edi
callq 0x5bd4
testl %eax, %eax
je 0x5b81
addb $-0x20, (%r14)
movb 0x1(%r14), %al
incq %r14
testb %al, %al
jne 0x5b71
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5bc8
movb (%rbx), %al
testb %al, %al
je 0x5bc8
movq %rbx, %r14
movsbl %al, %edi
callq 0x5be0
testl %eax, %eax
je 0x5bbd
addb $0x20, (%r14)
movb 0x1(%r14), %al
incq %r14
testb %al, %al
jne 0x5bad
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5c06
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x5bf6
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5c08
cmpl $0x20, %eax
je 0x5c08
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 0x5c58
addq %rsi, %rdi
xorl %edx, %edx
leal (%rdx,%rdx,4), %edx
movzbl %al, %eax
leal (%rax,%rdx,2), %edx
addl $-0x30, %edx
movb (%rdi), %al
leal -0x3a(%rax), %esi
incq %rdi
cmpb $-0xb, %sil
ja 0x5c3e
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5cc2
movq %rax, %rbx
movq $0x0, 0x10(%rax)
testq %r15, %r15
je 0x5cb2
movq %r14, %rdi
callq 0x1070
testq %rax, %rax
je 0x5cba
movq %r14, 0x8(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5bec
movq %rax, (%rbx)
jmp 0x5cc4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x5cc4
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5cfb
movslq %ebx, %rcx
movq %r14, %rax
cqto
idivq %rcx
incq %rdi
testq %rax, %rax
jne 0x5cee
incq %rdi
callq 0x1070
movq %rax, %r15
testq %rax, %rax
je 0x5d2f
movq %rsp, %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x5d3e
movq (%r12), %rax
movb $0x0, (%r15,%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5d89
cmpq %r12, %r15
jl 0x5db5
movq %r15, %rax
cqto
idivq %r12
movq %rdx, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x5d3e
jmp 0x5d61
cmpl $0xa, %ebp
jne 0x5db0
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0x2d, (%r14,%rax)
movq %r15, %rax
negq %rax
jno 0x5db0
movb $0x39, 0x1(%r14)
incq (%rbx)
movq %r13, %r15
negq %r15
jmp 0x5d61
cmpq $0x9, %r15
ja 0x5dc1
orb $0x30, %r15b
jmp 0x5de3
movsbl %r15b, %r15d
imull $0x67, %r15d, %eax
movzwl %ax, %ecx
shrl $0xa, %eax
shrl $0xf, %ecx
addb %al, %cl
movzbl %cl, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subb %al, %r15b
addb $0x41, %r15b
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_O3/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
testq %rdi, %rdi
je 0x5e2d
movl %ebx, %esi
movl $0x1, %edi
movq %r14, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
incq %rdi
cmpq %rsi, %rcx
movq %rax, %rcx
jae 0x5e18
jmp 0x5e32
movl $0x2, %edi
callq 0x1070
movq %rax, %r15
testq %rax, %rax
je 0x5e63
movq %rsp, %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x5e72
movq (%r12), %rax
movb $0x0, (%r15,%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl %ecx, %esi
cmpq %r15, %rsi
ja 0x5ea0
movq %r15, %rax
xorl %edx, %edx
divq %rsi
movq %rdx, %r15
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x5e72
cmpq $0x9, %r15
ja 0x5eac
orb $0x30, %r15b
jmp 0x5ece
movsbl %r15b, %r15d
imull $0x67, %r15d, %eax
movzwl %ax, %ecx
shrl $0xa, %eax
shrl $0xf, %ecx
addb %al, %cl
movzbl %cl, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subb %al, %r15b
addb $0x41, %r15b
movq (%rbx), %rax
movb %r15b, (%r14,%rax)
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1dbca(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
leaq 0x10368(%rip), %rsi     # 0x127a0
leaq 0x1036e(%rip), %rdx     # 0x127ad
xorl %eax, %eax
callq 0x2210
callq 0x7df0
callq 0x2454
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25a3
leaq 0xfaa5(%rip), %rdi      # 0x1203c
movq %rbx, %rsi
xorl %eax, %eax
callq 0xc84f
jmp 0x25b4
leaq 0xfab7(%rip), %rdi      # 0x12061
movq %rdx, %rsi
xorl %eax, %eax
callq 0xc84f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2f38
leaq -0x50(%rip), %rsi       # 0x2ed5
movl $0xe, %edi
callq 0x2200
movl 0x14(%r14), %edi
callq 0x2190
movq 0x8(%r14), %rdi
callq 0x7eb7
movq 0x8(%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4fd8
movl %eax, %ebx
callq 0x760a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x329a
movl 0x8(%rbx), %eax
leaq 0xf237(%rip), %r14      # 0x1247f
leaq 0xf24e(%rip), %r15      # 0x1249d
testl %eax, %eax
jle 0x329a
cmpl $0x0, (%rbx)
je 0x3272
movq (%r12), %rcx
movq %r14, %rdi
movq %r15, %rsi
movl $0x6c, %edx
xorl %eax, %eax
callq 0xc84f
movq 0x10(%rbx), %r12
movq (%r12), %rdi
movq 0x10(%r12), %r12
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x2030
movq %r12, 0x10(%rbx)
movl 0x8(%rbx), %eax
decl %eax
movl %eax, 0x8(%rbx)
testq %r12, %r12
jne 0x324f
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_O3/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 0x32e1
leaq 0x14d95(%rip), %rbx     # 0x18060
movq (%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc84f
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x32cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22a0
testq %rax, %rax
je 0x335d
movq %rax, %r12
cmpl $0x0, (%r14)
je 0x3339
movq 0x10(%r14), %r8
movl 0x8(%r14), %r9d
leaq 0xf185(%rip), %rdi      # 0x124a8
leaq 0xf173(%rip), %rsi      # 0x1249d
movl $0xaf, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xc84f
movq 0x10(%r14), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x10(%r14)
movq %r15, %rdi
callq 0x23a0
movq %rax, (%r12)
movq %rbx, 0x8(%r12)
incl 0x8(%r14)
jmp 0x3386
callq 0x2060
movl (%rax), %edi
callq 0x23b0
leaq 0xf16a(%rip), %rdi      # 0x124da
leaq 0xf126(%rip), %rsi      # 0x1249d
movl $0xb8, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc84f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33dd
movq %rdi, %r14
cmpl $0x0, 0x8(%rdi)
jle 0x33dd
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rbx
movq (%r15), %rsi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0xbede
movq (%r15), %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
decl 0x8(%r14)
jmp 0x33df
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x3438
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x20a0
testl %eax, %eax
je 0x343c
movq 0x10(%r12), %r12
testq %r12, %r12
je 0x3440
testl %eax, %eax
jne 0x3415
jmp 0x3440
xorl %ebx, %ebx
jmp 0x3440
movq (%r12), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0x1de9e(%rip)     # 0x21300
callq 0xd1ee
movl %ebx, %edi
callq 0xb2ff
movl %ebx, %edi
callq 0x7eae
movl %ebx, %edi
callq 0xca13
movl %ebx, %edi
callq 0xd7fb
movl %ebx, %edi
callq 0xe467
movl 0x1de70(%rip), %eax     # 0x21300
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1de6b(%rip)     # 0x21304
xorl %edi, %edi
callq 0x3459
xorl %edi, %edi
callq 0x34af
movl 0x1de57(%rip), %eax     # 0x21304
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_set_verbosity
int MIME_set_verbosity( int level )
{
    glb.verbosity = level;
    MIMEH_set_verbosity( level );
    TNEF_set_verbosity( level );
    FNFILTER_set_verbose( level );
    UUENCODE_set_verbosity( level );
    MDECODE_set_verbose( level );
    BS_set_verbose( level );
    return 0;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, 0x1de34(%rip)     # 0x212ec
callq 0x7ef3
movl %ebx, %edi
callq 0xb2e3
movl %ebx, %edi
callq 0xe470
movl %ebx, %edi
callq 0xd804
movl %ebx, %edi
callq 0xca1c
movl %ebx, %edi
callq 0xd1e5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_set_verbosity_contenttype
int MIME_set_verbosity_contenttype( int level )
{
    glb.verbosity_contenttype = level;
    MIMEH_set_verbosity_contenttype( level );
    UUENCODE_set_verbosity_contenttype( level );
    TNEF_set_verbosity_contenttype( level );
    return glb.verbosity_contenttype;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, 0x1dd3e(%rip)     # 0x212f4
callq 0x7efc
movl %ebx, %edi
callq 0xd80d
movl %ebx, %edi
callq 0xb2ec
movl 0x1dd25(%rip), %eax     # 0x212f4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_set_filename_report_fn
int MIME_set_filename_report_fn( int (*ptr_to_fn)(char *, char *) )
{
    glb.filename_decoded_reporter = ptr_to_fn;
    UUENCODE_set_filename_report_fn( ptr_to_fn );
    TNEF_set_filename_report_fn( ptr_to_fn );

    return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rdi, 0x20d6a(%rip)     # 0x24358
callq 0xd828
movq %rbx, %rdi
callq 0xb2f5
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: get_random_value
int get_random_value(void) {
    int randval;
    FILE *fp;
    fp = fopen("/dev/urandom", "r");
    fread(&randval, sizeof(randval), 1, fp);
    fclose(fp);
    if (randval < 0) { randval = randval *( -1); };
    return randval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf148(%rip), %rdi      # 0x1280a
leaq 0x12e3b(%rip), %rsi     # 0x16504
callq 0x2340
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x20c0
movq %rbx, %rdi
callq 0x20f0
movl (%r14), %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_decode_TNEF
int MIME_decode_TNEF( char *unpackdir, struct MIMEH_header_info *hinfo, int keep )
{
    int result=0;
    char fullpath[1024];

    snprintf(fullpath,sizeof(fullpath),"%s/%s",unpackdir,hinfo->filename);
    TNEF_set_path(unpackdir);
    result = TNEF_main( fullpath );

    if (result >= 0)
    {
        //      result = remove( fullpath );
        if (result == -1)
        {
            if (MIME_VERBOSE) LOGGER_log("%s:%d:MIME_decode_TNEF: Removing %s failed (%s)",FL,fullpath,strerror(errno));
        }
    }
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x5efd(%rsi), %r8
leaq 0xe7cd(%rip), %rdx      # 0x1240c
movq %rsp, %r14
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2140
movq %rbx, %rdi
callq 0xb2c1
movq %r14, %rdi
callq 0xbb5a
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_decode_OLE
int MIME_decode_OLE( char *unpackdir, struct MIMEH_header_info *hinfo, int keep )
{
    struct OLE_object ole;
    char fullpath[1024];
    int result;

    snprintf(fullpath,sizeof(fullpath),"%s/%s",unpackdir,hinfo->filename);

    OLE_init(&ole);
    OLE_set_quiet(&ole,glb.quiet);
    OLE_set_verbose(&ole,glb.verbosity);
    OLE_set_debug(&ole,glb.debug);
    OLE_set_save_unknown_streams(&ole,0);
    OLE_set_filename_report_fn(&ole, MIME_report_filename_decoded_RIPOLE );

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Starting OLE Decode",FL);
    result = OLE_decode_file(&ole, fullpath, unpackdir );
    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Decode done, cleaning up.",FL);
    OLE_decode_file_done(&ole);

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Decode returned with code = %d",FL,result);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x888, %rsp            # imm = 0x888
movq %rdi, %rbx
leaq 0x5efd(%rsi), %r8
leaq 0xe76c(%rip), %rdx      # 0x1240c
leaq 0x480(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2140
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xe7c0
movl 0x1d63a(%rip), %esi     # 0x21304
movq %r14, %rdi
callq 0xe83c
movl 0x1d614(%rip), %esi     # 0x212ec
movq %r14, %rdi
callq 0xe833
movl 0x1d61a(%rip), %esi     # 0x21300
movq %r14, %rdi
callq 0xe850
movq %r14, %rdi
xorl %esi, %esi
callq 0xe87e
leaq -0x90(%rip), %rsi       # 0x3c6f
movq %r14, %rdi
callq 0xfd2d
cmpl $0x0, 0x1d5f2(%rip)     # 0x21300
jle 0x3d2a
leaq 0xed44(%rip), %rdi      # 0x12a5b
leaq 0xe6c1(%rip), %rsi      # 0x123df
movl $0x4c8, %edx            # imm = 0x4C8
xorl %eax, %eax
callq 0xc84f
leaq 0x8(%rsp), %rdi
leaq 0x480(%rsp), %rsi
movq %rbx, %rdx
callq 0x101f2
movl %eax, %ebx
cmpl $0x0, 0x1d5b8(%rip)     # 0x21300
jle 0x3d64
leaq 0xed3b(%rip), %rdi      # 0x12a8c
leaq 0xe687(%rip), %rsi      # 0x123df
movl $0x4ca, %edx            # imm = 0x4CA
xorl %eax, %eax
callq 0xc84f
leaq 0x8(%rsp), %rdi
callq 0xfe60
cmpl $0x0, 0x1d58b(%rip)     # 0x21300
jle 0x3d93
leaq 0xed45(%rip), %rdi      # 0x12ac3
leaq 0xe65a(%rip), %rsi      # 0x123df
movl $0x4cd, %edx            # imm = 0x4CD
movl %ebx, %ecx
xorl %eax, %eax
callq 0xc84f
movl %ebx, %eax
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_decode_64_cleanup
int MIME_decode_64_cleanup( FFGET_FILE *f, char *unpackdir, struct MIMEH_header_info *hinfo)
{
    int result = 0;
    char buffer[128];

    while (FFGET_fgets(buffer, sizeof(buffer), f))
    {
        if (FFGET_feof(f) != 0) break;
        if (BS_cmp(buffer,strlen(buffer)) > 0) break;
    }
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x80, %esi
movq %rbx, %rdx
callq 0x7949
testq %rax, %rax
je 0x4e6f
movq %rbx, %rdi
callq 0x7858
testl %eax, %eax
jne 0x4e6f
movq %r14, %rdi
callq 0x2110
movq %r14, %rdi
movl %eax, %esi
callq 0xd609
testl %eax, %eax
jle 0x4e38
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/inflex[P]ripMIME/mime.c
// Function: MIME_postdecode_cleanup
int MIME_postdecode_cleanup( char *unpackdir, struct SS_object *ss )
{
    char fullpath[256];
    int result;
    result = 0;
    do {
        char *filename;
        if (MIME_DNORMAL) LOGGER_log("%s:%d: Popping file...",FL);
        filename = SS_pop(ss);
        if (filename == NULL) break;
        if (MIME_DNORMAL) LOGGER_log("%s:%d: Popped file '%s'",FL, filename);
        if ( strncmp( glb.blankfileprefix, filename, strlen( glb.blankfileprefix ) ) == 0 )
        {
            snprintf( fullpath, sizeof(fullpath), "%s/%s", unpackdir, filename );
            result = unlink( fullpath );
            if (MIME_VERBOSE)
            {
                if (result == -1) LOGGER_log("Error removing '%s'; %s", fullpath, strerror(errno));
                else LOGGER_log("Removed %s [status = %d]\n", fullpath, result );
            }
        }
    } while (1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc2cc(%rip), %r12      # 0x123df
leaq 0x1adce(%rip), %rbp     # 0x20ee8
movq %rsp, %r13
cmpl $0x0, 0x1b1dc(%rip)     # 0x21300
jle 0x613c
leaq 0xde14(%rip), %rdi      # 0x13f41
movq %r12, %rsi
movl $0x9cb, %edx            # imm = 0x9CB
xorl %eax, %eax
callq 0xc84f
movq %rbx, %rdi
callq 0x3394
testq %rax, %rax
je 0x61ff
movq %rax, %r15
cmpl $0x0, 0x1b1a9(%rip)     # 0x21300
jle 0x6172
leaq 0xddf8(%rip), %rdi      # 0x13f58
movq %r12, %rsi
movl $0x9ce, %edx            # imm = 0x9CE
movq %r15, %rcx
xorl %eax, %eax
callq 0xc84f
movq %rbp, %rdi
callq 0x2110
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x611d
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdi
leaq 0xc271(%rip), %rdx      # 0x1240c
movq %r14, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x2140
movq %r13, %rdi
callq 0x2070
cmpl $0x0, 0x1b135(%rip)     # 0x212ec
jle 0x611d
cmpl $-0x1, %eax
je 0x61da
leaq 0xddbf(%rip), %rdi      # 0x13f88
movq %r13, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0xc84f
jmp 0x611d
callq 0x2060
movl (%rax), %edi
callq 0x23b0
leaq 0xdd83(%rip), %rdi      # 0x13f70
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xc84f
jmp 0x611d
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq