LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x2eca(%rip), %r14      # 0x6389
cmovneq %rdi, %r14
movl 0x14(%r13), %ebp
movl 0x18(%r13), %ebx
movq %r14, %rdi
callq 0x4d80
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 0x34f3
xorl %r15d, %r15d
jmp 0x350b
movl %ebp, %esi
subl %r12d, %esi
jle 0x34ee
movl 0x38(%r13), %edx
movl $0x20, %edi
callq 0x4b68
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 0x353e
movl 0x4(%rsp), %esi
subl %r12d, %esi
jle 0x353e
movl $0x20, %edi
movl %ebp, %edx
callq 0x4b68
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_O3/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, %r12d
leal -0x2(%r12), %eax
cmpl $0xe, %eax
ja 0x396b
movq %rdi, %rbx
testq %rdi, %rdi
je 0x396f
movl %edx, %ebp
leal 0x1(%r12), %r15d
movq %r15, %rdi
callq 0x10f0
movq %rax, %r14
xorl %eax, %eax
testl %ebp, %ebp
sete %al
shll $0x5, %eax
leaq 0x37(%rax), %rcx
movl %r12d, %r13d
andl $0x3e, %r15d
leaq -0x1(%r13), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
addq $0x38, %rax
movdqa 0x2b4f(%rip), %xmm1     # 0x63a0
xorl %edx, %edx
movdqa 0x2b55(%rip), %xmm2     # 0x63b0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x2b55(%rip), %xmm4     # 0x63c0
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x38b2
leal (%rcx,%rdx), %esi
leal 0x30(%rdx), %edi
cmpq $0xa, %rdx
movzbl %dil, %edi
cmovael %esi, %edi
movb %dil, (%r14,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x38da
movl %edx, %esi
orb $0x31, %sil
leal (%rax,%rdx), %edi
cmpq $0xa, %rdx
movzbl %sil, %esi
cmovael %edi, %esi
movb %sil, 0x1(%r14,%rdx)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %r15
jne 0x386b
movb $0x0, (%r14,%r13)
movl $0x2, %edi
movq %rbx, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r13
incq %rdi
cmpq %r13, %rcx
movq %rax, %rcx
jae 0x38f4
callq 0x10f0
testq %rax, %rax
je 0x396b
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 0x3923
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 0x452c
xorl %eax, %eax
jmp 0x3976
leaq 0x2ad7(%rip), %rax      # 0x644d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x39a7
cmpl %esi, %edi
setle %al
testl %edi, %edi
setg %r9b
testb %al, %r9b
jne 0x39ae
cmpl $0x0, 0x18(%r8)
jne 0x39b0
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_O3/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 0x3a48
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 0x3a53
cmpl $0x0, 0x4(%rcx)
je 0x3a53
cmpb $0x66, %r9b
sete %al
testl %edx, %edx
setne %r10b
testl %edi, %edi
setne %dil
andb %r10b, %dil
testb %al, %dil
jne 0x3a53
movl $0x1, %eax
cmpl %esi, 0x14(%rcx)
jle 0x3a53
retq
movb 0x30(%rcx), %r9b
movl 0xc(%rcx), %edx
movl 0x18(%rcx), %r8d
xorl %eax, %eax
cmpb $0x75, %r9b
jne 0x3a47
testl %r8d, %r8d
jns 0x3a47
testl %edx, %edx
jne 0x3a47
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2708(%rip), %xmm1     # 0x63e0
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
fstl -0x8(%rsp)
movsd -0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x3cf6
subsd %xmm1, %xmm0
jmp 0x3cea
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x3d06
xorpd 0x26da(%rip), %xmm0     # 0x63e0
movsd %xmm0, -0x10(%rsp)
fldl -0x10(%rsp)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3dd4
fstp %st(0)
leal 0x3(%rdi), %eax
andl $-0x4, %eax
decl %edi
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa 0x26af(%rip), %xmm1     # 0x63f0
movl $0x4, %ecx
movdqa 0x26b2(%rip), %xmm3     # 0x6400
movdqa %xmm1, %xmm2
pmuludq %xmm3, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pshufd $0xf5, %xmm2, %xmm4     # xmm4 = xmm2[1,1,3,3]
pmuludq %xmm3, %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movl %ecx, %esi
addl $-0x4, %ecx
addl %eax, %esi
addl $-0x4, %esi
cmpl $0x4, %esi
jne 0x3d4e
negl %ecx
movd %ecx, %xmm3
pshufd $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
por 0x2681(%rip), %xmm3     # 0x6410
movdqa 0x2619(%rip), %xmm4     # 0x63b0
pxor %xmm4, %xmm0
pxor %xmm4, %xmm3
pcmpgtd %xmm0, %xmm3
pand %xmm3, %xmm2
pandn %xmm1, %xmm3
por %xmm2, %xmm3
pshufd $0xee, %xmm3, %xmm0     # xmm0 = xmm3[2,3,2,3]
pshufd $0xff, %xmm3, %xmm1     # xmm1 = xmm3[3,3,3,3]
pshufd $0xf5, %xmm3, %xmm2     # xmm2 = xmm3[1,1,3,3]
pmuludq %xmm1, %xmm2
pmuludq %xmm3, %xmm0
pmuludq %xmm2, %xmm0
movd %xmm0, 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 0x3e96
xorl %eax, %eax
movsd 0x2614(%rip), %xmm0     # 0x6420
movapd 0x25cc(%rip), %xmm1     # 0x63e0
movsd 0x260c(%rip), %xmm2     # 0x6428
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 0x3e40
addsd %xmm2, %xmm3
jmp 0x3e34
fldz
fucompi %st(1), %st
fstp %st(0)
jbe 0x3e4c
xorpd %xmm1, %xmm3
movsd %xmm3, 0x20(%rsp)
fldl 0x20(%rsp)
faddl 0x25d4(%rip)            # 0x6430
incl %ebx
fld1
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
cmovael %eax, %ebx
fdivs 0x25d9(%rip)            # 0x6448
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 0x3e1e
fstp %st(0)
movl $0x30, %edi
movl %ebx, %esi
callq 0x4b68
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4470
movl %esi, %r15d
cmpl $0x0, 0x4(%r13)
je 0x4411
cmpl $0x0, 0x18(%r13)
jg 0x4411
leaq 0x207c(%rip), %rsi      # 0x644d
movq %rbx, %rdi
callq 0x4d90
movl 0x38(%r13), %r14d
testl %eax, %eax
je 0x4427
movb 0x30(%r13), %al
cmpb $0x78, %al
leaq 0x2061(%rip), %rcx      # 0x644f
leaq 0x205d(%rip), %rsi      # 0x6452
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 0x4433
movl 0x38(%r13), %edx
movl $0x20, %edi
movl %r15d, %esi
callq 0x4b68
movl %eax, %r14d
jmp 0x4470
leaq 0x201e(%rip), %rsi      # 0x644c
movl $0x2, %edx
movl %r14d, %edi
callq 0x1060
movq %rax, (%rsp)
leaq 0x2007(%rip), %rsi      # 0x644d
movq %rbx, %rdi
callq 0x4d90
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%r15,%rcx,2), %esi
addl $-0x2, %esi
movl $0x30, %edi
movl %r14d, %edx
callq 0x4b68
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 0x44b4
leaq 0x1fbf(%rip), %rsi      # 0x644d
movq %rbx, %rdi
callq 0x4d90
testl %eax, %eax
je 0x44b8
movl 0x38(%r13), %edi
leaq 0x1fa8(%rip), %rsi      # 0x644d
movl $0x1, %edx
callq 0x1060
addl %eax, %r14d
jmp 0x44b8
testl %ebp, %ebp
je 0x4519
leaq 0x1f8e(%rip), %rsi      # 0x644d
movq %rbx, %rdi
callq 0x4d90
testl %eax, %eax
setne %al
movl %r15d, %ecx
andb $-0x21, %cl
cmpb $0x58, %cl
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4519
testl %r12d, %r12d
jne 0x44f2
cmpl $0x0, 0x4(%r13)
je 0x44f2
cmpl $0x0, 0x18(%r13)
jle 0x4519
movl 0x38(%r13), %edi
cmpb $0x78, %r15b
leaq 0x1f4e(%rip), %rax      # 0x644f
leaq 0x1f4a(%rip), %rsi      # 0x6452
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_O3/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 0x458e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50ec
cmpl $0x2, %r15d
jl 0x4586
movl %r15d, %eax
addq $-0x2, %rax
xorl %ecx, %ecx
movb 0x1(%r14,%rax), %dl
movb (%r14,%rcx), %sil
movb %sil, 0x1(%r14,%rax)
movb %dl, (%r14,%rcx)
incq %rcx
leaq -0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jg 0x4565
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x30(%rsp), %r14
movb %dil, 0xf(%rsp)
cmpl $0x0, 0xc(%r14)
je 0x45e5
movl 0x38(%r14), %ebp
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x1060
movq %rax, %rbx
movl 0x14(%r14), %esi
cmpl $0x2, %esi
jl 0x461d
decl %esi
movl $0x20, %edi
movl %ebp, %edx
callq 0x4b68
addl %ebx, %eax
movl %eax, %ebx
jmp 0x461d
movl 0x14(%r14), %esi
cmpl $0x1, %esi
jle 0x4604
decl %esi
movl 0x38(%r14), %ebp
movl $0x20, %edi
movl %ebp, %edx
callq 0x4b68
movl %eax, %ebx
jmp 0x460a
movl 0x38(%r14), %ebp
xorl %ebx, %ebx
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x1060
addl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4668
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 0x4653
cmpq $0x1, %rdi
movl %ecx, %esi
sbbl $0x0, %esi
subl %edx, %esi
cmpl %edx, %ecx
cmovgl %esi, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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, %r9d
movl $0x0, %eax
testl %edi, %edi
js 0x46ee
movl %edi, %ecx
xorl %r9d, %r9d
xorl %edi, %edi
xorl %eax, %eax
movq %rsi, %r10
shrq %cl, %r10
testb $0xf, %r10b
je 0x46cd
testl %edi, %edi
je 0x46d1
testl %r9d, %r9d
jne 0x46df
movl %edi, (%rdx)
movl %edi, %r9d
jmp 0x46df
incl %edi
jmp 0x46df
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
xorl %edi, %edi
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
incl %eax
leaq -0x4(%rcx), %r10
cmpq $0x3, %rcx
movq %r10, %rcx
jg 0x46b1
testq %rsi, %rsi
cmovel %r8d, %eax
subl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x475a
testl %ecx, %ecx
je 0x472c
testl %edi, %edi
je 0x47b2
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 0x4b68
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 0x4b68
movl %eax, %r15d
movl $0x3, %eax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0x1cc5(%rip), %rsi      # 0x6455
movl %ebp, %edi
callq 0x1060
movq %rax, %r14
decl %ebx
movl $0x30, %edi
movl %ebx, %esi
movl %ebp, %edx
callq 0x4b68
addl %eax, %r14d
addl %r15d, %r14d
jmp 0x4806
movl 0x38(%r12), %ebp
movl $0x3, %eax
subl %r14d, %eax
movslq %eax, %rdx
leaq 0x1c8c(%rip), %rsi      # 0x6455
movl %ebp, %edi
callq 0x1060
movq %rax, %r15
leal -0x1(%rbx), %esi
movl $0x30, %edi
movl %ebp, %edx
callq 0x4b68
addl %eax, %r15d
movl 0x14(%r12), %eax
subl %ebx, %r14d
leal (%r14,%rax), %esi
addl $-0x3, %esi
movl $0x20, %edi
movl %ebp, %edx
callq 0x4b68
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_O3/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 0x4841
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 0x4b68
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4b9d
movl %edx, %ebx
movl %esi, %ebp
xorl %r14d, %r14d
leaq 0x7(%rsp), %r15
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x4ab0
addl %eax, %r14d
cmpl %ebp, %r14d
jl 0x4b84
jmp 0x4ba0
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_O3/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 0x4be0
incq %rax
addq %rdx, %rcx
jmp 0x4bca
cmpl $0x20, %esi
je 0x4bd8
sarq $0x20, %rcx
movzbl (%rdi,%rcx), %ecx
cmpl $0x2b, %ecx
je 0x4bf7
cmpl $0x2d, %ecx
jne 0x4bfa
incq %rax
cltq
movb (%rdi,%rax), %sil
leal -0x30(%rsi), %r8d
xorl %edx, %edx
cmpb $0x9, %r8b
ja 0x4c5b
addq %rdi, %rax
incq %rax
xorl %edx, %edx
addb $-0x30, %sil
movzbl %sil, %esi
cmpl $0xccccccc, %edx        # imm = 0xCCCCCCC
jne 0x4c46
cmpb $0x2d, %cl
sete %r8b
cmpl $0x8, %esi
sete %dil
andb %r8b, %dil
cmpl $0x7, %esi
setne %r9b
testb %dil, %dil
jne 0x4c66
orb %r9b, %r8b
je 0x4c66
leal (%rdx,%rdx,4), %edx
leal (%rsi,%rdx,2), %edx
movb (%rax), %sil
leal -0x30(%rsi), %edi
incq %rax
cmpb $0xa, %dil
jb 0x4c14
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
movzbl %dil, %eax
addl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c8d
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4cad
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4cb9
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x4cbd
cmpl $0x28, %ecx
ja 0x4cad
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4cb9
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x4cd0
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4cdc
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x4ce9
movsbq %cl, %rax
retq
cmpl $0x0, 0x20(%rax)
je 0x4cf4
movswq %cx, %rax
retq
movslq %ecx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d15
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4d35
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4d41
leaq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
movl (%rdi), %ecx
je 0x4d45
cmpl $0x28, %ecx
ja 0x4d35
movq 0x10(%rdi), %rax
addq %rcx, %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4d41
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
retq
cmpl $0x28, %ecx
ja 0x4d58
movq %rcx, %rdx
addq 0x10(%rdi), %rdx
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x4d64
movq 0x8(%rdi), %rdx
leaq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movl (%rdx), %ecx
cmpl $0x0, 0x1c(%rax)
je 0x4d71
movzbl %cl, %eax
jmp 0x4d7b
cmpl $0x0, 0x20(%rax)
movzwl %cx, %eax
cmovel %ecx, %eax
movl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4e21
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4d80
movq %rax, %r15
movq %rbx, %rdi
callq 0x4d80
movq %rax, %r12
addl %r15d, %r12d
movslq %r12d, %rdi
callq 0x4e3c
testq %rax, %rax
je 0x4e24
testl %r12d, %r12d
jle 0x4e28
movslq %r15d, %rdx
movl %r12d, %ecx
subq %rdx, %rbx
xorl %esi, %esi
cmpq %rdx, %rsi
movq %rbx, %rdi
cmovlq %r14, %rdi
movb (%rdi,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
cmpq %rsi, %rcx
jne 0x4e05
jmp 0x4e2a
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x4e2e
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_O3/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 0x4e5d
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rbx, %rdx
jbe 0x4e4f
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, %r13
movq %rsi, %r15
movq %rdi, %rbp
testq %rcx, %rcx
je 0x4f98
movq %r15, 0x10(%rsp)
leaq -0x1(%rcx), %rbx
movq %rbx, %rax
subq %r13, %rax
cmpq $0x4, %rax
movq %r13, 0x8(%rsp)
movq %rbp, (%rsp)
jl 0x4f40
shlq $0x8, %rcx
leaq (%rcx,%rbp), %r12
addq $-0x400, %r12           # imm = 0xFC00
movq %r13, %r14
negq %r14
xorl %r15d, %r15d
leaq 0x300(%r12), %r13
leaq 0x400(%r12), %rdi
movb %r15b, 0x400(%r12)
movq %r13, %rsi
callq 0x50ec
leaq 0x200(%r12), %rbp
movb %r15b, 0x300(%r12)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x50ec
leaq 0x100(%r12), %r13
movb %r15b, 0x200(%r12)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x50ec
movb %r15b, 0x100(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x50ec
addq $-0x400, %r12           # imm = 0xFC00
leaq (%r14,%rbx), %rax
addq $-0x4, %rax
addq $-0x4, %rbx
cmpq $0x3, %rax
jg 0x4eba
movq 0x8(%rsp), %r13
cmpq %r13, %rbx
setl %al
testq %rbx, %rbx
sets %cl
orb %al, %cl
movq 0x10(%rsp), %r15
movq (%rsp), %rbp
jne 0x4f98
movq %rbx, %rax
shlq $0x8, %rax
leaq (%rax,%rbp), %r12
addq $0x100, %r12            # imm = 0x100
movq %rbx, %r14
movq %r12, %rdi
addq $-0x100, %r12
movb $0x0, (%rdi)
movq %r12, %rsi
callq 0x50ec
addq $-0x1, %rbx
setb %al
cmpq %r13, %r14
jle 0x4f98
testb %al, %al
jne 0x4f70
shlq $0x8, %r13
movq %rbp, %rdi
addq %r13, %rdi
movb $0x0, (%rbp,%r13)
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x50ec
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4fe6
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 0x4fcf
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
incl %ecx
cmpb $0x0, (%rax,%rdx)
jne 0x4ff1
movb (%rsi), %dil
testb %dil, %dil
je 0x5026
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 0x5008
addl %ecx, %edx
addl $-0x2, %edx
movb $0x0, (%rax,%rdx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x50c8
movzbl %sil, %ecx
imull $0x1010101, %ecx, %ecx  # imm = 0x1010101
movq %rcx, %r8
shlq $0x20, %r8
movq %rax, %rdi
testb $0x7, %al
je 0x5065
movb %sil, (%rdi)
incq %rdi
decq %rdx
testb $0x7, %dil
jne 0x5056
orq %r8, %rcx
movq %rdi, -0x8(%rsp)
cmpq $0x40, %rdx
jb 0x50a7
movq %rdx, %r8
shrq $0x6, %r8
movq %rcx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rcx, 0x38(%rdi)
addq $0x40, %rdi
decq %r8
jne 0x507a
movq %rdi, -0x8(%rsp)
movl %edx, %r8d
shrl $0x3, %r8d
andl $0x7, %r8d
je 0x50c5
movq %rcx, (%rdi)
addq $0x8, %rdi
decq %r8
jne 0x50b4
movq %rdi, -0x8(%rsp)
andl $0x7, %edx
testq %rdx, %rdx
je 0x50df
xorl %ecx, %ecx
movq -0x8(%rsp,%rcx,8), %rdi
movb %sil, (%rdi)
incq %rcx
cmpq %rcx, %rdx
jne 0x50cf
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x677f
movslq (%r14), %rcx
leaq (%rax,%rcx), %rdx
addq $-0x8, %rdx
leaq 0xa(%rax), %rsi
leaq -0x1f(%rbp), %rcx
movq %rbx, %rdi
callq 0x33f8
movq (%rbx), %rsi
leaq -0x1e(%rbp), %rdx
movb $0x9, (%rdx)
movq %rbx, %rdi
callq 0x34d2
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x18, %eax
leaq -0x1d(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x34d2
movq (%rbx), %rsi
movq %r15, %rax
shrl $0x10, %eax
leaq -0x1c(%rbp), %rdx
movb %al, (%rdx)
movq %rbx, %rdi
callq 0x34d2
movq (%rbx), %rsi
movq %r15, %rax
movb %ah, -0x1a(%rbp)
leaq -0x1a(%rbp), %rdx
movq %rbx, %rdi
callq 0x34d2
movq (%rbx), %rsi
leaq -0x1b(%rbp), %rdx
movb %r15b, (%rdx)
movq %rbx, %rdi
callq 0x34d2
movl 0x8(%rbx), %eax
subl (%rbx), %eax
testb $0xf, %al
je 0x316a
leaq -0x19(%rbp), %r14
movb $0x0, -0x19(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3652
movl 0x8(%rbx), %eax
subl (%rbx), %eax
testb $0xf, %al
jne 0x3152
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3182
jmp 0x3182
jmp 0x3182
jmp 0x3182
jmp 0x3182
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3199
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3862
xorl %eax, %eax
leaq -0x24(%rbp), %r15
movl %eax, (%r15)
leaq -0x20(%rbp), %rdx
movl %eax, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3998
movq %rax, %r14
movslq (%r15), %rdx
addq %rax, %rdx
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33f8
testq %r14, %r14
je 0x3204
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_O3/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 0x326e
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 0x324c
leaq -0x218(%rbp), %rdi
callq 0x2220
movq 0x6d4f(%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 0x32ca
movq %rdx, %r14
movq %rax, %rbx
jmp 0x32dc
movq %rdx, %r14
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2240
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x32f3
callq 0x20b0
callq 0x2280
xorl %eax, %eax
jmp 0x32b2
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O3/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 0x343a
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 0x33a1
movq %rdx, %r14
movq %rax, %rbx
jmp 0x33b3
jmp 0x33a1
movq %rdx, %r14
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x33ca
callq 0x20b0
callq 0x2280
xorl %eax, %eax
jmp 0x3389
callq 0x22a0
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3809
callq 0x21e0
movq $0x0, 0x28(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x381f
callq 0x21e0
movq $0x0, 0x78(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3835
callq 0x21e0
movq $0x0, 0x50(%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3853
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_O3/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 0x3883
callq 0x21e0
movslq %ebx, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, 0x50(%r14)
testl %r12d, %r12d
jle 0x38ae
movl %ebx, %eax
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
movq 0x50(%r14), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x389b
movl %ebx, 0x58(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3911
movl 0x58(%rdi), %eax
movl $0x800000, %r9d         # imm = 0x800000
cmpl %r9d, %eax
cmovbl %eax, %r9d
movq 0x50(%rdi), %r10
movq 0x38(%rdi), %r8
movq 0x48(%rdi), %r11
xorl %eax, %eax
cmpq %r9, %r11
jae 0x392f
movzbl (%r10,%r11), %ebx
movl %edx, %ecx
shll %cl, %ebx
movslq %ebx, %rcx
orq %rcx, %r8
movq %r8, 0x38(%rdi)
addl $0x8, %edx
movl %edx, 0x40(%rdi)
incq %r11
movq %r11, 0x48(%rdi)
cmpl %esi, %edx
jl 0x38e6
jmp 0x3915
movq 0x38(%rdi), %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %eax
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_O3/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 0x3980
movl 0x58(%rdi), %eax
movl $0x800000, %edx         # imm = 0x800000
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x50(%rdi), %r8
movq 0x38(%rdi), %rax
movq 0x48(%rdi), %r9
cmpq %rdx, %r9
jae 0x3993
movzbl (%r8,%r9), %r10d
shll %cl, %r10d
movslq %r10d, %r10
orq %r10, %rax
movq %rax, 0x38(%rdi)
addl $0x8, %ecx
movl %ecx, 0x40(%rdi)
incq %r9
movq %r9, 0x48(%rdi)
cmpl %esi, %ecx
jl 0x3956
jmp 0x3984
movq 0x38(%rdi), %rax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %edx
notl %edx
andl %edx, %eax
jmp 0x3995
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DavidSM64[P]DKR-Decompressor/GECompression.cpp
// Function: GECompression::UncompressType0(unsigned char*, int&)
bool GECompression::UncompressType0(unsigned char* returnBuffer, int& fileSize)
{
	// discard bits

	unsigned long discardBits = bitsRemain & 0x7;
	GetNBits(discardBits); // discard begins

	unsigned short copyLen = GetNBits(16);
	GetNBits(16); // discarded

	for (int x = 0; x < copyLen; x++)
	{
		if (fileSize >= maxByteSize)
		{
			fileSize = 0;
			return false;
		}
		returnBuffer[fileSize] = GetNBits(8);
		fileSize++;

		if (iterationCounter > 268435455)
		{
			fileSize = 0;
			return false;
		}
		iterationCounter++;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movl 0x40(%rdi), %esi
andl $0x7, %esi
callq 0x38bc
movq %r15, %rdi
movl $0x10, %esi
callq 0x38bc
movq %rax, %r13
movq %r15, %rdi
movl $0x10, %esi
callq 0x38bc
movb $0x1, %al
andl $0xffff, %r13d          # imm = 0xFFFF
je 0x3d17
cmpl $0x7fffff, (%rbx)       # imm = 0x7FFFFF
jle 0x3cba
xorl %r12d, %r12d
jmp 0x3d0e
movl $0x1, %r14d
xorl %r12d, %r12d
movq %r15, %rdi
movl $0x8, %esi
callq 0x38bc
movslq (%rbx), %rcx
movq -0x30(%rbp), %rdx
movb %al, (%rdx,%rcx)
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
movq 0x80(%r15), %rcx
cmpq $0xfffffff, %rcx        # imm = 0xFFFFFFF
ja 0x3d0e
incq %rcx
movq %rcx, 0x80(%r15)
cmpl %r14d, %r13d
je 0x3d28
setbe %r12b
incl %r14d
cmpl $0x7ffffe, %eax         # imm = 0x7FFFFE
jle 0x3cc3
movl $0x0, (%rbx)
movl %r12d, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x3d17
// File: /workspace/github_c_makefile_star2_O3/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: put_int(int)
void put_int(int i) {
    outbuf[outcnt++] = i & 0xFF;
    outbuf[outcnt++] = (i >> 8) & 0xFF;
    outbuf[outcnt++] = (i >> 16) & 0xFF;
    outbuf[outcnt++] = (i >> 24) & 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
movslq 0x1008f88(%rip), %rcx   # 0x100db10
leaq 0x8f81(%rip), %rdx      # 0xdb10
movb %al, (%rcx,%rdx)
movb %ah, 0x1(%rcx,%rdx)
movl %edi, %esi
shrl $0x10, %esi
movb %sil, 0x2(%rcx,%rdx)
shrl $0x18, %eax
leal 0x4(%rcx), %esi
movl %esi, 0x1008f64(%rip)   # 0x100db10
movb %al, 0x3(%rcx,%rdx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: updcrc(char*, unsigned int)
u32 updcrc(char* bytes, u32 numBytes) {
    u32 c;

    static u32 crc = 0xffffffff;

    if (bytes == NULL) {
        c = 0xffffffff;
    } else {
        c = crc;
        if (numBytes) do {
            c = crc_32_tab[((int)c ^ (*bytes++)) & 0xff] ^ (c >> 8);
        } while (--numBytes);
    }
    crc = c;
    return c ^ 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x4beb
movl 0x5fc3(%rip), %eax      # 0xab84
testl %esi, %esi
je 0x4bf0
movl %esi, %ecx
xorl %edx, %edx
leaq 0x5bb0(%rip), %rsi      # 0xa780
movb (%rdi,%rdx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rsi,%r8,4), %eax
incq %rdx
cmpl %edx, %ecx
jne 0x4bd0
jmp 0x4bf0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x5f8e(%rip)      # 0xab84
notl %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: read_buf(char*, unsigned int)
int read_buf(char* buf, u32 size){
    u32 len;
    
    if(incnt + size >= inbufSize) {
        len = inbufSize - incnt;
    } else {
        len = size;
    }
    
    memcpy(buf, inbuf + incnt, len);

    crc = updcrc((char*)buf, len);
    incnt += (u32)len;
    return (int)len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movslq 0x1008f19(%rip), %rax   # 0x100db24
movl 0x1008f0f(%rip), %ecx   # 0x100db20
movl %ecx, %ebx
subl %eax, %ebx
leal (%rax,%rsi), %edx
cmpl %ecx, %edx
cmovbl %esi, %ebx
addq 0x1008ef4(%rip), %rax   # 0x100db18
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2140
testq %r14, %r14
je 0x4c63
movl 0x5f4a(%rip), %eax      # 0xab84
testl %ebx, %ebx
je 0x4c68
movl %ebx, %ecx
xorl %edx, %edx
leaq 0x5b37(%rip), %rsi      # 0xa780
movb (%r14,%rdx), %dil
xorb %al, %dil
movzbl %dil, %edi
shrl $0x8, %eax
xorl (%rsi,%rdi,4), %eax
incq %rdx
cmpl %edx, %ecx
jne 0x4c49
jmp 0x4c68
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x5f16(%rip)      # 0xab84
notl %eax
movl %eax, 0x1008eba(%rip)   # 0x100db30
addl %ebx, 0x1008ea8(%rip)   # 0x100db24
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq