LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x49dc
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 0x2d94
cmpb $0x2e, %dl
jne 0x2dd6
sarq $0x20, %rdi
addq %r14, %rdi
callq 0x49dc
movl %eax, 0x18(%r15)
movslq %r12d, %rax
decq %rax
movb 0x1(%r14,%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x2dc6
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_O1/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 0x2e49
cmpl $0x0, 0x18(%rbx)
jle 0x2e3c
movsbl 0x30(%rbx), %esi
leaq 0x254a(%rip), %rdi      # 0x537d
callq 0x4df4
testl %eax, %eax
jg 0x2e42
cmpl $0x0, 0xc(%rbx)
je 0x2e49
movl $0x0, 0x4(%rbx)
cmpl $0x0, 0x10(%rbx)
je 0x2e5c
cmpl $0x0, 0x8(%rbx)
je 0x2e5c
movl $0x0, 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r15d
movl %esi, 0xc(%rsp)
movq %rdi, %r14
leaq 0x50(%rsp), %rbx
leal (%r15,%r15), %ebp
negl %ebp
leaq 0x2227(%rip), %rsi      # 0x53dd
callq 0x4bc0
testl %eax, %eax
cmovel %eax, %ebp
movb 0x30(%rbx), %r13b
cmpb $0x6f, %r13b
jne 0x31de
addl 0x18(%rbx), %r15d
setle %al
cmpl $0x0, (%rbx)
setne %cl
andb %al, %cl
movzbl %cl, %ebp
negl %ebp
movl 0x14(%rbx), %eax
movl %eax, 0x8(%rsp)
movq %r14, %rdi
callq 0x4bb0
movq %rax, 0x10(%rsp)
leaq 0x21e4(%rip), %rsi      # 0x53dd
movq %r14, %rdi
callq 0x4bc0
movq %rbx, %rcx
movl 0x18(%rbx), %r12d
xorl %r15d, %r15d
orl %r12d, %eax
movl $0x0, %ebx
jne 0x3227
cmpl $0x0, (%rcx)
sete %al
cmpb $0x6f, %r13b
setne %cl
orb %al, %cl
movzbl %cl, %ebx
cmpb $0x6f, %r13b
sete %r13b
leaq 0x21a7(%rip), %rsi      # 0x53dd
movq %r14, %rdi
callq 0x4bc0
notl %r12d
orl %eax, %r12d
sete %al
andb %r13b, %al
movzbl %al, %eax
movl 0xc(%rsp), %ecx
testl %ecx, %ecx
cmovgl %ecx, %r15d
addl 0x8(%rsp), %ebp
addl 0x10(%rsp), %r15d
subl %r15d, %ebp
addl %ebx, %ebp
addl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ee2(%rip), %r14      # 0x5389
cmovneq %rdi, %r14
movl 0x14(%r13), %ebp
movl 0x18(%r13), %ebx
movq %r14, %rdi
callq 0x4bb0
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 0x34db
xorl %r15d, %r15d
jmp 0x34f3
movl %ebp, %esi
subl %r12d, %esi
jle 0x34d6
movl 0x38(%r13), %edx
movl $0x20, %edi
callq 0x4988
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 0x3526
movl 0x4(%rsp), %esi
subl %r12d, %esi
jle 0x3526
movl $0x20, %edi
movl %ebp, %edx
callq 0x4988
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_O1/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 0x38b6
movq %rdi, %rbx
testq %rdi, %rdi
je 0x3824
movl %edx, %ebp
leal 0x1(%r15), %edi
callq 0x10f0
movq %rax, %r14
movl %r15d, %r13d
testl %r15d, %r15d
jle 0x3830
xorl %eax, %eax
testl %ebp, %ebp
sete %al
shll $0x5, %eax
addq $0x37, %rax
xorl %ecx, %ecx
leal (%rax,%rcx), %edx
leal 0x30(%rcx), %esi
cmpq $0xa, %rcx
movzbl %sil, %esi
cmovael %edx, %esi
movb %sil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r13
jne 0x3805
jmp 0x3832
leaq 0x1bb2(%rip), %rax      # 0x53dd
jmp 0x38b8
xorl %ecx, %ecx
movb $0x0, (%r14,%rcx)
movl $0x2, %edi
movq %rbx, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
incq %rdi
cmpq %r13, %rcx
movq %rax, %rcx
jae 0x383f
callq 0x10f0
testq %rax, %rax
je 0x38b6
movq %rax, %r15
xorl %ecx, %ecx
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %r12d, %r12d
movq %rbx, %rax
xorl %edx, %edx
divq %r13
movb (%r14,%rdx), %dl
movb %dl, (%r15,%r12)
incq %r12
addq %rsi, %rcx
cmpq %r13, %rbx
movq %rax, %rbx
jae 0x386e
sarq $0x20, %rcx
movb $0x0, (%r15,%rcx)
movq %r14, %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 0x436c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x38e7
cmpl %esi, %edi
setle %al
testl %edi, %edi
setg %r9b
testb %al, %r9b
jne 0x38ee
cmpl $0x0, 0x18(%r8)
jne 0x38f0
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_O1/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 0x3981
movl 0xc(%rcx), %eax
movl 0x18(%rcx), %edx
orl %eax, %edx
sete %r8b
movb 0x30(%rcx), %dl
cmpb $0x66, %dl
sete %r9b
orb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x3981
cmpl $0x0, 0x4(%rcx)
je 0x3981
cmpb $0x66, %dl
sete %dl
testl %eax, %eax
setne %al
testl %edi, %edi
setne %dil
andb %al, %dil
testb %dl, %dil
jne 0x3981
movl $0x1, %eax
cmpl %esi, 0x14(%rcx)
jle 0x3981
retq
xorl %eax, %eax
cmpb $0x75, 0x30(%rcx)
jne 0x3980
cmpl $0x0, 0x18(%rcx)
jns 0x3980
cmpl $0x0, 0xc(%rcx)
jne 0x3980
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1794(%rip), %xmm1     # 0x53a0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
fstl -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3c2a
subsd %xmm1, %xmm0
jmp 0x3c1e
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x3c3a
xorpd 0x1766(%rip), %xmm0     # 0x53a0
movsd %xmm0, -0x10(%rsp)
fldl -0x10(%rsp)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
movl %esi, %edx
fldt 0x40(%rsp)
fld1
testl %edi, %edi
jle 0x3c73
fstp %st(0)
incl %edi
movl $0x1, %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
decl %edi
cmpl $0x1, %edi
jg 0x3c5f
movl %eax, 0x1c(%rsp)
fildl 0x1c(%rsp)
fmulp %st, %st(1)
fnstcw 0xe(%rsp)
movzwl 0xe(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0x12(%rsp)
fldcw 0x12(%rsp)
fistl 0x18(%rsp)
fldcw 0xe(%rsp)
xorl %ebx, %ebx
cmpl $0x2, 0x18(%rsp)
jl 0x3d35
xorl %eax, %eax
movsd 0x1705(%rip), %xmm0     # 0x53b0
movapd 0x16ed(%rip), %xmm1     # 0x53a0
movsd 0x16fd(%rip), %xmm2     # 0x53b8
xorl %ebx, %ebx
fld %st(0)
fchs
fucomi %st(1), %st
fld %st(1)
fcmovnbe %st(1), %st
fstp %st(1)
fstl 0x28(%rsp)
movsd 0x28(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jb 0x3cdf
addsd %xmm2, %xmm3
jmp 0x3cd3
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x3ceb
xorpd %xmm1, %xmm3
movsd %xmm3, 0x20(%rsp)
fldl 0x20(%rsp)
faddl 0x16c5(%rip)            # 0x53c0
incl %ebx
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
cmovael %eax, %ebx
fdivs 0x16ca(%rip)            # 0x53d8
fnstcw 0xc(%rsp)
movzwl 0xc(%rsp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, 0x10(%rsp)
fldcw 0x10(%rsp)
fistl 0x14(%rsp)
fldcw 0xc(%rsp)
cmpl $0x1, 0x14(%rsp)
jg 0x3cbd
fstp %st(0)
movl $0x30, %edi
movl %ebx, %esi
callq 0x4988
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x42b2
movl %esi, %r15d
cmpl $0x0, 0x4(%r13)
je 0x4255
cmpl $0x0, 0x18(%r13)
jg 0x4255
leaq 0x11c8(%rip), %rsi      # 0x53dd
movq %rbx, %rdi
callq 0x4bc0
movl 0x38(%r13), %edi
testl %eax, %eax
je 0x426b
movb 0x30(%r13), %al
cmpb $0x78, %al
leaq 0x11ad(%rip), %rcx      # 0x53df
leaq 0x11a9(%rip), %rsi      # 0x53e2
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 0x4277
movl 0x38(%r13), %edx
movl $0x20, %edi
movl %r15d, %esi
callq 0x4988
movl %eax, %r14d
jmp 0x42b2
leaq 0x116a(%rip), %rsi      # 0x53dc
movl $0x2, %edx
callq 0x1060
movq %rax, (%rsp)
leaq 0x1156(%rip), %rsi      # 0x53dd
movq %rbx, %rdi
callq 0x4bc0
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%r15,%rcx,2), %esi
addl $-0x2, %esi
movl 0x38(%r13), %edx
movl $0x30, %edi
callq 0x4988
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 0x42f4
leaq 0x110d(%rip), %rsi      # 0x53dd
movq %rbx, %rdi
callq 0x4bc0
testl %eax, %eax
je 0x42f4
movl 0x38(%r13), %edi
leaq 0x10f6(%rip), %rsi      # 0x53dd
movl $0x1, %edx
callq 0x1060
addl %eax, %r14d
testl %ebp, %ebp
je 0x4359
leaq 0x10de(%rip), %rsi      # 0x53dd
movq %rbx, %rdi
callq 0x4bc0
testl %eax, %eax
setne %al
movl %r15d, %ecx
andb $-0x21, %cl
cmpb $0x58, %cl
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4359
testl %r12d, %r12d
jne 0x4332
cmpl $0x0, 0x4(%r13)
je 0x4332
cmpl $0x0, 0x18(%r13)
jle 0x4359
movl 0x38(%r13), %edi
cmpb $0x78, %r15b
leaq 0x109e(%rip), %rax      # 0x53df
leaq 0x109a(%rip), %rsi      # 0x53e2
cmoveq %rax, %rsi
movl $0x2, %edx
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_O1/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, %r14
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x10f0
testq %rax, %rax
je 0x43ce
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x4f2c
cmpl $0x2, %r15d
jl 0x43c4
movl %r15d, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb 0x1(%rbx,%rax), %dl
movb (%rbx,%rcx), %sil
movb %sil, 0x1(%rbx,%rax)
movb %dl, (%rbx,%rcx)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jg 0x43a5
movq %r14, %rdi
callq 0x1030
jmp 0x43d0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4410
movl 0x14(%r14), %esi
cmpl $0x2, %esi
jl 0x4410
decl %esi
movl 0x38(%r14), %edx
movl $0x20, %edi
callq 0x4988
movl %eax, %ebx
jmp 0x4412
xorl %ebx, %ebx
movl 0x38(%r14), %ebp
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x1060
addl %eax, %ebx
testl %r15d, %r15d
je 0x4449
movl 0x14(%r14), %esi
cmpl $0x2, %esi
jl 0x4449
decl %esi
movl $0x20, %edi
movl %ebp, %edx
callq 0x4988
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_O1/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, %rax
negq %rax
cmovsq %rdi, %rax
cmpb $0x75, 0x38(%rsp)
movl %edi, %esi
cmovnel %eax, %esi
movl 0x20(%rsp), %ecx
xorl %eax, %eax
movl $0x0, %edx
testl %esi, %esi
je 0x4496
xorl %edx, %edx
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
incl %edx
movl %esi, %r9d
imulq %r8, %r9
shrq $0x23, %r9
cmpl $0x9, %esi
movl %r9d, %esi
ja 0x4481
cmpq $0x1, %rdi
movl %ecx, %esi
sbbl $0x0, %esi
subl %edx, %esi
cmpl %edx, %ecx
cmovgl %esi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 $0x0, (%rdx)
xorl %r8d, %r8d
movl $0x0, %eax
testl %edi, %edi
js 0x450b
movl %edi, %ecx
shrl $0x2, %edi
movl %edi, %eax
incl %eax
xorl %edi, %edi
movq %rsi, %r9
shrq %cl, %r9
testb $0xf, %r9b
je 0x44f2
testl %edi, %edi
je 0x44f6
cmpl $0x0, (%rdx)
jne 0x44fe
movl %edi, (%rdx)
jmp 0x44fe
incl %edi
jmp 0x44fe
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
xorl %edi, %edi
leaq -0x4(%rcx), %r9
cmpq $0x3, %rcx
movq %r9, %rcx
jg 0x44d9
testq %rsi, %rsi
cmovel %r8d, %eax
subl (%rdx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4576
testl %ecx, %ecx
je 0x4548
testl %edi, %edi
je 0x45ce
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
movl $0x20, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4988
movl %r14d, %eax
subl %ebx, %eax
movl 0x14(%r12), %ecx
movl 0x38(%r12), %ebp
leal (%rax,%rcx), %esi
addl $-0x3, %esi
movl $0x20, %edi
movl %ebp, %edx
callq 0x4988
movl %eax, %r15d
movl $0x3, %eax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0xe39(%rip), %rsi       # 0x53e5
movl %ebp, %edi
callq 0x1060
movq %rax, %r14
decl %ebx
movl $0x30, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x4988
addl %eax, %r14d
addl %r15d, %r14d
jmp 0x4622
movl 0x38(%r12), %ebp
movl $0x3, %eax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0xe00(%rip), %rsi       # 0x53e5
movl %ebp, %edi
callq 0x1060
movq %rax, %r15
leal -0x1(%rbx), %esi
movl $0x30, %edi
movl %ebp, %edx
callq 0x4988
addl %eax, %r15d
movl 0x14(%r12), %eax
subl %ebx, %r14d
leal (%r14,%rax), %esi
addl $-0x3, %esi
movl $0x20, %edi
movl %ebp, %edx
callq 0x4988
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_O1/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 0x465d
leaq 0x8(%rsp), %rax
movl 0x14(%rax), %ecx
movl 0x18(%rax), %edx
cmpl %edi, %edx
cmovgl %edx, %edi
addl 0x10(%rax), %edi
addl 0x8(%rax), %edi
negl %edi
leal (%rcx,%rdi), %esi
addl $-0x2, %esi
movl 0x38(%rax), %edx
movl $0x30, %edi
jmp 0x4988
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movb %dil, 0x7(%rsp)
testl %esi, %esi
jle 0x49bd
movl %edx, %ebx
movl %esi, %ebp
xorl %r14d, %r14d
leaq 0x7(%rsp), %r15
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x48d0
addl %eax, %r14d
cmpl %ebp, %r14d
jl 0x49a4
jmp 0x49c0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 $0x100000000, %rdx      # imm = 0x100000000
xorl %eax, %eax
movzbl (%rdi,%rax), %esi
leal -0x9(%rsi), %r8d
cmpl $0x5, %r8d
jae 0x4a00
incq %rax
addq %rdx, %rcx
jmp 0x49ea
cmpl $0x20, %esi
je 0x49f8
sarq $0x20, %rcx
movzbl (%rdi,%rcx), %ecx
cmpl $0x2b, %ecx
je 0x4a17
cmpl $0x2d, %ecx
jne 0x4a19
incl %eax
cltq
movb (%rdi,%rax), %dl
leal -0x30(%rdx), %r8d
xorl %esi, %esi
cmpb $0x9, %r8b
ja 0x4a73
addq %rdi, %rax
incq %rax
xorl %esi, %esi
addb $-0x30, %dl
movzbl %dl, %edi
cmpl $0xccccccc, %esi        # imm = 0xCCCCCCC
jne 0x4a5f
cmpb $0x2d, %cl
sete %r8b
cmpl $0x8, %edi
sete %r10b
cmpl $0x7, %edi
setne %r9b
testb %r10b, %r8b
jne 0x4a7e
orb %r9b, %r8b
je 0x4a7e
leal (%rsi,%rsi,4), %edx
leal (%rdi,%rdx,2), %esi
movb (%rax), %dl
leal -0x30(%rdx), %edi
incq %rax
cmpb $0xa, %dil
jb 0x4a32
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
retq
xorb $0x2d, %cl
xorb $0x8, %dl
xorl %eax, %eax
orb %cl, %dl
sete %al
addl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4ab1
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4ad1
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4add
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x4ae1
cmpl $0x28, %ecx
ja 0x4ad1
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4add
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x4af4
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4b00
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x4b0d
movsbq %cl, %rax
retq
cmpl $0x0, 0x20(%rax)
je 0x4b18
movswq %cx, %rax
retq
movslq %ecx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4b39
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4b59
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4b65
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x4b69
cmpl $0x28, %ecx
ja 0x4b59
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4b65
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x4b7c
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4b88
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x4b95
movzbl %cl, %eax
jmp 0x4b9f
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_O1/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 0x4c51
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4bb0
movq %rax, %r15
movq %rbx, %rdi
callq 0x4bb0
movq %rax, %r12
addl %r15d, %r12d
movslq %r12d, %rdi
callq 0x4c6c
testq %rax, %rax
je 0x4c54
testl %r12d, %r12d
jle 0x4c58
movslq %r15d, %rdx
movl %r12d, %esi
subq %rdx, %rbx
xorl %ecx, %ecx
cmpq %rdx, %rcx
movq %rbx, %rdi
cmovlq %r14, %rdi
movb (%rdi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rsi
jne 0x4c35
jmp 0x4c5a
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x4c5e
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4c8f
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rbx, %rdx
jbe 0x4c7f
jmp 0x4c91
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %rbp
movq %rsi, %r13
movq %rdi, (%rsp)
testq %rcx, %rcx
je 0x4dcd
movq %r13, 0x10(%rsp)
leaq -0x1(%rcx), %rbx
movq %rbx, %rax
subq %rbp, %rax
cmpq $0x4, %rax
movq %rbp, 0x8(%rsp)
jl 0x4d75
shlq $0x8, %rcx
movq (%rsp), %rax
leaq (%rcx,%rax), %r12
addq $-0x400, %r12           # imm = 0xFC00
movq %rbp, %r14
negq %r14
xorl %r15d, %r15d
leaq 0x300(%r12), %r13
leaq 0x400(%r12), %rdi
movb %r15b, 0x400(%r12)
movq %r13, %rsi
callq 0x4f2c
leaq 0x200(%r12), %rbp
movb %r15b, 0x300(%r12)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4f2c
leaq 0x100(%r12), %r13
movb %r15b, 0x200(%r12)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4f2c
movb %r15b, 0x100(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x4f2c
addq $-0x400, %r12           # imm = 0xFC00
leaq (%r14,%rbx), %rax
addq $-0x4, %rax
addq $-0x4, %rbx
cmpq $0x3, %rax
jg 0x4cef
movq 0x8(%rsp), %rbp
cmpq %rbp, %rbx
setl %al
testq %rbx, %rbx
sets %cl
orb %al, %cl
movq 0x10(%rsp), %r13
jne 0x4dcd
xorl %r14d, %r14d
testq %rbp, %rbp
cmovgq %rbp, %r14
leaq 0x1(%rbx), %r15
shlq $0x8, %rbx
movq (%rsp), %rax
leaq (%rbx,%rax), %rdi
addq $0x100, %rdi            # imm = 0x100
leaq -0x100(%rdi), %r12
movb $0x0, (%rdi)
movq %r12, %rsi
callq 0x4f2c
decq %r15
movq %r12, %rdi
cmpq %r14, %r15
jg 0x4db0
shlq $0x8, %rbp
movq (%rsp), %rax
leaq (%rax,%rbp), %rdi
movb $0x0, (%rax,%rbp)
movq %r13, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f2c
nop
// File: /workspace/github_c_makefile_star2_O1/AndreIglesias[P]quick_ls/libft/libstring/depo/.././src//c/allocated/ft_countchr.c
// Function: ft_countchr
int	ft_countchr(const char *s, int c)
{
	int	i;
	int	q;

	i = 0;
	q = 0;
	while (s[i])
	{
		if (s[i] == (char)c)
			q++;
		i++;
	}
	return (q);
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x4e1a
movsbl %sil, %ecx
incq %rdi
xorl %eax, %eax
movsbl %dl, %edx
xorl %esi, %esi
cmpl %edx, %ecx
sete %sil
addl %esi, %eax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x4e03
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ecx, %ecx
movl %ecx, %edx
movl %ecx, %edi
leal 0x1(%rdx), %ecx
cmpb $0x0, (%rax,%rdi)
jne 0x4e25
movb (%rsi), %dil
testb %dil, %dil
je 0x4e5d
movl $0x1, %edx
leal (%rcx,%rdx), %r8d
addl $-0x2, %r8d
movb %dil, (%rax,%r8)
movl %edx, %edi
movb (%rsi,%rdi), %dil
incl %edx
testb %dil, %dil
jne 0x4e3f
addl %ecx, %edx
addl $-0x2, %edx
movl %edx, %ecx
movb $0x0, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4f07
movzbl %sil, %ecx
imull $0x1010101, %ecx, %ecx  # imm = 0x1010101
movq %rcx, %rdi
shlq $0x20, %rdi
movq -0x8(%rsp), %r8
testb $0x7, %r8b
je 0x4e9d
movb %sil, (%r8)
incq %r8
decq %rdx
jmp 0x4e8c
orq %rdi, %rcx
movq %r8, -0x8(%rsp)
cmpq $0x40, %rdx
jb 0x4ee4
movq %rdx, %rdi
shrq $0x6, %rdi
movq -0x8(%rsp), %r8
movq %rcx, (%r8)
movq %rcx, 0x8(%r8)
movq %rcx, 0x10(%r8)
movq %rcx, 0x18(%r8)
movq %rcx, 0x20(%r8)
movq %rcx, 0x28(%r8)
movq %rcx, 0x30(%r8)
movq %rcx, 0x38(%r8)
addq $0x40, %r8
decq %rdi
jne 0x4eb7
movq %r8, -0x8(%rsp)
movl %edx, %edi
shrl $0x3, %edi
andl $0x7, %edi
je 0x4f04
movq -0x8(%rsp), %r8
movq %rcx, (%r8)
addq $0x8, %r8
decq %rdi
jne 0x4ef3
movq %r8, -0x8(%rsp)
andl $0x7, %edx
testq %rdx, %rdx
je 0x4f1e
xorl %ecx, %ecx
movq -0x8(%rsp,%rcx,8), %rdi
movb %sil, (%rdi)
incq %rcx
cmpq %rcx, %rdx
jne 0x4f0e
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x7b6f(%rip), %rbx      # 0x9fd8
leaq 0x4b94(%rip), %rsi      # 0x7004
movl $0xf, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x4b66(%rip), %rsi      # 0x7014
movl $0x48, %edx
movq %rax, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x4b71(%rip), %rsi      # 0x705d
movl $0x4a, %edx
movq %rax, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movq %rax, %rbx
leaq 0x4b7e(%rip), %rsi      # 0x70a8
movl $0x71, %edx
movq %rax, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2120
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x0, (%r14)
movq %rsi, %r15
movl $0x9, %edx
movq %r14, %rcx
callq 0x68d7
movslq (%r14), %rcx
leaq (%rax,%rcx), %rdx
addq $-0x8, %rdx
leaq 0xa(%rax), %rsi
leaq -0x1f(%rbp), %rcx
movq %rbx, %rdi
callq 0x345c
movq (%rbx), %rsi
leaq -0x1e(%rbp), %rdx
movb $0x9, (%rdx)
movq %rbx, %rdi
callq 0x353a
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x18, %eax
leaq -0x1d(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x353a
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x10, %eax
leaq -0x1c(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x353a
movq (%rbx), %rsi
movq %r15, %rax
movb %ah, -0x1a(%rbp)
leaq -0x1a(%rbp), %rdx
movq %rbx, %rdi
callq 0x353a
movq (%rbx), %rsi
leaq -0x1b(%rbp), %rdx
movb %r15b, (%rdx)
movq %rbx, %rdi
callq 0x353a
movl 0x8(%rbx), %eax
subl (%rbx), %eax
testb $0xf, %al
je 0x31ce
leaq -0x19(%rbp), %r14
movb $0x0, -0x19(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36ba
movl 0x8(%rbx), %eax
subl (%rbx), %eax
testb $0xf, %al
jne 0x31b6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31e6
jmp 0x31e6
jmp 0x31e6
jmp 0x31e6
jmp 0x31e6
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31fd
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x38ce
xorl %eax, %eax
leaq -0x24(%rbp), %r15
movl %eax, (%r15)
leaq -0x20(%rbp), %rdx
movl %eax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x39fa
movq %rax, %r14
movslq (%r15), %rdx
addq %rax, %rdx
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x345c
testq %r14, %r14
je 0x3268
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/DKRCompression.cpp
// Function: DKRCompression::writeBinaryFile(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DKRCompression::writeBinaryFile(std::vector<uint8_t>& output, std::string filename)
{
    try 
    {
        std::ofstream wf(filename.c_str(), std::ios::out | std::ios::binary);
        for(int i = 0; i < output.size(); i++)
            wf.write((char *)&output[i], 1);
        wf.close();
    } 
    catch (int e)
    {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq (%rdx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x14, %edx
callq 0x21a0
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x32d2
xorl %r15d, %r15d
leaq -0x218(%rbp), %r14
addq %r15, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
incq %r15
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cmpq %r15, %rax
ja 0x32b0
leaq -0x218(%rbp), %rdi
callq 0x2220
movq 0x6ceb(%rip), %rax      # 0x9fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x2150
leaq -0x120(%rbp), %rdi
callq 0x2090
movb $0x1, %al
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x332e
movq %rdx, %r14
movq %rax, %rbx
jmp 0x3340
movq %rdx, %r14
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2240
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x3357
callq 0x20b0
callq 0x2280
xorl %eax, %eax
jmp 0x3316
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/DKRCompression.cpp
// Function: DKRCompression::readBinaryFile(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DKRCompression::readBinaryFile(std::vector<uint8_t>& input, std::string filename)
{
    try 
    {
        std::ifstream is;
        is.open(filename.c_str(), std::ios::binary);
        is.seekg(0, std::ios::end);
        size_t filesize = is.tellg();
        is.seekg(0, std::ios::beg);
        input.resize(filesize);
        is.read((char *)input.data(), filesize);
    } 
    catch (int e)
    {
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %r14
movq %rsi, %rbx
leaq -0x218(%rbp), %rdi
callq 0x21b0
movq (%r14), %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x2110
leaq -0x218(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2200
leaq -0x218(%rbp), %rdi
callq 0x2290
movq %rax, %r14
leaq -0x218(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x349e
movq (%rbx), %rsi
leaq -0x218(%rbp), %rdi
movq %r14, %rdx
callq 0x21d0
leaq -0x218(%rbp), %rdi
callq 0x2070
movb $0x1, %al
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3405
movq %rdx, %r14
movq %rax, %rbx
jmp 0x3417
jmp 0x3405
movq %rdx, %r14
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x342e
callq 0x20b0
callq 0x2280
xorl %eax, %eax
jmp 0x33ed
callq 0x22a0
nop
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::GECompression()
GECompression::GECompression()
{
//	inputBuffer = NULL;
	compressedBuffer = NULL;
//	inputBufferSize = 0;
	compressedBufferSize = 0;
	wordTable = NULL;
	unpackTable = NULL;
	game = GOLDENEYE;

	unpackTable = new tableEntry[0xFFFF];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rax, 0x50(%rdi)
movl %eax, 0x58(%rdi)
movq %rax, 0x78(%rdi)
movq %rax, 0x28(%rdi)
movl %eax, (%rdi)
movl $0x17ffe8, %edi         # imm = 0x17FFE8
callq 0x2030
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::~GECompression()
GECompression::~GECompression(void)
{
	if (unpackTable != NULL)
	{
		delete [] unpackTable;
		unpackTable = NULL;
	}
	if (wordTable != NULL)
	{
		delete [] wordTable;
		wordTable = NULL;
	}
	if (compressedBuffer != NULL)
	{
		delete [] compressedBuffer;
		compressedBuffer = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x3875
callq 0x21e0
movq $0x0, 0x28(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x388b
callq 0x21e0
movq $0x0, 0x78(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x38a1
callq 0x21e0
movq $0x0, 0x50(%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x38bf
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2190
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::SetCompressedBuffer(unsigned char*, int)
void GECompression::SetCompressedBuffer(unsigned char* Buffer, int bufferSize)
{
	if (compressedBuffer == NULL)
	{
		compressedBuffer = new unsigned char[bufferSize];
	}
	else
	{
		delete [] compressedBuffer;
		compressedBuffer = new unsigned char[bufferSize];
	}

	for (int x = 0; x < bufferSize; x++)
	{
		compressedBuffer[x] = Buffer[x];
	}

	compressedBufferSize = bufferSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x38ef
callq 0x21e0
movslq %ebx, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x50(%r14)
testl %r12d, %r12d
jle 0x391a
movl %ebx, %eax
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
movq 0x50(%r14), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x3907
movl %ebx, 0x58(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::GetNBits(int)
unsigned long GECompression::GetNBits(int nBits)
{
	while (bitsRemain < nBits)
	{
		if (bytesIndex >= maxByteSize)
			return 0; // bad decompression
		if (bytesIndex >= compressedBufferSize)
			return 0; // bad decompression
		bitsCache = ((bitsCache) | (compressedBuffer[bytesIndex] << bitsRemain));
		bitsRemain = bitsRemain + 8;
		bytesIndex++;
	}

	unsigned long result = (bitsCache & ((1 << nBits)-1));
	bitsCache = bitsCache >> nBits;
	bitsRemain = bitsRemain - nBits;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl 0x40(%rdi), %edx
cmpl %esi, %edx
jge 0x397b
movl 0x58(%rdi), %eax
movl $0x800000, %r8d         # imm = 0x800000
cmpl %r8d, %eax
cmovbl %eax, %r8d
movq 0x50(%rdi), %r9
movq 0x38(%rdi), %r10
movq 0x48(%rdi), %r11
xorl %eax, %eax
cmpq %r8, %r11
jae 0x3999
movzbl (%r9,%r11), %ebx
movl %edx, %ecx
shll %cl, %ebx
movslq %ebx, %rcx
orq %rcx, %r10
movq %r10, 0x38(%rdi)
addl $0x8, %edx
movl %edx, 0x40(%rdi)
incq %r11
movq %r11, 0x48(%rdi)
cmpl %esi, %edx
jl 0x3952
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %eax
movq 0x38(%rdi), %r8
notl %eax
andl %r8d, %eax
shrq %cl, %r8
movq %r8, 0x38(%rdi)
subl %esi, %edx
movl %edx, 0x40(%rdi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::GetNBitsAndPreserve(int)
unsigned long GECompression::GetNBitsAndPreserve(int nBits)
{
	while (bitsRemain < nBits)
	{
		if (bytesIndex >= maxByteSize)
			return 0; // bad decompression
		if (bytesIndex >= compressedBufferSize)
			return 0; // bad decompression
		bitsCache = ((bitsCache) | (compressedBuffer[bytesIndex] << bitsRemain));
		bitsRemain = bitsRemain + 8;
		bytesIndex++;
	}

	unsigned long result = (bitsCache & ((1 << nBits)-1));
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x40(%rdi), %ecx
cmpl %esi, %ecx
jge 0x39ea
movl 0x58(%rdi), %eax
movl $0x800000, %edx         # imm = 0x800000
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x50(%rdi), %r8
movq 0x38(%rdi), %r9
movq 0x48(%rdi), %r10
xorl %eax, %eax
cmpq %rdx, %r10
jae 0x39f8
movzbl (%r8,%r10), %r11d
shll %cl, %r11d
movslq %r11d, %r11
orq %r11, %r9
movq %r9, 0x38(%rdi)
addl $0x8, %ecx
movl %ecx, 0x40(%rdi)
incq %r10
movq %r10, 0x48(%rdi)
cmpl %esi, %ecx
jl 0x39c2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %eax
notl %eax
andl 0x38(%rdi), %eax
popq %rbp
retq