LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_vfprintf.c
// Function: ft_vfprintf
int	ft_vfprintf(const char *format, va_list ap, int fd)
{
	int		i;
	int		res;
	t_fdi	fdi;

	res = 0;
	i = 0;
	fdi.fd = fd;
	while (format[i])
	{
		if (format[i] == '%')
		{
			fdi.i = i + 1;
			i = vprint(format, fdi, ap, &res);
		}
		else if (format[i] == '\\' && format[i + 1])
		{
			res += write(fd, &format[i], 2);
			i += 2;
		}
		else
			res += write(fd, &format[i++], 1);
	}
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3b0c
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x3a80
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x24(%rbp), %rsi
leaq -0x1c(%rbp), %rcx
callq 0x3930
movl %eax, -0x18(%rbp)
jmp 0x3b07
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x3ad7
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3ad7
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl $0x2, %edx
callq 0x1060
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x3b05
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cltq
addq %rax, %rsi
movl $0x1, %edx
callq 0x1060
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x3b07
jmp 0x3a37
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/id_format.c
// Function: is_modifier
int	is_modifier(const char *format, int i)
{
	if (ft_countchr("hlL", format[i]) > 0)
	{
		i++;
		if (format[i] == 'h' || format[i] == 'l')
			i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x47d5(%rip), %rdi      # 0x8347
callq 0x7320
cmpl $0x0, %eax
jle 0x3bb2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x68, %eax
je 0x3ba7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6c, %eax
jne 0x3bb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3bb2
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/id_format.c
// Function: init_flags
t_flags	init_flags(int i, int fd)
{
	t_flags	flags;

	flags.square = 0;
	flags.zero = 0;
	flags.plus = 0;
	flags.minus = 0;
	flags.space = 0;
	flags.hh = 0;
	flags.h = 0;
	flags.l = 0;
	flags.ll = 0;
	flags.lo = 0;
	flags.width = 0;
	flags.precision = -1;
	flags.i = i;
	flags.fd = fd;
	return (flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movl $0x0, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movl $0x0, 0x14(%rdi)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %ecx
movl %ecx, 0x34(%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x38(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/id_format.c
// Function: valid_conversion
int	valid_conversion(const char *format, int i)
{
	while (is_flag(format[i]))
		i++;
	while ('0' <= format[i] && format[i] <= '9')
		i++;
	if (format[i] == '.')
	{
		i++;
		while ('0' <= format[i] && format[i] <= '9')
			i++;
	}
	i = is_modifier(format, i);
	return (is_conversion(format[i]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3bc0
cmpl $0x0, %eax
je 0x3c90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c6f
jmp 0x3c92
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0xd(%rbp)
jg 0x3cc1
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x3cca
jmp 0x3cd5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c92
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x3d34
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0xe(%rbp)
jg 0x3d1e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x3d27
jmp 0x3d32
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cef
jmp 0x3d34
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3b50
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3b20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/interpreter.c
// Function: ft_flags
t_flags	ft_flags(const char *format, t_flags flags)
{
	int	i;

	i = flags.i - 1;
	while (is_flag(format[++i]))
	{
		if (format[i] == '#')
			flags.square = 1;
		if (format[i] == '0')
			flags.zero = 1;
		if (format[i] == '+')
			flags.plus = 1;
		if (format[i] == '-')
			flags.minus = 1;
		if (format[i] == ' ')
			flags.space = 1;
	}
	flags.i = i;
	return (flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl 0x34(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x3bc0
cmpl $0x0, %eax
je 0x3e37
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x23, %eax
jne 0x3dc2
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0x3dde
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x3dfa
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x3e16
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x3e32
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x3d85
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x34(%rsi)
movl $0x3c, %edx
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/interpreter.c
// Function: ft_modifiers
t_flags	ft_modifiers(const char *format, t_flags flags, int i)
{
	if (ft_countchr("hlL", format[++i]))
	{
		if (format[i] == 'l')
		{
			if (format[i + 1] && format[i + 1] == 'l')
				flags.ll = 1;
			else
				flags.l = 1;
			i += (format[i + 1] && format[i + 1] == 'l');
		}
		if (format[i] == 'h')
		{
			if (format[i + 1] && format[i + 1] == 'h')
			{
				i++;
				flags.hh = 1;
			}
			else
				flags.h = 1;
		}
		if (format[i++] == 'L')
			flags.lo = 1;
	}
	flags.i = i;
	return (flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %esi
leaq 0x44ad(%rip), %rdi      # 0x8347
callq 0x7320
cmpl $0x0, %eax
je 0x3fcc
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6c, %eax
jne 0x3f44
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3ef6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6c, %eax
jne 0x3ef6
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x3f01
movq -0x18(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x3f36
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6c, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x68, %eax
jne 0x3fa4
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3f97
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x68, %eax
jne 0x3f97
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movl $0x1, 0x1c(%rax)
jmp 0x3fa2
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x3fa4
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4c, %eax
jne 0x3fca
movq -0x18(%rbp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x3fcc
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x34(%rsi)
movl $0x3c, %edx
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/interpreter.c
// Function: no_flags
t_flags	no_flags(const char *format, t_flags flags)
{
	int	i;

	i = flags.i;
	flags.width = ft_atoi(&format[i]);
	while ('0' <= format[i] && format[i] <= '9')
		i++;
	if (format[i] == '.')
	{
		i++;
		flags.precision = ft_atoi(&format[i]);
		while ('0' <= format[i] && format[i] <= '9')
			i++;
	}
	flags.i = i;
	return (flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl 0x34(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
callq 0x6af0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jg 0x405a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4063
jmp 0x406e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x402b
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x40e6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
callq 0x6af0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x2a(%rbp)
jg 0x40d0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x40d9
jmp 0x40e4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40a1
jmp 0x40e6
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x34(%rsi)
movl $0x3c, %edx
callq 0x10e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/interpreter.c
// Function: manage_exceptions
void	manage_exceptions(t_flags *flags)
{
	if ((*flags).zero && (((*flags).precision > 0
				&& ft_countchr("diouxX", (*flags).type) > 0) || (*flags).minus))
		(*flags).zero = 0;
	if ((*flags).space && (*flags).plus)
		(*flags).space = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x415e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x4149
movq -0x8(%rbp), %rax
movsbl 0x30(%rax), %esi
leaq 0x4212(%rip), %rdi      # 0x8351
callq 0x7320
cmpl $0x0, %eax
jg 0x4153
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x415e
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x417d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x417d
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/manipulation.c
// Function: manipulation
int	manipulation(t_flags flags, va_list ap)
{
	if (ft_countchr("diouxX", flags.type) > 0 && flags.lo != 0)
		return (0);
	if (flags.type == 'f' && (flags.h || flags.hh || flags.ll))
		return (0);
	return (print_arg(flags, ap));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movsbl 0x30(%rax), %esi
leaq 0x4142(%rip), %rdi      # 0x8351
callq 0x7320
cmpl $0x0, %eax
jle 0x422c
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x422c
movl $0x0, -0x4(%rbp)
jmp 0x4291
movq -0x18(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x66, %eax
jne 0x4260
movq -0x18(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x4257
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x4257
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4260
movl $0x0, -0x4(%rbp)
jmp 0x4291
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x2c(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x2c(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x4c30
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/printform.c
// Function: ft_uoxx_w
int	ft_uoxx_w(t_flags flags, char *s, int q, int b)
{
	int	n;
	int	oo;

	oo = b * 2 * (ft_strcmp(s, "0") != 0);
	if (flags.type == 'o')
		oo = b + flags.precision <= 0 && flags.square;
	n = flags.width - ft_strlen(s) - oo - ((q > 0) * q);
	n += (ft_strcmp(s, "0") == 0 && flags.precision == 0
			&& !(flags.square && flags.type == 'o'));
	n += (ft_strcmp(s, "0") == 0
			&& flags.precision == -1 && flags.type == 'o');
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3ca8(%rip), %rsi      # 0x83a5
callq 0x6fb0
movl -0x24(%rbp), %ecx
movl %eax, %edx
movq -0x20(%rbp), %rax
cmpl $0x0, %edx
setne %dl
andb $0x1, %dl
movzbl %dl, %edx
imull %edx, %ecx
movl %ecx, -0x18(%rbp)
movsbl 0x30(%rax), %eax
cmpl $0x6f, %eax
jne 0x4752
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl 0x18(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
jg 0x4747
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq 0x14(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movslq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpl $0x0, -0xc(%rbp)
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
imull -0xc(%rbp), %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3c08(%rip), %rsi      # 0x83a5
callq 0x6fb0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x26(%rbp)
jne 0x47e4
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x18(%rcx)
movb %al, -0x26(%rbp)
jne 0x47e4
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x47dc
movq -0x20(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x6f, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3ba8(%rip), %rsi      # 0x83a5
callq 0x6fb0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
jne 0x482e
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x18(%rcx)
movb %al, -0x32(%rbp)
jne 0x482e
movq -0x20(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x6f, %eax
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/printform.c
// Function: put_wstr
int	put_wstr(char *str, t_flags flags, int xp)
{
	int	i;
	int	w;
	int	nb;
	int	p;

	i = 0;
	nb = 0;
	if (!str)
		str = "(null)";
	p = flags.precision;
	w = flags.width;
	i = ft_strlen(str);
	xp = i;
	if (p < i && p >= 0)
		xp = p;
	if (!flags.minus && w - (xp) > 0)
		nb += ft_repet_fd(' ', w - (xp), flags.fd);
	nb += write(flags.fd, str, xp);
	if (flags.minus && w - (xp) > 0)
		nb += ft_repet_fd(' ', w - (xp), flags.fd);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4b67
leaq 0x37fa(%rip), %rax      # 0x835d
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4b9d
cmpl $0x0, -0x1c(%rbp)
jl 0x4b9d
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x4bcf
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x4bcf
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %esi
subl -0xc(%rbp), %esi
movl 0x38(%rax), %edx
movl $0x20, %edi
callq 0x6a70
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1060
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
addq %rdx, %rcx
movl %ecx, -0x18(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x4c22
movl -0x14(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x4c22
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %esi
subl -0xc(%rbp), %esi
movl 0x38(%rax), %edx
movl $0x20, %edi
callq 0x6a70
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_itoa_basexx.c
// Function: ft_itoa_basexx
char	*ft_itoa_basexx(uintmax_t value, int base, int mayus)
{
	char	*basee;
	char	*result;
	int		i;

	if ((2 <= base && base <= 16))
	{
		if (value == 0)
			return ("0");
		basee = (char *)malloc(sizeof(char) * (base + 1));
		create_base(base, basee, mayus);
		i = size_number(value, base);
		result = (char *)malloc(sizeof(char) * (i + 2));
		if (!result)
			return (0);
		i = to_string(value, result, basee, base);
		result[i] = '\0';
		free(basee);
		return (ft_strrevf(result, i));
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x2, %eax
cmpl -0x14(%rbp), %eax
jg 0x519a
cmpl $0x10, -0x14(%rbp)
jg 0x519a
cmpq $0x0, -0x10(%rbp)
jne 0x5101
leaq 0x32ad(%rip), %rax      # 0x83a5
movq %rax, -0x8(%rbp)
jmp 0x51a2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1100
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x51b0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5230
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x515c
movq $0x0, -0x8(%rbp)
jmp 0x51a2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x5270
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x61d0
movq %rax, -0x8(%rbp)
jmp 0x51a2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_itoa_basexx.c
// Function: create_base
static void	create_base(int base, char *basee, int mayus)
{
	int	i;
	int	upcase;

	upcase = 87;
	if (mayus)
		upcase = 55;
	i = 0;
	while (i < base)
	{
		if (i > 9)
			basee[i] = i + upcase;
		else
			basee[i] = i + 48;
		i++;
	}
	basee[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x57, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x51d2
movl $0x37, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x521a
cmpl $0x9, -0x18(%rbp)
jle 0x51fc
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x520f
movl -0x18(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x51d9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_itoa_basexx.c
// Function: size_number
static int	size_number(uintmax_t value, int base)
{
	int	i;

	i = 0;
	while (value != 0)
	{
		value /= base;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5265
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5242
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_itoa_basexx.c
// Function: to_string
static int	to_string(uintmax_t value, char *result, char *basee, int base)
{
	int			i;
	uintmax_t	x;

	i = 0;
	x = value;
	while (x != 0)
	{
		result[i] = basee[x % base];
		x /= base;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x52dc
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq -0x30(%rbp), %rax
movb (%rax,%rdx), %dl
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x1c(%rbp), %rcx
movq -0x28(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5292
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_put.c
// Function: u_width
int	u_width(t_flags flags, int p, int i, int iszero)
{
	if ((flags.type != 'f' && p <= i && p > 0) || flags.precision == 0)
		p = 0;
	return (flags.width - p - i
		- (flags.type != 'u' * (flags.plus || flags.space) + p)
		+ (flags.type != 'f' && iszero && p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movsbl 0x30(%rax), %eax
cmpl $0x66, %eax
je 0x531c
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x531c
cmpl $0x0, -0x4(%rbp)
jg 0x5326
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x532d
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
subl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movsbl 0x30(%rcx), %eax
movl %eax, -0x20(%rbp)
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
jne 0x535d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movl -0x20(%rbp), %edx
movb -0x19(%rbp), %sil
andb $0x1, %sil
movzbl %sil, %esi
imull $0x75, %esi, %esi
addl -0x4(%rbp), %esi
cmpl %esi, %edx
setne %dl
andb $0x1, %dl
movzbl %dl, %edx
subl %edx, %ecx
movl %ecx, -0x2c(%rbp)
movsbl 0x30(%rax), %ecx
xorl %eax, %eax
cmpl $0x66, %ecx
movb %al, -0x25(%rbp)
je 0x53ac
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x25(%rbp)
je 0x53ac
cmpl $0x0, -0x4(%rbp)
setne %al
movb %al, -0x25(%rbp)
movl -0x2c(%rbp), %eax
movb -0x25(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_put.c
// Function: ft_fillzero
int	ft_fillzero(int p, t_flags flags, int i)
{
	return ((p >= 0 && !((flags.precision || flags.minus) && flags.type != 'f')
			&& flags.zero && !(p && flags.type == 'f' && flags.minus)
			&& i < flags.width) || (flags.type == 'u' && flags.precision < 0
			&& !flags.minus && flags.zero));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x5431
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x53ec
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x53f9
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x66, %eax
jne 0x5431
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x5431
cmpl $0x0, -0x4(%rbp)
je 0x5420
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x66, %eax
jne 0x5420
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x5431
movq -0x10(%rbp), %rdx
movl -0x8(%rbp), %ecx
movb $0x1, %al
cmpl 0x14(%rdx), %ecx
movb %al, -0x11(%rbp)
jl 0x5475
movq -0x10(%rbp), %rax
movsbl 0x30(%rax), %ecx
xorl %eax, %eax
cmpl $0x75, %ecx
movb %al, -0x12(%rbp)
jne 0x546f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x18(%rcx)
movb %al, -0x12(%rbp)
jge 0x546f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0xc(%rcx)
movb %al, -0x12(%rbp)
jne 0x546f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_put.c
// Function: calc_x
static uintmax_t	calc_x(t_flags flags, intmax_t *lg, uintmax_t x, int *i)
{
	if (flags.type != 'u' && (*lg) < 0)
		(*lg) *= -1;
	x = (uintmax_t)(*lg);
	if (!(*lg) && flags.type == 'u' && flags.precision != 0)
		x = 1;
	while (x != 0 && ++(*i))
		x /= 10;
	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsbl 0x30(%rax), %eax
cmpl $0x75, %eax
je 0x5746
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x5746
movq -0x8(%rbp), %rax
imulq $-0x1, (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x577a
movq -0x20(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x75, %eax
jne 0x577a
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x577a
movq $0x1, -0x10(%rbp)
jmp 0x577c
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
je 0x579c
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x57a5
jmp 0x57b9
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
jmp 0x577c
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_put.c
// Function: calc_iszero
static int	calc_iszero(t_flags flags, int i, int iszero)
{
	int	ret;

	ret = flags.width - i;
	ret = ret - (flags.plus || flags.space) + (flags.type != 'f' && iszero);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x14(%rcx), %eax
subl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movb $0x1, %al
cmpl $0x0, 0x8(%rcx)
movb %al, -0xd(%rbp)
jne 0x57fa
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
movb %al, -0xd(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb -0xd(%rbp), %dl
andb $0x1, %dl
movzbl %dl, %edx
subl %edx, %ecx
movl %ecx, -0x28(%rbp)
movsbl 0x30(%rax), %ecx
xorl %eax, %eax
cmpl $0x66, %ecx
movb %al, -0x21(%rbp)
je 0x5827
cmpl $0x0, -0x8(%rbp)
setne %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_putdbl.c
// Function: ft_fmod
long double	ft_fmod(long double a, double b)
{
	double	mod;

	if (a < 0)
		a *= -1;
	if (b < 0)
		b *= -1;
	mod = a;
	while (mod >= b)
		mod -= b;
	if (a < 0)
		return (-mod);
	return (mod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
fldt -0x20(%rbp)
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x5864
jmp 0x585c
fldt -0x20(%rbp)
fchs
fstpt -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x5880
movsd 0x2afa(%rip), %xmm0     # 0x8370
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
fldt -0x20(%rbp)
fstpl -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0x58b1
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x5890
fldt -0x20(%rbp)
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x58db
jmp 0x58be
movaps 0x2acb(%rip), %xmm1     # 0x8390
movsd -0x30(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x40(%rbp)
fldl -0x40(%rbp)
fstpt -0x10(%rbp)
jmp 0x58e1
fldl -0x30(%rbp)
fstpt -0x10(%rbp)
fldt -0x10(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_putdbl.c
// Function: ft_putzeroes
int	ft_putzeroes(long double nb, int precision, int fd)
{
	int	zeroes;

	nb *= ft_pow(10, precision);
	zeroes = 0;
	while ((int)nb > 1)
	{
		if (ft_fmod(nb, 10) + 1e-9 >= 1.)
			zeroes = 0;
		else
			zeroes++;
		nb /= 10.;
	}
	ft_repet_fd('0', zeroes, fd);
	return (zeroes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
fldt 0x10(%rbp)
fstpt -0x10(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl -0x14(%rbp), %esi
movl $0xa, %edi
callq 0x59b0
movl %eax, -0x20(%rbp)
fildl -0x20(%rbp)
fldt -0x10(%rbp)
fmulp %st, %st(1)
fstpt -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
fldt -0x10(%rbp)
fnstcw -0x26(%rbp)
movzwl -0x26(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x28(%rbp)
fldcw -0x28(%rbp)
fistpl -0x24(%rbp)
fldcw -0x26(%rbp)
movl -0x24(%rbp), %eax
cmpl $0x1, %eax
jle 0x5995
fldt -0x10(%rbp)
movq %rsp, %rax
fstpt (%rax)
movsd 0x2a1e(%rip), %xmm0     # 0x8378
callq 0x5840
fldl 0x2a1b(%rip)            # 0x8380
faddp %st, %st(1)
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0x597c
jmp 0x5973
movl $0x0, -0x1c(%rbp)
jmp 0x5985
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
fldt -0x10(%rbp)
flds 0x2a12(%rip)            # 0x83a0
fdivrp %st, %st(1)
fstpt -0x10(%rbp)
jmp 0x5926
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x30, %edi
callq 0x6a70
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_putdbl.c
// Function: ft_pow
static int	ft_pow(int n, int xp)
{
	int	a;

	a = 1;
	while (xp > 0)
	{
		a *= n;
		xp--;
	}
	return (a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x59dc
movl -0x4(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x59c1
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_strrev.c
// Function: ft_strrevf
char	*ft_strrevf(char *str, int size)
{
	int		i;
	char	temp;
	char	*copy;

	copy = (char *)malloc(sizeof(char) * (size + 1));
	if (!copy)
		return (NULL);
	ft_strcpy(copy, str);
	i = 0;
	size--;
	while (size > i)
	{
		temp = copy[size];
		copy[size] = copy[i];
		copy[i] = temp;
		i++;
		size--;
	}
	free(str);
	str = copy;
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6209
movq $0x0, -0x8(%rbp)
jmp 0x628d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7680
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x6274
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %dl
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6226
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_strrev.c
// Function: put_wchar
int	put_wchar(char c, t_flags flags)
{
	int	nb;

	nb = 0;
	if (!flags.minus && flags.width - 1 > 0)
		nb += ft_repet_fd(' ', flags.width - 1, flags.fd);
	nb += write(flags.fd, &c, 1);
	if (flags.minus && flags.width - 1 > 0)
		nb += ft_repet_fd(' ', flags.width - 1, flags.fd);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %cl
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movb %cl, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x0, 0xc(%rax)
jne 0x62ef
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x62ef
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
subl $0x1, %esi
movl 0x38(%rax), %edx
movl $0x20, %edi
callq 0x6a70
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x1060
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
addq %rdx, %rcx
movl %ecx, -0x8(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x6347
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x6347
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
subl $0x1, %esi
movl 0x38(%rax), %edx
movl $0x20, %edi
callq 0x6a70
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_strrev.c
// Function: di_lenp
int	di_lenp(long long int lg, t_flags flags)
{
	int				i;
	int				p;
	int				iszero;
	unsigned int	x;

	p = flags.precision;
	i = 0;
	iszero = (lg == 0);
	if (flags.type != 'u' && lg < 0)
		lg *= -1;
	x = (unsigned int)lg;
	while (x != 0)
	{
		i++;
		x /= 10;
	}
	if (p > i)
		return (p - i - iszero);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl 0x18(%rax), %ecx
movl %ecx, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x1c(%rbp)
movsbl 0x30(%rax), %eax
cmpl $0x75, %eax
je 0x6393
cmpq $0x0, -0x10(%rbp)
jge 0x6393
imulq $-0x1, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x63ba
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x20(%rbp)
jmp 0x639a
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x63d0
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x63d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/print_address.c
// Function: a_size
int	a_size(int i, unsigned long p, int *zeroes)
{
	int	count;
	int	zcount;

	count = 0;
	*zeroes = 0;
	zcount = 0;
	while (i >= 0)
	{
		if ((p >> i & 0xf))
		{
			if (!zcount)
				*zeroes = -1;
			else if (!(*zeroes))
				*zeroes = zcount;
		}
		else
			zcount++;
		count++;
		i -= 4;
	}
	if (!p)
		count = 0;
	if (!*zeroes)
		return (count);
	return (count - *zeroes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x6496
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %ecx
shrq %cl, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6479
cmpl $0x0, -0x20(%rbp)
jne 0x6463
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x6477
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6475
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x6477
jmp 0x6482
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x8(%rbp)
jmp 0x6437
cmpq $0x0, -0x10(%rbp)
jne 0x64a4
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x64b5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x64c1
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/print_address.c
// Function: ft_zero
int	ft_zero(t_flags flags, int size)
{
	int	nb;
	int	mprec;

	if (!size)
		return (0);
	mprec = size;
	if (flags.precision > size)
		mprec = flags.precision;
	nb = ft_repet_fd('0', flags.width - mprec - flags.space
			- flags.plus - 2, flags.fd);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x66c2
movl $0x0, -0x4(%rbp)
jmp 0x6707
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movl 0x18(%rax), %eax
cmpl -0x8(%rbp), %eax
jle 0x66de
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
subl -0x10(%rbp), %esi
subl 0x10(%rax), %esi
subl 0x8(%rax), %esi
subl $0x2, %esi
movl 0x38(%rax), %edx
movl $0x30, %edi
callq 0x6a70
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_repet_fd.c
// Function: ft_repet_fd
int	ft_repet_fd(char c, int i, const int fd)
{
	int	nb;

	nb = 0;
	while (nb < i)
		nb += ft_write(fd, &c, 1);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x6ab3
movl -0xc(%rbp), %edi
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x6990
movq %rax, %rcx
movslq -0x10(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x10(%rbp)
jmp 0x6a8b
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdlib/ft_atoi.c
// Function: ft_atoi
int	ft_atoi(const char *str)
{
	int	i;
	int	number;
	int	sign;
	int	f;

	number = 0;
	sign = 1;
	i = ft_cspecial(str);
	if (str[i] == '-')
		sign *= -1;
	if (str[i] == '-' || str[i] == '+')
		i++;
	while (str[i] && (str[i] <= '9') && (str[i] >= '0'))
	{
		f = ((int)str[i] - '0');
		if (ft_condition(number, f, sign))
		{
			if (f == 8 && sign < 0)
				return (-2147483648);
			return (2147483647);
		}
		number = (number * 10) + f;
		i++;
	}
	return (number * sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c20
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x6b2e
imull $-0x1, -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x6b50
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x6b59
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b5b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x6b9c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x39, %ecx
movb %al, -0x21(%rbp)
jg 0x6b9c
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
setge %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6ba5
jmp 0x6c00
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x6c90
cmpl $0x0, %eax
je 0x6be8
cmpl $0x8, -0x20(%rbp)
jne 0x6bdf
cmpl $0x0, -0x1c(%rbp)
jge 0x6bdf
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x6c0a
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x6c0a
imull $0xa, -0x18(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b5b
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdlib/ft_atoi.c
// Function: ft_cspecial
static int	ft_cspecial(const char *c)
{
	int	i;

	i = 0;
	while (c[i] == ' ' || (c[i] >= 9 && c[i] <= 13))
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xd(%rbp)
je 0x6c76
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0xe(%rbp)
jl 0x6c70
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
setle %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x6c7f
jmp 0x6c8a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c2f
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/caster.c
// Function: get_int
intmax_t	get_int(t_flags flags, va_list ap)
{
	intmax_t	x;

	if (flags.l)
		return (va_arg(ap, long int));
	else if (flags.ll)
		return (va_arg(ap, long long int));
	else
		x = (va_arg(ap, int));
	if (flags.hh)
		x = (signed char)x;
	else if (flags.h)
		return ((short int)x);
	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0x24(%rax)
je 0x6d58
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x28, %eax
ja 0x6d31
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rbp)
jmp 0x6d48
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e3d
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x6db4
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0x6d8d
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x6da4
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e3d
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl (%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x28, %eax
ja 0x6ddf
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6df6
movq -0x60(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6e03
movq -0x20(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x6e1b
movq -0x18(%rbp), %rax
movsbq %al, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e35
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x6e33
movq -0x18(%rbp), %rax
movswq %ax, %rax
movq %rax, -0x8(%rbp)
jmp 0x6e3d
jmp 0x6e35
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)