LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_vfprintf.c
// Function: interpret
t_flags	interpret(const char *format, int i, int fd)
{
	t_flags	flags;

	flags = init_flags(i, fd);
	flags = ft_flags(format, flags);
	flags = no_flags(format, flags);
	flags = ft_modifiers(format, flags, flags.i - 1);
	flags.type = format[flags.i++];
	manage_exceptions(&flags);
	return (flags);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
movl %ecx, %edx
callq 0x2983
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movups %xmm3, 0x6c(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movups 0x6c(%rsp), %xmm0
movups %xmm0, 0x2c(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x84(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a0c
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0x2c(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movups %xmm3, 0x6c(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movups 0x6c(%rsp), %xmm0
movups %xmm0, 0x2c(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x84(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2c27
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0x2c(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x34(%rbx), %edx
decl %edx
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x2c(%rbx), %xmm3
movups %xmm3, 0x6c(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movups 0x6c(%rsp), %xmm0
movups %xmm0, 0x2c(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x84(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b2b
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movups %xmm3, 0x2c(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movslq 0x34(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x34(%rbx)
movb (%r14,%rax), %al
movb %al, 0x30(%rbx)
movq %rbx, %rdi
callq 0x2ce5
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_vfprintf.c
// Function: vprint
int	vprint(const char *format, t_fdi fdi, va_list ap, int *res)
{
	t_flags	flags;

	if ((valid_conversion(format, fdi.i)) ? 1 : 0)
	{
		flags = interpret(format, fdi.i, fdi.fd);
		*res += manipulation(flags, ap);
		return (flags.i);
	}
	*res += write(fdi.fd, "%", 1);
	return (fdi.i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %r12
shrq $0x20, %r12
callq 0x29a4
testl %eax, %eax
je 0x2840
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x2604
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups 0x2c(%rbp), %xmm3
movups %xmm3, 0x2c(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x2d4d
addl (%rbx), %eax
movl 0x34(%rbp), %r14d
jmp 0x2854
leaq 0x2b2a(%rip), %rsi      # 0x5371
pushq $0x1
popq %rdx
movl %r12d, %edi
callq 0x1060
addl (%rbx), %eax
movl %eax, (%rbx)
movl %r14d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %rax
andl $0x0, (%rax)
movq %rbx, %r12
shlq $0x20, %r12
xorl %r13d, %r13d
pushq $0x1
popq %rbp
movslq %r13d, %rsi
movzbl (%r15,%rsi), %eax
cmpl $0x25, %eax
je 0x28db
addq %r15, %rsi
cmpl $0x5c, %eax
je 0x28ae
testl %eax, %eax
jne 0x28c8
jmp 0x28f9
cmpb $0x0, 0x1(%rsi)
je 0x28c8
movl %ebx, %edi
pushq $0x2
popq %rdx
callq 0x1060
addl %eax, 0x4(%rsp)
addl $0x2, %r13d
jmp 0x2893
incl %r13d
movl %ebx, %edi
movq %rbp, %rdx
callq 0x1060
addl %eax, 0x4(%rsp)
jmp 0x2893
incl %r13d
orq %r12, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
leaq 0x4(%rsp), %rcx
callq 0x27ca
movl %eax, %r13d
jmp 0x2893
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r15
movsbl (%rdi,%r15), %esi
leaq 0x2a34(%rip), %rdi      # 0x5373
callq 0x49a8
testl %eax, %eax
jle 0x2961
movzbl 0x1(%r14,%r15), %eax
orl $0x4, %eax
cmpl $0x6c, %eax
jne 0x295b
addl $0x2, %ebx
jmp 0x2961
incq %r15
movl %r15d, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
decq %r14
movsbl 0x1(%rbx,%r14), %edi
callq 0x2969
incq %r14
testl %eax, %eax
jne 0x29b1
leaq (%rbx,%r14), %rax
decq %r14
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
incq %r14
cmpb $0xa, %dl
jb 0x29ca
cmpb $0x2e, %cl
jne 0x29ef
incq %r14
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x29df
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2926
cltq
movsbl (%rbx,%rax), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x290c
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movl 0x34(%r15), %eax
decl %eax
movl (%r15), %ecx
movl %ecx, 0x14(%rsp)
movl 0x4(%r15), %ecx
movl %ecx, 0x10(%rsp)
movl 0x10(%r15), %r13d
movl 0xc(%r15), %ebp
movl 0x8(%r15), %ecx
movl %ecx, 0xc(%rsp)
movslq %eax, %r12
incq %r12
movsbl (%r14,%r12), %edi
callq 0x2969
testl %eax, %eax
je 0x2ab4
movzbl (%r14,%r12), %eax
incq %r12
cmpl $0x20, %eax
je 0x2a93
cmpl $0x30, %eax
je 0x2aa8
cmpl $0x2b, %eax
je 0x2a9c
cmpl $0x2d, %eax
je 0x2a8b
cmpl $0x23, %eax
jne 0x2a50
decq %r12
pushq $0x1
popq %rax
movl %eax, 0x14(%rsp)
jmp 0x2a4d
decq %r12
pushq $0x1
popq %rbp
jmp 0x2a4d
decq %r12
pushq $0x1
popq %r13
jmp 0x2a4d
decq %r12
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
jmp 0x2a4d
decq %r12
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
jmp 0x2a4d
movl %r13d, 0x10(%r15)
movl %ebp, 0xc(%r15)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%r15)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%r15)
movl 0x14(%rsp), %eax
movl %eax, (%r15)
movl %r12d, 0x34(%r15)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movl 0x10(%r15), %eax
movl %eax, 0x10(%rbx)
movq 0x14(%r15), %rax
movq %rax, 0x14(%rbx)
movl 0x1c(%r15), %eax
movl %eax, 0x1c(%rbx)
movl (%r15), %eax
movl %eax, (%rbx)
movl 0x4(%r15), %eax
movl %eax, 0x4(%rbx)
movl 0x8(%r15), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r15), %eax
movl %eax, 0xc(%rbx)
movups 0x2c(%r15), %xmm0
movups %xmm0, 0x2c(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movslq %edx, %r13
leaq 0x1(%r13), %r12
movsbl 0x1(%rsi,%r13), %esi
leaq 0x2820(%rip), %rdi      # 0x5373
callq 0x49a8
testl %eax, %eax
je 0x2b78
movb (%r14,%r12), %cl
cmpb $0x6c, %cl
jne 0x2b99
movb 0x2(%r14,%r13), %al
cmpb $0x6c, %al
jne 0x2b7d
movl $0x1, 0x28(%r15)
jmp 0x2b85
movl %r12d, %eax
jmp 0x2bd4
movl $0x1, 0x24(%r15)
xorl %edx, %edx
cmpb $0x6c, %al
sete %dl
addl %r12d, %edx
movslq %edx, %rax
movb (%r14,%rax), %cl
movl %edx, %r12d
movslq %r12d, %rax
incq %rax
cmpb $0x4c, %cl
je 0x2bbd
movzbl %cl, %ecx
cmpl $0x68, %ecx
jne 0x2bd4
cmpb $0x68, (%r14,%rax)
jne 0x2bc7
movl $0x1, 0x1c(%r15)
jmp 0x2bd2
movl $0x1, 0x2c(%r15)
jmp 0x2bd4
movl $0x1, 0x20(%r15)
movl %r12d, %eax
incl %eax
movl %eax, 0x34(%r15)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0x28(%rbx)
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x2c(%r15), %eax
movl %eax, 0x2c(%rbx)
movl 0x30(%r15), %eax
movl %eax, 0x30(%rbx)
movl 0x34(%r15), %eax
movl %eax, 0x34(%rbx)
movl 0x38(%r15), %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movslq 0x34(%r15), %r12
leaq (%rsi,%r12), %rdi
callq 0x4604
movl %eax, 0x14(%r15)
leaq -0x1(%r12), %rax
movq %r12, %rdi
shlq $0x20, %rdi
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %rdi
incl %r12d
movb 0x1(%r14,%rax), %dl
leal -0x30(%rdx), %esi
incq %rax
cmpb $0xa, %sil
jb 0x2c61
cmpb $0x2e, %dl
jne 0x2ca3
sarq $0x20, %rdi
addq %r14, %rdi
callq 0x4604
movl %eax, 0x18(%r15)
movslq %r12d, %rax
decq %rax
movb 0x1(%r14,%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x2c93
movl %eax, 0x34(%r15)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x2c(%r15), %rax
movq %rax, 0x2c(%rbx)
movl 0x34(%r15), %eax
movl %eax, 0x34(%rbx)
movl 0x38(%r15), %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x2d13
cmpl $0x0, 0x18(%rbx)
jle 0x2d09
movsbl 0x30(%rbx), %esi
leaq 0x267d(%rip), %rdi      # 0x537d
callq 0x49a8
testl %eax, %eax
jg 0x2d0f
cmpl $0x0, 0xc(%rbx)
je 0x2d13
andl $0x0, 0x4(%rbx)
cmpl $0x0, 0x10(%rbx)
je 0x2d23
cmpl $0x0, 0x8(%rbx)
je 0x2d23
andl $0x0, 0x10(%rbx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x50(%rsp), %bpl
movsbl %bpl, %esi
leaq 0x261a(%rip), %rdi      # 0x537d
callq 0x49a8
testl %eax, %eax
jle 0x2d7c
cmpl $0x0, 0x4c(%rsp)
je 0x2d7c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x66, %bpl
jne 0x2d99
leaq 0x20(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x2d73
cmpl $0x0, 0x1c(%rax)
jne 0x2d73
cmpl $0x0, 0x28(%rax)
jne 0x2d73
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x342a
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, 0xc(%rsp)
movq %rdi, %r14
leaq 0x50(%rsp), %r15
leaq 0x232a(%rip), %rsi      # 0x53cd
callq 0x47d0
movb 0x30(%r15), %r12b
cmpb $0x6f, %r12b
jne 0x30cc
movl 0x18(%r15), %r13d
addl %r13d, %ebx
setle %al
cmpl $0x0, (%r15)
setne %cl
andb %al, %cl
movzbl %cl, %ebx
negl %ebx
jmp 0x30d9
addl %ebx, %ebx
negl %ebx
testl %eax, %eax
cmovel %eax, %ebx
movl 0x18(%r15), %r13d
movl 0x14(%r15), %eax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
callq 0x47c0
movq %rax, 0x10(%rsp)
leaq 0x22d8(%rip), %rsi      # 0x53cd
movq %r14, %rdi
callq 0x47d0
xorl %r15d, %r15d
orl %r13d, %eax
movl $0x0, %ebp
jne 0x3121
leaq 0x50(%rsp), %rax
cmpl $0x0, (%rax)
sete %al
cmpb $0x6f, %r12b
setne %cl
orb %al, %cl
movzbl %cl, %ebp
cmpb $0x6f, %r12b
sete %r12b
leaq 0x229d(%rip), %rsi      # 0x53cd
movq %r14, %rdi
callq 0x47d0
notl %r13d
orl %eax, %r13d
sete %al
andb %r12b, %al
movzbl %al, %eax
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
cmovgl %ecx, %r15d
addl 0x8(%rsp), %ebx
addl 0x10(%rsp), %r15d
subl %r15d, %ebx
addl %ebp, %ebx
addl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rsp), %r13
testq %rdi, %rdi
leaq 0x1fec(%rip), %r14      # 0x5389
cmovneq %rdi, %r14
movl 0x14(%r13), %ebp
movl 0x18(%r13), %ebx
movq %r14, %rdi
callq 0x47c0
cmpl %eax, %ebx
movl %eax, %r12d
cmovll %ebx, %r12d
testl %ebx, %ebx
cmovsl %eax, %r12d
movl 0xc(%r13), %ebx
testl %ebx, %ebx
movl %ebp, 0x4(%rsp)
je 0x33d1
xorl %r15d, %r15d
jmp 0x33e7
movl %ebp, %esi
subl %r12d, %esi
jle 0x33cc
movl 0x38(%r13), %edx
pushq $0x20
popq %rdi
callq 0x45b0
movl %eax, %r15d
movl 0x38(%r13), %ebp
movslq %r12d, %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1060
addl %eax, %r15d
testl %ebx, %ebx
je 0x3418
movl 0x4(%rsp), %esi
subl %r12d, %esi
jle 0x3418
pushq $0x20
popq %rdi
movl %ebp, %edx
callq 0x45b0
addl %r15d, %eax
movl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
leal -0x2(%r15), %eax
cmpl $0xe, %eax
ja 0x375c
movq %rdi, %r14
testq %rdi, %rdi
je 0x378a
movl %edx, %ebp
leal 0x1(%r15), %edi
callq 0x10f0
movq %rax, %rbx
xorl %eax, %eax
testl %ebp, %ebp
sete %al
shll $0x5, %eax
addq $0x37, %rax
movl %r15d, %r13d
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x3707
leal (%rax,%rcx), %edx
leal 0x30(%rcx), %esi
cmpq $0xa, %rcx
movzbl %sil, %esi
cmovael %edx, %esi
movb %sil, (%rbx,%rcx)
incq %rcx
jmp 0x36e8
movb $0x0, (%rbx,%r13)
pushq $0x2
popq %rdi
movq %r14, %rax
testq %rax, %rax
je 0x3721
xorl %edx, %edx
divq %r13
incq %rdi
jmp 0x3712
callq 0x10f0
testq %rax, %rax
je 0x375c
movq %rax, %r15
xorl %ecx, %ecx
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %r12d, %r12d
testq %r14, %r14
je 0x3760
movq %r14, %rax
xorl %edx, %edx
divq %r13
movb (%rbx,%rdx), %dl
movb %dl, (%r15,%r12)
incq %r12
addq %rsi, %rcx
movq %rax, %r14
jmp 0x373d
xorl %eax, %eax
jmp 0x3791
sarq $0x20, %rcx
movb $0x0, (%r15,%rcx)
movq %rbx, %rdi
callq 0x1030
movq %r15, %rdi
movl %r12d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4050
leaq 0x1c3c(%rip), %rax      # 0x53cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x8(%rsp), %r8
movsbl 0x30(%r8), %ecx
cmpl $0x66, %ecx
je 0x37bf
cmpl %esi, %edi
setle %al
testl %edi, %edi
setg %r9b
testb %al, %r9b
jne 0x37c6
cmpl $0x0, 0x18(%r8)
jne 0x37c8
xorl %edi, %edi
movl 0x10(%r8), %r9d
movl 0x14(%r8), %eax
cmpb $0x66, %cl
setne %r10b
testl %edx, %edx
setne %dl
testl %edi, %edi
setne %r11b
andb %dl, %r11b
andb %r10b, %r11b
movzbl %r11b, %edx
addl %edi, %esi
subl %esi, %eax
leal 0x75(%rdi), %esi
orl 0x8(%r8), %r9d
cmovel %edi, %esi
xorl %edi, %edi
cmpl %ecx, %esi
setne %dil
addl %edx, %eax
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x8(%rsp), %rcx
testl %edi, %edi
js 0x385e
movl 0x18(%rcx), %r8d
movl 0xc(%rcx), %edx
movl %r8d, %eax
orl %edx, %eax
sete %al
movb 0x30(%rcx), %r9b
cmpb $0x66, %r9b
sete %r10b
orb %al, %r10b
cmpb $0x1, %r10b
jne 0x3869
cmpl $0x0, 0x4(%rcx)
je 0x3869
cmpb $0x66, %r9b
sete %al
testl %edx, %edx
setne %r10b
testl %edi, %edi
setne %dil
andb %r10b, %dil
testb %al, %dil
jne 0x3869
cmpl %esi, 0x14(%rcx)
jle 0x3869
pushq $0x1
popq %rax
retq
movb 0x30(%rcx), %r9b
movl 0xc(%rcx), %edx
movl 0x18(%rcx), %r8d
xorl %eax, %eax
cmpb $0x75, %r9b
jne 0x385d
testl %r8d, %r8d
jns 0x385d
testl %edx, %edx
jne 0x385d
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
fldt 0x8(%rsp)
fld %st(0)
fchs
fucomi %st(1), %st
fxch %st(1)
fcmovnbe %st(1), %st
fstp %st(1)
movapd 0x1924(%rip), %xmm1     # 0x53a0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
fstl -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3a9a
subsd %xmm1, %xmm0
jmp 0x3a8e
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x3aaa
xorpd 0x18f6(%rip), %xmm0     # 0x53a0
movsd %xmm0, -0x10(%rsp)
fldl -0x10(%rsp)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
fldt 0x50(%rsp)
fstpt 0x24(%rsp)
callq 0x3b52
movl %eax, 0x20(%rsp)
fldt 0x24(%rsp)
fimull 0x20(%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
fnstcw 0x18(%rsp)
movzwl 0x18(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0x1a(%rsp)
fldcw 0x1a(%rsp)
fistl 0x1c(%rsp)
fldcw 0x18(%rsp)
cmpl $0x2, 0x1c(%rsp)
jl 0x3b39
fld %st(0)
fstpt (%rsp)
movsd 0x18a0(%rip), %xmm0     # 0x53b0
fstpt 0x24(%rsp)
callq 0x3a64
faddl 0x1899(%rip)            # 0x53b8
incl %ebp
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
fldt 0x24(%rsp)
cmovael %r14d, %ebp
fdivs 0x1891(%rip)            # 0x53c8
jmp 0x3add
fstp %st(0)
pushq $0x30
popq %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x45b0
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/ft_putoxx.c
// Function: ft_putoxx
int	ft_putoxx(t_flags flags, char *s, int n, int b)
{
	int	nb;

	nb = 0;
	if (!flags.minus)
	{
		if (flags.zero && flags.precision <= 0)
		{
			if (ft_strcmp(s, "0") == 0)
				nb += write(flags.fd, "00", 2);
			else
				nb += write(flags.fd, xtype(flags.type),
						2 * (is_xx(flags.type) && flags.square));
			nb += ft_repet_fd('0', n - (ft_strcmp(s, "0") == 0) * 2, flags.fd);
		}
		else
			nb += ft_repet_fd(' ', n, flags.fd);
	}
	if (b && flags.type == 'o' && ft_strcmp(s, "0") != 0)
		nb += write(flags.fd, "0", 1);
	if (b && ft_strcmp(s, "0") && (flags.type == 'x' || flags.type == 'X')
		&& !(flags.zero && flags.precision <= 0 && !flags.minus))
		nb += write(flags.fd, xtype(flags.type), 2);
	return (nb);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movl 0xc(%r13), %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
jne 0x3f98
movl %esi, %r15d
cmpl $0x0, 0x4(%r13)
je 0x3f41
cmpl $0x0, 0x18(%r13)
jg 0x3f41
leaq 0x14cc(%rip), %rsi      # 0x53cd
movq %rbx, %rdi
callq 0x47d0
movl 0x38(%r13), %r14d
testl %eax, %eax
je 0x3f55
movb 0x30(%r13), %al
cmpb $0x78, %al
leaq 0x14b1(%rip), %rcx      # 0x53cf
leaq 0x14ad(%rip), %rsi      # 0x53d2
cmoveq %rcx, %rsi
andb $-0x21, %al
cmpb $0x58, %al
sete %al
cmpl $0x0, (%r13)
setne %cl
andb %al, %cl
movzbl %cl, %edx
addl %edx, %edx
jmp 0x3f5f
movl 0x38(%r13), %edx
pushq $0x20
popq %rdi
movl %r15d, %esi
callq 0x45b0
movl %eax, %r14d
jmp 0x3f98
leaq 0x1470(%rip), %rsi      # 0x53cc
pushq $0x2
popq %rdx
movl %r14d, %edi
callq 0x1060
movq %rax, (%rsp)
leaq 0x145b(%rip), %rsi      # 0x53cd
movq %rbx, %rdi
callq 0x47d0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal -0x2(%r15,%rcx,2), %esi
pushq $0x30
popq %rdi
movl %r14d, %edx
callq 0x45b0
movl %eax, %r14d
addl (%rsp), %r14d
testl %ebp, %ebp
setne %al
movb 0x30(%r13), %r15b
cmpb $0x6f, %r15b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x3fda
leaq 0x1417(%rip), %rsi      # 0x53cd
movq %rbx, %rdi
callq 0x47d0
testl %eax, %eax
je 0x3fde
movl 0x38(%r13), %edi
leaq 0x1400(%rip), %rsi      # 0x53cd
pushq $0x1
popq %rdx
callq 0x1060
addl %eax, %r14d
jmp 0x3fde
testl %ebp, %ebp
je 0x403d
leaq 0x13e8(%rip), %rsi      # 0x53cd
movq %rbx, %rdi
callq 0x47d0
testl %eax, %eax
setne %al
movl %r15d, %ecx
andb $-0x21, %cl
cmpb $0x58, %cl
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x403d
testl %r12d, %r12d
jne 0x4018
cmpl $0x0, 0x4(%r13)
je 0x4018
cmpl $0x0, 0x18(%r13)
jle 0x403d
movl 0x38(%r13), %edi
cmpb $0x78, %r15b
leaq 0x13a8(%rip), %rax      # 0x53cf
leaq 0x13a4(%rip), %rsi      # 0x53d2
cmoveq %rax, %rsi
pushq $0x2
popq %rdx
callq 0x1060
addl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x10f0
movq %rax, %r14
testq %rax, %rax
je 0x40a7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4aa8
movslq %r15d, %rax
decq %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
jle 0x409f
movb (%r14,%rax), %dl
movb (%r14,%rcx), %sil
movb %sil, (%r14,%rax)
movb %dl, (%r14,%rcx)
incq %rcx
decq %rax
jmp 0x4082
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %r14
movb %dil, 0x7(%rsp)
movl 0xc(%r14), %r15d
testl %r15d, %r15d
jne 0x40e5
movl 0x14(%r14), %esi
cmpl $0x2, %esi
jl 0x40e5
decl %esi
movl 0x38(%r14), %edx
pushq $0x20
popq %rdi
callq 0x45b0
movl %eax, %ebx
jmp 0x40e7
xorl %ebx, %ebx
movl 0x38(%r14), %ebp
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
movl %ebp, %edi
callq 0x1060
addl %eax, %ebx
testl %r15d, %r15d
je 0x411a
movl 0x14(%r14), %esi
cmpl $0x2, %esi
jl 0x411a
decl %esi
pushq $0x20
popq %rdi
movl %ebp, %edx
callq 0x45b0
addl %ebx, %eax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rdx
negq %rdx
cmovsq %rdi, %rdx
movl 0x20(%rsp), %ecx
cmpb $0x75, 0x38(%rsp)
movl %edi, %eax
cmovnel %edx, %eax
xorl %esi, %esi
pushq $0xa
popq %r8
testl %eax, %eax
je 0x4152
incl %esi
xorl %edx, %edx
divl %r8d
jmp 0x4145
cmpq $0x1, %rdi
movl %ecx, %edx
sbbl $0x0, %edx
subl %esi, %edx
xorl %eax, %eax
cmpl %esi, %ecx
cmovgl %edx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %ecx
andl $0x0, (%rdx)
xorl %edi, %edi
pushq $-0x1
popq %r8
xorl %eax, %eax
xorl %r9d, %r9d
testl %ecx, %ecx
js 0x41c2
movq %rsi, %r10
shrq %cl, %r10
testb $0xf, %r10b
je 0x41ad
testl %r9d, %r9d
je 0x41b2
testl %edi, %edi
jne 0x41bb
movl %r9d, (%rdx)
movl %r9d, %edi
jmp 0x41bb
incl %r9d
jmp 0x41bb
orl $-0x1, (%rdx)
xorl %r9d, %r9d
movl %r8d, %edi
incl %eax
addl $-0x4, %ecx
jmp 0x418c
xorl %ecx, %ecx
testq %rsi, %rsi
cmovel %ecx, %eax
subl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/aux/print_address.c
// Function: ft_width
int	ft_width(t_flags flags, int size, int g)
{
	int	nb;
	int	mprec;

	nb = 0;
	mprec = size;
	if (flags.precision > size)
		mprec = flags.precision;
	if (!flags.minus && !size)
	{
		nb += ft_repet_fd(' ', flags.width - 3 + g - flags.precision, flags.fd);
		return (nb + write(flags.fd, "0x0", 3 - g) + ft_repet_fd('0',
				flags.precision - 1, flags.fd));
	}
	if (!flags.minus)
		return (ft_repet_fd(' ', flags.width - mprec
				- flags.space - flags.plus - 2, flags.fd));
	if (!size)
	{
		nb += write(flags.fd, "0x0", 3 - g)
			+ ft_repet_fd('0', flags.precision - 1, flags.fd);
		return (nb + ft_repet_fd(' ', flags.width - 3 + g - flags.precision,
				flags.fd));
	}
	return (nb + ft_repet_fd(' ', flags.width - mprec
			- flags.space - flags.plus - 2, flags.fd));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
leaq 0x30(%rsp), %r12
movl 0xc(%r12), %ecx
movl 0x18(%r12), %ebx
cmpl %edi, %ebx
movl %edi, %eax
cmovgl %ebx, %eax
movl %ecx, %edx
orl %edi, %edx
je 0x4228
testl %ecx, %ecx
je 0x41fc
testl %edi, %edi
je 0x427a
addl 0x10(%r12), %eax
addl 0x8(%r12), %eax
movl 0x14(%r12), %ecx
movl 0x38(%r12), %edx
negl %eax
leal (%rcx,%rax), %esi
addl $-0x2, %esi
pushq $0x20
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x45b0
movl %r14d, %eax
subl %ebx, %eax
movl 0x14(%r12), %ecx
movl 0x38(%r12), %ebp
leal (%rax,%rcx), %esi
addl $-0x3, %esi
pushq $0x20
popq %rdi
movl %ebp, %edx
callq 0x45b0
movl %eax, %r15d
pushq $0x3
popq %rax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0x117b(%rip), %rsi      # 0x53d5
movl %ebp, %edi
callq 0x1060
movq %rax, %r14
decl %ebx
pushq $0x30
popq %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x45b0
addl %eax, %r14d
addl %r15d, %r14d
jmp 0x42c8
movl 0x38(%r12), %ebp
pushq $0x3
popq %rax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0x1146(%rip), %rsi      # 0x53d5
movl %ebp, %edi
callq 0x1060
movq %rax, %r15
leal -0x1(%rbx), %esi
pushq $0x30
popq %rdi
movl %ebp, %edx
callq 0x45b0
addl %eax, %r15d
movl 0x14(%r12), %eax
subl %ebx, %r14d
leal (%r14,%rax), %esi
addl $-0x3, %esi
pushq $0x20
popq %rdi
movl %ebp, %edx
callq 0x45b0
movl %eax, %r14d
addl %r15d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
je 0x4301
leaq 0x8(%rsp), %rax
movl 0x18(%rax), %ecx
cmpl %edi, %ecx
cmovgl %ecx, %edi
addl 0x10(%rax), %edi
addl 0x8(%rax), %edi
movl 0x14(%rax), %ecx
negl %edi
leal (%rcx,%rdi), %esi
addl $-0x2, %esi
movl 0x38(%rax), %edx
pushq $0x30
popq %rdi
jmp 0x45b0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
leaq 0xf(%rsp), %r14
movb %dil, (%r14)
xorl %r15d, %r15d
pushq $0x1
popq %r12
cmpl %ebp, %r15d
jge 0x45e6
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4520
addl %eax, %r15d
jmp 0x45cf
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
movabsq $0x100003e00, %rdx      # imm = 0x100003E00
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %eax, %eax
movzbl (%rdi,%rax), %r8d
cmpq $0x20, %r8
ja 0x4635
btq %r8, %rdx
jae 0x4635
incq %rax
addq %rsi, %rcx
jmp 0x461c
sarq $0x20, %rcx
movzbl (%rdi,%rcx), %ecx
cmpl $0x2b, %ecx
je 0x4647
cmpl $0x2d, %ecx
jne 0x464a
incq %rax
cltq
addq %rax, %rdi
xorl %edx, %edx
movb (%rdi), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x468c
cmpl $0xccccccc, %edx        # imm = 0xCCCCCCC
jne 0x467f
cmpb $0x2d, %cl
sete %r8b
cmpb $0x8, %al
sete %sil
andb %r8b, %sil
cmpb $0x7, %al
setne %r9b
orb %r8b, %r9b
cmpb %r9b, %sil
je 0x4697
movzbl %al, %eax
imull $0xa, %edx, %edx
addl %eax, %edx
incq %rdi
jmp 0x4651
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
movzbl %sil, %eax
addl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x2c(%rsp)
je 0x46c1
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x46e1
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x46ed
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x46f1
cmpl $0x28, %ecx
ja 0x46e1
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x46ed
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x4704
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4710
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x471d
movsbq %cl, %rax
retq
cmpl $0x0, 0x20(%rax)
je 0x4728
movswq %cx, %rax
retq
movslq %ecx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/caster.c
// Function: flags_uoxx
uintmax_t	flags_uoxx(t_flags flags, va_list ap)
{
	uintmax_t	x;

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

// Assembly:
cmpl $0x0, 0x2c(%rsp)
je 0x4749
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4769
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4775
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x4779
cmpl $0x28, %ecx
ja 0x4769
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4775
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x478c
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4798
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x47a5
movzbl %cl, %eax
jmp 0x47af
cmpl $0x0, 0x20(%rax)
movzwl %cx, %eax
cmovel %ecx, %eax
movl %eax, %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocate/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*str;
	int		l1;
	int		l2;
	int		i;

	if (s1 && s2)
	{
		l1 = ft_strlen(s1);
		l2 = ft_strlen(s2);
		str = ft_strnew(l1 + l2);
		if (!str)
			return (NULL);
		i = 0;
		while (i < l1 + l2)
		{
			if (i < l1)
				str[i] = s1[i];
			else
				str[i] = s2[i - l1];
			i++;
		}
		str[i] = '\0';
		return (str);
	}
	return (NULL);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x4860
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x47c0
movq %rax, %r12
movq %rbx, %rdi
callq 0x47c0
movq %rax, %r15
addl %r12d, %r15d
movslq %r15d, %rdi
callq 0x4878
xorl %ecx, %ecx
testq %rax, %rax
je 0x486a
movslq %r12d, %rdx
testl %r15d, %r15d
cmovlel %ecx, %r15d
subq %rdx, %rbx
cmpq %rcx, %r15
je 0x4863
cmpq %rdx, %rcx
movq %rbx, %rsi
cmovlq %r14, %rsi
movb (%rsi,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x4844
xorl %eax, %eax
retq
movb $0x0, (%rax,%r15)
jmp 0x486c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocate/ft_strnew.c
// Function: ft_strnew
char	*ft_strnew(size_t size)
{
	char			*fresh;
	unsigned int	i;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
incq %rdi
callq 0x10f0
testq %rax, %rax
je 0x489b
xorl %edx, %edx
movl %edx, %ecx
cmpq %rbx, %rcx
ja 0x489b
leal 0x1(%rcx), %edx
movb $0x0, (%rax,%rcx)
jmp 0x488b
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocate/strins.c
// Function: strins
void	strins(char array[][256], char *str, size_t pos, size_t size)
{
	long	last;

	if (size == 0)
	{
		element_copy(array, pos, str);
		return ;
	}
	last = (long)size;
	last--;
	while (4 <= (last - (long)pos) && 0 <= (last - (long)pos))
	{
		element_copy(array, last + 1, array[last]);
		element_copy(array, last, array[last - 1]);
		element_copy(array, last - 1, array[last - 2]);
		element_copy(array, last - 2, array[last - 3]);
		last -= 4;
	}
	while ((long)pos <= last && 0 <= last)
	{
		element_copy(array, last + 1, array[last]);
		last--;
	}
	element_copy(array, pos, str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x4977
movq %rbx, 0x10(%rsp)
leaq -0x1(%rcx), %r12
shlq $0x8, %rcx
leaq (%rcx,%r15), %r13
addq $-0x100, %r13
movq %r14, 0x8(%rsp)
negq %r14
leaq (%r14,%r12), %rax
cmpq $0x3, %rax
jle 0x4947
leaq 0x1(%r12), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x4990
leaq -0x1(%r12), %rbp
leaq -0x100(%r13), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x4990
leaq -0x2(%r12), %rbx
leaq -0x200(%r13), %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4990
leaq -0x300(%r13), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4990
addq $-0x4, %r12
addq $-0x400, %r13           # imm = 0xFC00
jmp 0x48e0
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %r12
jl 0x4977
testq %r12, %r12
js 0x4977
leaq 0x1(%r12), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x4990
addq $-0x100, %r13
decq %r12
jmp 0x4951
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4990
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocated/ft_strcat.c
// Function: ft_strcat
char	*ft_strcat(char *restrict s1, const char *restrict s2)
{
	unsigned int	i;
	unsigned int	j;

	i = 0;
	while (s1[i])
		i++;
	j = 0;
	while (s2[j])
		s1[i++] = s2[j++];
	s1[i] = '\0';
	return (s1);
}

// Assembly:
movq %rdi, %rax
pushq $-0x1
popq %rcx
incl %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x49ce
xorl %edx, %edx
movl %edx, %edi
movb (%rsi,%rdi), %r8b
movl %ecx, %edi
testb %r8b, %r8b
je 0x49ef
incl %edx
incl %ecx
movb %r8b, (%rax,%rdi)
jmp 0x49d8
movb $0x0, (%rax,%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocated/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *dstpp, int c, size_t len)
{
	long int	dstp;
	t_u_long	cccc;

	dstp = (long int) dstpp;
	if (len >= 8)
	{
		cccc = (unsigned char) c;
		cccc |= cccc << 8;
		cccc |= cccc << 16;
		if ((sizeof(t_u_long)) > 4)
			cccc |= (cccc << 16) << 16;
		while (dstp % (sizeof(t_u_long)) != 0)
		{
			((t_byte *)dstp)[0] = c;
			dstp += 1;
			len -= 1;
		}
		bwritex(len, &dstp, cccc);
		len = bwrite(len, &dstp, cccc);
	}
	blast_bytes(len, &dstp, c);
	return (dstpp);
}

// Assembly:
movq %rdi, %rax
movq %rdi, -0x8(%rsp)
cmpq $0x8, %rdx
jb 0x4a87
movzbl %sil, %ecx
imull $0x1010101, %ecx, %edi  # imm = 0x1010101
movq %rax, %rcx
testb $0x7, %cl
je 0x4a23
movb %sil, (%rcx)
incq %rcx
decq %rdx
jmp 0x4a13
movabsq $0x100000001, %r8       # imm = 0x100000001
imulq %r8, %rdi
movq %rdx, %r8
shrq $0x6, %r8
subq $0x1, %r8
jb 0x4a63
movq %rdi, (%rcx)
movq %rdi, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rdi, 0x18(%rcx)
movq %rdi, 0x20(%rcx)
movq %rdi, 0x28(%rcx)
movq %rdi, 0x30(%rcx)
movq %rdi, 0x38(%rcx)
addq $0x40, %rcx
jmp 0x4a38
movl %edx, %r8d
andl $0x38, %r8d
xorl %r9d, %r9d
cmpq %r9, %r8
je 0x4a7c
movq %rdi, (%rcx,%r9)
addq $0x8, %r9
jmp 0x4a6d
addq %r9, %rcx
movq %rcx, -0x8(%rsp)
andl $0x7, %edx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x4a9b
movq -0x8(%rsp,%rcx,8), %rdi
movb %sil, (%rdi)
incq %rcx
jmp 0x4a89
retq
// File: /workspace/github_c_makefile_star2_O2/DavidSM64[P]DKR-Decompressor/dkr_decompressor.cpp
// Function: printHelp()
void printHelp()
{
    std::cout 
    << "---- Usage ----" << std::endl
    << " Compress file: ./dkr_decompressor -c <input_filename> <output_filename>" << std::endl
    << " Decompress file: ./dkr_decompressor -d <input_filename> <output_filename>" << std::endl
    << " Decompress section from a ROM file: ./dkr_decompressor -r <rom_filename> <output_filename> <rom_offset> <length>" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x7b89(%rip), %rdi      # 0x9fd0
leaq 0x4bb6(%rip), %rsi      # 0x7004
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq 0x4bb2(%rip), %rsi      # 0x7014
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq 0x4be4(%rip), %rsi      # 0x705d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
leaq 0x4c18(%rip), %rsi      # 0x70a8
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
popq %rbp
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O2/DavidSM64[P]DKR-Decompressor/DKRCompression.cpp
// Function: DKRCompression::compressBuffer(std::vector<unsigned char, std::allocator<unsigned char>>)
std::vector<uint8_t> DKRCompression::compressBuffer(std::vector<uint8_t> data) 
{
    int uncompressedSize = data.size();
    int compressedSize = 0;
    
    uint8_t* compressed = dkr_gzip_compress(&data[0], uncompressedSize, 9, &compressedSize);
    
    std::vector<uint8_t> dkr_compressed(compressed + 10, compressed + compressedSize - 8);
    
    dkr_compressed.insert(dkr_compressed.begin(), 0x09); // gzip compression level?
    dkr_compressed.insert(dkr_compressed.begin(), (uncompressedSize >> 24) & 0xFF);
    dkr_compressed.insert(dkr_compressed.begin(), (uncompressedSize >> 16) & 0xFF);
    dkr_compressed.insert(dkr_compressed.begin(), (uncompressedSize >> 8) & 0xFF);
    dkr_compressed.insert(dkr_compressed.begin(), uncompressedSize & 0xFF);
    
    while((dkr_compressed.size() & 0xF) != 0) {
        dkr_compressed.push_back(0); // Pad out compressed file to be 16-byte aligned.
    }
    
    return dkr_compressed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movq 0x8(%rdx), %rsi
subq %rdi, %rsi
leaq -0x24(%rbp), %r14
andl $0x0, (%r14)
pushq $0x9
popq %rdx
movq %rsi, %r15
movq %r14, %rcx
callq 0x618e
movslq (%r14), %rcx
leaq (%rax,%rcx), %rdx
addq $-0x8, %rdx
leaq 0xa(%rax), %rsi
leaq -0x1f(%rbp), %rcx
movq %rbx, %rdi
callq 0x30a2
movq (%rbx), %rsi
leaq -0x1e(%rbp), %rdx
movb $0x9, (%rdx)
movq %rbx, %rdi
callq 0x315e
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x18, %eax
leaq -0x1d(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x315e
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x10, %eax
leaq -0x1c(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x315e
movq (%rbx), %rsi
movq %r15, %rax
movb %ah, -0x1a(%rbp)
leaq -0x1a(%rbp), %rdx
movq %rbx, %rdi
callq 0x315e
movq (%rbx), %rsi
leaq -0x1b(%rbp), %rdx
movb %r15b, (%rdx)
movq %rbx, %rdi
callq 0x315e
leaq -0x19(%rbp), %r14
movl 0x8(%rbx), %eax
subl (%rbx), %eax
testb $0xf, %al
je 0x2e50
movb $0x0, -0x19(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f8
jmp 0x2e36
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e68
jmp 0x2e68
jmp 0x2e68
jmp 0x2e68
jmp 0x2e68
movq %rax, %r14
movq %rbx, %rdi
callq 0x2bd2
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_c_makefile_star2_O2/DavidSM64[P]DKR-Decompressor/DKRCompression.cpp
// Function: DKRCompression::decompressBuffer(std::vector<unsigned char, std::allocator<unsigned char>>)
std::vector<uint8_t> DKRCompression::decompressBuffer(std::vector<uint8_t> data) 
{
    compressed.SetCompressedBuffer(&data[0], data.size());
    
    int fileSize = 0, fileSizeCompressed = 0;
    uint8_t* decompressed = compressed.OutputDecompressedBuffer(fileSize, fileSizeCompressed);
    
    std::vector<uint8_t> out(decompressed, decompressed + fileSize);
    
    delete[] decompressed;
    
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
subl %esi, %edx
movq %r14, %rdi
callq 0x34d0
leaq -0x24(%rbp), %r15
andl $0x0, (%r15)
leaq -0x20(%rbp), %rdx
andl $0x0, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3600
movq %rax, %r14
movslq (%r15), %rdx
addq %rax, %rdx
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30a2
testq %r14, %r14
je 0x2ede
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq