LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_x.c
// Function: print_x
t_tags			*print_x(t_tags *ids)
{
	uintmax_t	nbr;
	size_t		len;
	char		*str;

	nbr = cast_unsigned_number(ids, 0);
	str = ids->current_type == 'x' ? uimaxtoa_base(nbr, 16)
	: uimaxtoa_base_capital(nbr, 16);
	len = ft_strlen(str);
	if (ids->period == 1 && ids->maxwth == 0 && nbr == 0)
	{
		period_zero(ids);
		return (ids);
	}
	prefix_print(ids, nbr, len);
	ft_putstr(str);
	ids->printed_chars += len;
	if (nbr == 0 && ids->current_flag[0] == '#' && ids->current_flag[4] == '-')
		minwth_print(ids, len - 2);
	else if (ids->minwth > 0 && ids->current_flag[4] == '-')
		minwth_print(ids, len);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5dcc
movq %rax, %r15
cmpb $0x78, 0x5e(%rbx)
jne 0x554d
movl $0x10, %esi
movq %r15, %rdi
callq 0x5a17
jmp 0x555a
movl $0x10, %esi
movq %r15, %rdi
callq 0x597a
movq %rax, %r14
movq %rax, %rdi
callq 0x481c
movq %rax, %r12
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5588
movq 0x20(%rbx), %rcx
orq %r15, %rcx
jne 0x5588
movq %rbx, %rdi
callq 0x62dc
jmp 0x5658
testq %r15, %r15
jne 0x559d
cmpb $0x23, 0x58(%rbx)
jne 0x559d
cmpb $0x2d, 0x5c(%rbx)
jne 0x5664
cmpq %r12, 0x10(%rbx)
jbe 0x55c0
cmpb $0x2d, 0x5c(%rbx)
je 0x55c0
cmpq $0x1, %rax
je 0x55b5
cmpb $0x30, 0x59(%rbx)
je 0x55c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6764
testq %r15, %r15
je 0x55f5
cmpb $0x23, 0x58(%rbx)
jne 0x55f5
cmpb $0x78, 0x5e(%rbx)
leaq 0x24c4(%rip), %rax      # 0x7a9a
leaq 0x24c7(%rip), %rsi      # 0x7aa4
cmoveq %rax, %rsi
movl $0x2, %edx
movl $0x1, %edi
callq 0x1040
addq $0x2, 0x30(%rbx)
cmpb $0x30, 0x59(%rbx)
jne 0x5608
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6691
jmp 0x5615
cmpq $0x1, 0x18(%rbx)
jne 0x5615
cmpq %r12, 0x20(%rbx)
ja 0x55fb
movq %r14, %rdi
callq 0x4668
addq %r12, 0x30(%rbx)
testq %r15, %r15
jne 0x5638
cmpb $0x23, 0x58(%rbx)
jne 0x5638
cmpb $0x2d, 0x5c(%rbx)
jne 0x5638
addq $-0x2, %r12
jmp 0x5645
cmpq $0x0, 0x10(%rbx)
je 0x5650
cmpb $0x2d, 0x5c(%rbx)
jne 0x5650
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6764
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2(%r12), %rsi
movq %rbx, %rdi
callq 0x6764
jmp 0x55f5
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_arg_type
t_tags	*scan_arg_type(t_tags *ids)
{
	int	i;

	i = 0;
	while (ids->arg_type[i])
	{
		if (ids->format[ids->i] == ids->arg_type[i])
		{
			ids->current_type = ids->format[ids->i];
			ids->i++;
			return (ids);
		}
		i++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x48(%rdi), %rcx
movb (%rcx), %sil
testb %sil, %sil
je 0x56b2
movq (%rax), %rdi
movq 0x28(%rax), %rdx
movb (%rdi,%rdx), %dil
incq %rcx
cmpb %sil, %dil
je 0x56a7
movb (%rcx), %sil
incq %rcx
testb %sil, %sil
jne 0x5695
jmp 0x56b2
movb %dil, 0x5e(%rax)
incq %rdx
movq %rdx, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_modifier
t_tags	*scan_modifier(t_tags *ids)
{
	int	i;
	int	c;

	i = 0;
	c = 0;
	if (ids->format[ids->i] == 'h' || ids->format[ids->i] == 'l' ||
		ids->format[ids->i] == 'L')
	{
		while (ids->modifiers[i] != '\0')
		{
			while (ids->modifiers[i] == ids->format[ids->i])
			{
				ids->current_modifier[c] = ids->format[ids->i];
				if (c < 1)
					c++;
				ids->i++;
			}
			i++;
		}
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x28(%rdi), %rdx
movzbl (%rcx,%rdx), %esi
addl $-0x4c, %esi
cmpl $0x20, %esi
ja 0x572b
movabsq $0x110000001, %rdi      # imm = 0x110000001
btq %rsi, %rdi
jae 0x572b
movq 0x50(%rax), %rsi
movb (%rsi), %r8b
testb %r8b, %r8b
je 0x572b
xorl %edi, %edi
xorl %r9d, %r9d
cmpb (%rcx,%rdx), %r8b
jne 0x571e
movl %r9d, %r9d
movq %rdx, %r10
movb %r8b, 0x5f(%rax,%r9)
incq %rdx
movq %rdx, 0x28(%rax)
movb (%rsi,%rdi), %r8b
movl $0x1, %r9d
cmpb 0x1(%rcx,%r10), %r8b
je 0x56f8
movl $0x1, %r9d
movb 0x1(%rsi,%rdi), %r8b
incq %rdi
testb %r8b, %r8b
jne 0x56ef
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_period_maxwth
t_tags	*scan_period_maxwth(t_tags *ids)
{
	if (ids->format[ids->i] == '.')
	{
		ids->period++;
		ids->i++;
		while (ids->format[ids->i] >= '0' && ids->format[ids->i] <= '9')
		{
			ids->maxwth += ids->format[ids->i] - 48;
			if (ids->format[ids->i + 1] >= '0' &&
				ids->format[ids->i + 1] <= '9')
				ids->maxwth = ids->maxwth * 10;
			ids->i++;
		}
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x28(%rdi), %rdx
cmpb $0x2e, (%rcx,%rdx)
jne 0x57a3
incq 0x18(%rax)
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rax)
movb 0x1(%rcx,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x57a3
movq 0x20(%rax), %r8
addq $0x2, %rdx
addb $-0x30, %sil
movzbl %sil, %edi
addq %r8, %rdi
movq %rdi, 0x20(%rax)
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x578b
addq %rdi, %rdi
leaq (%rdi,%rdi,4), %rdi
movq %rdi, 0x20(%rax)
movq %rdx, 0x28(%rax)
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %r9d
incq %rdx
movq %rdi, %r8
cmpb $0xa, %r9b
jb 0x5763
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_minwth
t_tags	*scan_minwth(t_tags *ids)
{
	while (ids->format[ids->i] >= '0' && ids->format[ids->i] <= '9')
	{
		ids->minwth += ids->format[ids->i] - 48;
		if (ids->format[ids->i + 1] >= '0' && ids->format[ids->i + 1] <= '9')
			ids->minwth = ids->minwth * 10;
		ids->i++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x28(%rdi), %rdx
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x5807
movq 0x10(%rax), %r8
incq %rdx
addb $-0x30, %sil
movzbl %sil, %edi
addq %r8, %rdi
movq %rdi, 0x10(%rax)
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x57ef
addq %rdi, %rdi
leaq (%rdi,%rdi,4), %rdi
movq %rdi, 0x10(%rax)
movq %rdx, 0x28(%rax)
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %r9d
incq %rdx
movq %rdi, %r8
cmpb $0xa, %r9b
jb 0x57c7
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_flags
t_tags	*scan_flags(t_tags *ids)
{
	int		i;

	i = 0;
	while (ids->flag[i] != '\0')
	{
		while (ids->flag[i] == ids->format[ids->i])
		{
			while (ids->format[ids->i] == '#' && ids->i++)
				ids->current_flag[0] = '#';
			while (ids->format[ids->i] == '0' && ids->i++)
				ids->current_flag[1] = '0';
			while (ids->format[ids->i] == ' ' && ids->i++)
				ids->current_flag[2] = ' ';
			while (ids->format[ids->i] == '+' && ids->i++)
				ids->current_flag[3] = '+';
			while (ids->format[ids->i] == '-' && ids->i++)
				ids->current_flag[4] = '-';
			i = 0;
		}
		i++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movb (%rcx), %dil
testb %dil, %dil
je 0x594d
movq (%rax), %rdx
movq 0x28(%rax), %rsi
xorl %r8d, %r8d
cmpb (%rdx,%rsi), %dil
jne 0x5939
movq %rsi, %r8
cmpb $0x23, %dil
jne 0x585d
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
jne 0x5928
movb 0x1(%rdx), %dil
movl $0x1, %esi
movl $0x1, %r8d
cmpb $0x30, %dil
jne 0x588d
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
je 0x587e
movb $0x30, 0x59(%rax)
movb 0x1(%rdx,%r8), %dil
movq %rsi, %r8
jmp 0x585d
movb 0x1(%rdx), %dil
movl $0x1, %esi
movl $0x1, %r8d
cmpb $0x20, %dil
jne 0x58bd
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
je 0x58ae
movb $0x20, 0x5a(%rax)
movb 0x1(%rdx,%r8), %dil
movq %rsi, %r8
jmp 0x588d
movb 0x1(%rdx), %dil
movl $0x1, %esi
movl $0x1, %r8d
cmpb $0x2b, %dil
jne 0x58ed
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
je 0x58de
movb $0x2b, 0x5b(%rax)
movb 0x1(%rdx,%r8), %dil
movq %rsi, %r8
jmp 0x58bd
movb 0x1(%rdx), %dil
movl $0x1, %esi
movl $0x1, %r8d
cmpb $0x2d, %dil
jne 0x591d
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
je 0x590e
movb $0x2d, 0x5c(%rax)
movb 0x1(%rdx,%r8), %dil
movq %rsi, %r8
jmp 0x58ed
movb 0x1(%rdx), %dil
movl $0x1, %esi
movl $0x1, %r8d
cmpb %dil, (%rcx)
je 0x5837
jmp 0x5936
movb $0x23, 0x58(%rax)
movb 0x1(%rdx,%r8), %dil
jmp 0x5834
xorl %r8d, %r8d
movslq %r8d, %r8
movb 0x1(%rcx,%r8), %dil
incq %r8
testb %dil, %dil
jne 0x582a
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/imaxtoa.c
// Function: unsigned_base_nbrcount
intmax_t		unsigned_base_nbrcount(uintmax_t n, size_t base)
{
	intmax_t	i;

	i = 0;
	if (n == 0)
		return (1);
	while (n > 0)
	{
		i++;
		n = n / base;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x5970
xorl %ecx, %ecx
incq %rcx
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
cmpq %rsi, %rdi
movq %rax, %rdi
jae 0x595b
jmp 0x5975
movl $0x1, %ecx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/imaxtoa.c
// Function: uimaxtoa_base_capital
char			*uimaxtoa_base_capital(uintmax_t nbr, size_t base)
{
	char		*base_str;
	char		*str;
	intmax_t	count;

	base_str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	count = unsigned_base_nbrcount(nbr, base);
	if (!(str = ft_strnew(count)))
		return (NULL);
	count--;
	if (nbr == 0)
		str[0] = '0';
	while (nbr > 0)
	{
		str[count] = base_str[nbr % base];
		nbr /= base;
		count--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x59f2
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x1, %r15
movq %rdi, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
incq %r15
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x599a
testq %r14, %r14
sete %r12b
leaq 0x1(%r15), %rdi
callq 0x4840
movq %rax, %rcx
testq %rax, %rax
sete %al
orb %r12b, %al
jne 0x5a0b
movq %rcx, %rsi
addq %r15, %rsi
leaq 0x20cf(%rip), %rdi      # 0x7aa7
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x59d8
jmp 0x5a0b
movl $0x1, %edi
callq 0x4840
testq %rax, %rax
je 0x5a09
movq %rax, %rcx
movb $0x30, (%rax)
jmp 0x5a0b
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/imaxtoa.c
// Function: uimaxtoa_base
char			*uimaxtoa_base(uintmax_t nbr, size_t base)
{
	char		*base_str;
	char		*str;
	intmax_t	count;

	base_str = "0123456789abcdefghijklmnopqrstuvwxyz";
	count = unsigned_base_nbrcount(nbr, base);
	if (!(str = ft_strnew(count)))
		return (NULL);
	count--;
	if (nbr == 0)
		str[0] = '0';
	while (nbr > 0)
	{
		str[count] = base_str[nbr % base];
		nbr /= base;
		count--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x5a8f
movq %rsi, %rbx
movq %rdi, %r14
movq $-0x1, %r15
movq %rdi, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
incq %r15
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x5a37
testq %r14, %r14
sete %r12b
leaq 0x1(%r15), %rdi
callq 0x4840
movq %rax, %rcx
testq %rax, %rax
sete %al
orb %r12b, %al
jne 0x5aa8
movq %rcx, %rsi
addq %r15, %rsi
leaq 0x2057(%rip), %rdi      # 0x7acc
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x5a75
jmp 0x5aa8
movl $0x1, %edi
callq 0x4840
testq %rax, %rax
je 0x5aa6
movq %rax, %rcx
movb $0x30, (%rax)
jmp 0x5aa8
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/imaxtoa.c
// Function: base_nbrcount
intmax_t		base_nbrcount(intmax_t n, size_t base)
{
	intmax_t	i;

	i = 0;
	if (n == 0)
		return (1);
	if (n < 0)
	{
		n = n * -1;
		i++;
	}
	while (n > 0)
	{
		i++;
		n = n / base;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x5ae0
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
shrq $0x3f, %rdi
incq %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
cmpq %rsi, %rcx
movq %rax, %rcx
jae 0x5acb
jmp 0x5ae5
movl $0x1, %edi
movq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/imaxtoa.c
// Function: imaxtoa_base
char			*imaxtoa_base(intmax_t nbr, size_t base)
{
	char		*base_str;
	char		*str;
	intmax_t	count;

	if (nbr == LONG_MIN || nbr == LLONG_MIN)
		return (ft_strdup("9223372036854775808"));
	base_str = "0123456789abcdefghijklmnopqrstuvwxyz";
	count = base_nbrcount(nbr, base);
	if (!(str = ft_strnew(count)))
		return (NULL);
	count--;
	if (nbr == 0)
		str[0] = '0';
	while (nbr > 0)
	{
		str[count] = base_str[nbr % base];
		nbr /= base;
		count--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5b1a
movq %rdi, %r14
movq %rdi, %rcx
negq %rcx
jno 0x5b31
leaq 0x1fe6(%rip), %rdi      # 0x7af1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x471c
movl $0x1, %edi
callq 0x4840
testq %rax, %rax
je 0x5b8f
movq %rax, %rcx
movb $0x30, (%rax)
jmp 0x5b91
movq %rsi, %rbx
cmovsq %r14, %rcx
movq %r14, %r15
shrq $0x3f, %r15
incq %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x5b3f
movq %r15, %rdi
callq 0x4840
testq %rax, %rax
je 0x5b8f
movq %rax, %rcx
testq %r14, %r14
jle 0x5b91
leaq (%rcx,%r15), %rsi
decq %rsi
leaq 0x1f57(%rip), %rdi      # 0x7acc
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x5b75
jmp 0x5b91
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/number_cast.c
// Function: cast_double
long double	cast_double(t_tags *ids, long double nbr)
{
	if (ft_strcmp(ids->current_modifier, "\0") == 0)
		nbr = (double)va_arg(ids->arguments, double);
	if (ft_strcmp(ids->current_modifier, "l") == 0)
		nbr = (double)va_arg(ids->arguments, double);
	if (ft_strcmp(ids->current_modifier, "L") == 0)
		nbr = (long double)va_arg(ids->arguments, long double);
	if (nbr < 0)
		ids->negative = -1;
	return ((long double)nbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
fldt 0x10(%rbp)
fstpt -0x1c(%rbp)
leaq 0x5f(%rdi), %r14
leaq 0x1f46(%rip), %rsi      # 0x7b05
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5bf7
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x5be6
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x5bf2
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x1f0d(%rip), %rsi      # 0x7b0b
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5c36
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x5c25
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x5c31
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x1e14(%rip), %rsi      # 0x7a51
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
fldt -0x1c(%rbp)
jne 0x5c64
fstp %st(0)
movq 0x70(%rbx), %rax
addq $0xf, %rax
andq $-0x10, %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldt (%rax)
fldz
fucompi %st(1), %st
jbe 0x5c71
movl $0xffffffff, 0x40(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/number_cast.c
// Function: cast_number
intmax_t	cast_number(t_tags *ids, intmax_t nbr)
{
	if (ft_strcmp(ids->current_modifier, "\0") == 0)
		nbr = (int)va_arg(ids->arguments, int);
	if (ft_strcmp(ids->current_modifier, "h") == 0)
		nbr = (short)va_arg(ids->arguments, int);
	if (ft_strcmp(ids->current_modifier, "l") == 0)
		nbr = (long)va_arg(ids->arguments, long int);
	if (ft_strcmp(ids->current_modifier, "hh") == 0)
		nbr = (signed char)va_arg(ids->arguments, int);
	if (ft_strcmp(ids->current_modifier, "ll") == 0)
		nbr = (long long)va_arg(ids->arguments, long long int);
	if (nbr < 0)
		ids->negative = -1;
	return ((intmax_t)nbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5f(%rdi), %r14
leaq 0x1e70(%rip), %rsi      # 0x7b05
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5cc8
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5cb9
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5cc5
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movslq (%rax), %r15
leaq 0x1e39(%rip), %rsi      # 0x7b08
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5d03
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5cf3
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5cff
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movswq (%rax), %r15
leaq 0x1e01(%rip), %rsi      # 0x7b0b
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5d3d
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5d2e
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5d3a
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
leaq 0x1dc3(%rip), %rsi      # 0x7b07
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5d78
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5d68
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5d74
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movsbq (%rax), %r15
leaq 0x1d8b(%rip), %rsi      # 0x7b0a
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5db2
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5da3
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5daf
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
testq %r15, %r15
jns 0x5dbe
movl $0xffffffff, 0x40(%rbx) # imm = 0xFFFFFFFF
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/number_cast.c
// Function: cast_unsigned_number
uintmax_t	cast_unsigned_number(t_tags *ids, uintmax_t nbr)
{
	if (ft_strcmp(ids->current_modifier, "\0") == 0)
		nbr = (unsigned int)va_arg(ids->arguments, unsigned int);
	if (ft_strcmp(ids->current_modifier, "h") == 0)
		nbr = (unsigned short)va_arg(ids->arguments, unsigned int);
	if (ft_strcmp(ids->current_modifier, "l") == 0)
		nbr = (unsigned long)va_arg(ids->arguments, unsigned long int);
	if (ft_strcmp(ids->current_modifier, "hh") == 0)
		nbr = (unsigned char)va_arg(ids->arguments, unsigned int);
	if (ft_strcmp(ids->current_modifier, "ll") == 0)
		nbr = (unsigned long long)
		va_arg(ids->arguments, unsigned long long int);
	return ((uintmax_t)nbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5f(%rdi), %r14
leaq 0x1d1e(%rip), %rsi      # 0x7b05
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5e1a
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5e0b
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5e17
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movl (%rax), %r15d
leaq 0x1ce7(%rip), %rsi      # 0x7b08
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5e55
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5e45
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5e51
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movzwl (%rax), %r15d
leaq 0x1caf(%rip), %rsi      # 0x7b0b
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5e8f
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5e80
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5e8c
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
leaq 0x1c71(%rip), %rsi      # 0x7b07
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5eca
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5eba
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5ec6
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movzbl (%rax), %r15d
leaq 0x1c39(%rip), %rsi      # 0x7b0a
movq %r14, %rdi
callq 0x46c8
testl %eax, %eax
jne 0x5f04
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5ef5
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5f01
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_d.c
// Function: print_d
t_tags			*print_d(t_tags *ids)
{
	intmax_t	nbr;
	intmax_t	len;
	char		*str;

	nbr = cast_number(ids, 0);
	len = base_nbrcount(nbr, 10);
	if (ids->period == 1 && ids->maxwth == 0 && nbr == 0)
	{
		period_zero(ids);
		return (ids);
	}
	prefix_print(ids, len, nbr);
	nbr *= ids->negative;
	if (ids->current_flag[1] != '\0' && ids->period == 0)
		put_zero_df(ids, len);
	str = imaxtoa_base(nbr, 10);
	ft_putstr(str);
	ids->printed_chars += ft_strlen(str);
	if (ids->minwth > 0 && ids->current_flag[4] == '-')
		minwth_print(ids, len);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5c7a
movq %rax, %r15
movl $0xa, %esi
movq %rax, %rdi
callq 0x5ab4
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5f8d
movq 0x20(%rbx), %rcx
orq %r15, %rcx
je 0x60b1
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
jbe 0x5fce
cmpb $0x2d, 0x5c(%rbx)
je 0x5fce
cmpb $0x30, 0x59(%rbx)
jne 0x5fc3
xorl %edx, %edx
cmpq $0x1, %rax
sete %dl
movq 0x20(%rbx), %rax
xorl %esi, %esi
cmpq %rcx, %rax
setb %sil
testq %rax, %rax
cmovnel %esi, %edx
cmpb $0x1, %dl
jne 0x5fce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6764
cmpb $0x20, 0x5a(%rbx)
jne 0x5ffa
cmpl $0x1, 0x40(%rbx)
jne 0x5ffa
cmpb $0x0, 0x5b(%rbx)
jne 0x5ffa
leaq 0x19ac(%rip), %rsi      # 0x7993
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
testq %r15, %r15
js 0x6005
cmpb $0x2b, 0x5b(%rbx)
jne 0x602d
testq %r15, %r15
leaq 0x1a30(%rip), %rax      # 0x7a3f
leaq 0x1af7(%rip), %rsi      # 0x7b0d
cmovsq %rax, %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
cmpq $0x1, 0x18(%rbx)
jne 0x603f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x649c
movslq 0x40(%rbx), %rax
imulq %rax, %r15
cmpb $0x0, 0x59(%rbx)
je 0x605f
cmpq $0x0, 0x18(%rbx)
jne 0x605f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x649c
movl $0xa, %esi
movq %r15, %rdi
callq 0x5aea
movq %rax, %r15
movq %rax, %rdi
callq 0x4668
movq %r15, %rdi
callq 0x481c
addq %rax, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x609b
cmpb $0x2d, 0x5c(%rbx)
jne 0x609b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6764
movq %r15, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x62dc
jmp 0x60a3
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_o.c
// Function: print_o
t_tags				*print_o(t_tags *ids)
{
	uintmax_t	nbr;
	size_t		len;
	char		*str;

	nbr = cast_unsigned_number(ids, 0);
	str = uimaxtoa_base(nbr, 8);
	len = ft_strlen(str);
	if (ids->period == 1 && ids->maxwth == 0 && nbr == 0)
	{
		period_zero_check(ids);
		return (ids);
	}
	prefix_print(ids, nbr, len);
	ft_putstr(str);
	ids->printed_chars += len;
	if (nbr == 0 && ids->current_flag[0] == '#' && ids->current_flag[4] == '-')
		minwth_print(ids, len - 1);
	else if (ids->minwth > 0 && ids->current_flag[4] == '-')
		minwth_print(ids, len);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5dcc
movq %rax, %r12
movl $0x8, %esi
movq %rax, %rdi
callq 0x5a17
movq %rax, %r14
movq %rax, %rdi
callq 0x481c
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x6102
movq 0x20(%rbx), %rcx
orq %r12, %rcx
je 0x616e
testq %r12, %r12
jne 0x6117
cmpb $0x23, 0x58(%rbx)
jne 0x6117
cmpb $0x2d, 0x5c(%rbx)
jne 0x619f
cmpq %r15, 0x10(%rbx)
jbe 0x613a
cmpb $0x2d, 0x5c(%rbx)
je 0x613a
cmpq $0x1, %rax
je 0x612f
cmpb $0x30, 0x59(%rbx)
je 0x613a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
testq %r12, %r12
je 0x61ab
cmpb $0x23, 0x58(%rbx)
jne 0x61ab
cmpq $0x1, 0x18(%rbx)
jne 0x6152
cmpq %r15, 0x20(%rbx)
ja 0x61ab
leaq 0x19b6(%rip), %rsi      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
jmp 0x61ab
cmpq $0x0, 0x10(%rbx)
jne 0x6195
cmpb $0x23, 0x58(%rbx)
jne 0x6195
leaq 0x198d(%rip), %rsi      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
movq %rbx, %rdi
callq 0x62dc
jmp 0x620d
leaq -0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x6764
cmpb $0x30, 0x59(%rbx)
jne 0x61be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6691
jmp 0x61cb
cmpq $0x1, 0x18(%rbx)
jne 0x61cb
cmpq %r15, 0x20(%rbx)
ja 0x61b1
movq %r14, %rdi
callq 0x4668
addq %r15, 0x30(%rbx)
testq %r12, %r12
jne 0x61ed
cmpb $0x23, 0x58(%rbx)
jne 0x61ed
cmpb $0x2d, 0x5c(%rbx)
jne 0x61ed
decq %r15
jmp 0x61fa
cmpq $0x0, 0x10(%rbx)
je 0x6205
cmpb $0x2d, 0x5c(%rbx)
jne 0x6205
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_percent.c
// Function: print_percent
t_tags		*print_percent(t_tags *ids)
{
	if (ids->current_flag[4] == '-')
		write(1, "%", 1);
	while (ids->minwth > 1 && ids->current_flag[1] != '0')
	{
		write(1, " ", 1);
		ids->minwth--;
		ids->printed_chars++;
	}
	while (ids->minwth > 1 && ids->current_flag[1] == '0')
	{
		write(1, "0", 1);
		ids->minwth--;
		ids->printed_chars++;
	}
	if (ids->current_flag[4] != '-')
		write(1, "%", 1);
	ids->printed_chars++;
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x2d, 0x5c(%rdi)
jne 0x6242
leaq 0x18de(%rip), %rsi      # 0x7b11
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
cmpq $0x2, 0x10(%rbx)
jb 0x62b3
leaq 0x1743(%rip), %r14      # 0x7993
cmpb $0x30, 0x59(%rbx)
je 0x627f
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
cmpq $0x1, %rax
ja 0x6250
jmp 0x62b3
leaq 0x1889(%rip), %r14      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
cmpq $0x1, %rax
jbe 0x62b3
cmpb $0x30, 0x59(%rbx)
je 0x6286
cmpb $0x2d, 0x5c(%rbx)
je 0x62cf
leaq 0x1851(%rip), %rsi      # 0x7b11
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_u.c
// Function: period_zero
t_tags			*period_zero(t_tags *ids)
{
	if (ids->minwth == 0 && ids->current_flag[2] == '\0'
	&& ids->current_flag[3] == '\0')
		return (ids);
	if (ids->minwth > 0 &&
	(ids->current_flag[2] == ' ' || ids->current_flag[3] == '+'))
		ids->minwth--;
	while (ids->minwth > 0 && ids->current_flag[4] != '-')
	{
		write(1, " ", 1);
		ids->minwth--;
		ids->printed_chars++;
	}
	write_space_or_plus(ids);
	while (ids->minwth > 0 && ids->current_flag[4] == '-')
	{
		write(1, " ", 1);
		ids->minwth--;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movb 0x5a(%rdi), %cl
testq %rax, %rax
je 0x630f
cmpb $0x20, %cl
je 0x6300
cmpb $0x2b, 0x5b(%rbx)
jne 0x6325
leaq 0x5c(%rbx), %r15
decq %rax
movq %rax, 0x10(%rbx)
jne 0x6329
jmp 0x6321
testb %cl, %cl
jne 0x631d
cmpb $0x0, 0x5b(%rbx)
je 0x63c0
leaq 0x5c(%rbx), %r15
xorl %eax, %eax
jmp 0x635f
leaq 0x5c(%rbx), %r15
cmpb $0x2d, 0x5c(%rbx)
je 0x635f
leaq 0x165d(%rip), %r14      # 0x7993
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
movq 0x10(%rbx), %rax
incq 0x30(%rbx)
decq %rax
movq %rax, 0x10(%rbx)
je 0x6321
cmpb $0x2d, (%r15)
jne 0x6336
cmpb $0x2b, 0x5b(%rbx)
jne 0x636e
leaq 0x17a1(%rip), %rsi      # 0x7b0d
jmp 0x637b
cmpb $0x20, 0x5a(%rbx)
jne 0x6392
leaq 0x1618(%rip), %rsi      # 0x7993
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x63c0
leaq 0x15f5(%rip), %r14      # 0x7993
cmpb $0x2d, (%r15)
jne 0x63c0
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
incq 0x30(%rbx)
decq 0x10(%rbx)
jne 0x639e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_u.c
// Function: print_u
t_tags			*print_u(t_tags *ids)
{
	uintmax_t	nbr;
	size_t		len;
	char		*str;

	nbr = cast_unsigned_number(ids, 0);
	str = uimaxtoa_base(nbr, 10);
	len = ft_strlen(str);
	if (ids->period == 1 && ids->maxwth == 0 && nbr == 0)
	{
		period_zero(ids);
		return (ids);
	}
	prefix_print(ids, len);
	ft_putstr(str);
	ids->printed_chars += len;
	if (ids->minwth > len && ids->current_flag[4] == '-')
		minwth_print(ids, len);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5dcc
movq %rax, %r12
movl $0xa, %esi
movq %rax, %rdi
callq 0x5a17
movq %rax, %r14
movq %rax, %rdi
callq 0x481c
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x6411
orq 0x20(%rbx), %r12
je 0x648f
cmpq %r15, 0x10(%rbx)
jbe 0x6434
cmpb $0x2d, 0x5c(%rbx)
je 0x6434
cmpq $0x1, %rax
je 0x6429
cmpb $0x30, 0x59(%rbx)
je 0x6434
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
cmpb $0x30, 0x59(%rbx)
jne 0x6440
cmpq %r15, 0x10(%rbx)
ja 0x644d
cmpq $0x1, 0x18(%rbx)
jne 0x6458
cmpq %r15, 0x20(%rbx)
jbe 0x6458
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6691
movq %r14, %rdi
callq 0x4668
addq %r15, 0x30(%rbx)
cmpq %r15, 0x10(%rbx)
jbe 0x647b
cmpb $0x2d, 0x5c(%rbx)
jne 0x647b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6764
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x62dc
jmp 0x6483
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_df
t_tags			*put_zero_df(t_tags *ids, size_t len)
{
	if (ids->current_type == 'f')
	{
		len += ids->period == 0 ? 7 : ids->maxwth + 1;
	}
	if (ids->current_flag[4] == '-' && ids->minwth > len && ids->period == 0)
		return (ids);
	if (ids->current_flag[3] == '+' && ids->period == 0 && ids->negative == 1)
		len++;
	if (ids->current_flag[1] == '0' && ids->current_flag[2] == ' ' &&
	ids->minwth > len && ids->negative == 1)
		len++;
	if (ids->negative == -1 && ids->maxwth + 1 > len)
		len--;
	write_zero(ids, len);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x5e(%rdi), %al
cmpb $0x66, %al
jne 0x64cb
cmpq $0x0, 0x18(%rbx)
je 0x64c3
movq 0x20(%rbx), %rcx
incq %rcx
jmp 0x64c8
movl $0x7, %ecx
addq %rcx, %r14
cmpb $0x2d, 0x5c(%rbx)
jne 0x64e2
cmpq %r14, 0x10(%rbx)
jbe 0x64e2
cmpq $0x0, 0x18(%rbx)
je 0x6596
cmpb $0x2b, 0x5b(%rbx)
jne 0x64fb
cmpq $0x0, 0x18(%rbx)
jne 0x64fb
xorl %ecx, %ecx
cmpl $0x1, 0x40(%rbx)
sete %cl
addq %rcx, %r14
cmpb $0x30, 0x59(%rbx)
jne 0x6519
cmpb $0x20, 0x5a(%rbx)
jne 0x6519
cmpq %r14, 0x10(%rbx)
jbe 0x6519
xorl %ecx, %ecx
cmpl $0x1, 0x40(%rbx)
sete %cl
addq %rcx, %r14
cmpl $-0x1, 0x40(%rbx)
jne 0x652d
movq 0x20(%rbx), %rcx
incq %rcx
cmpq %rcx, %r14
sbbq $0x0, %r14
cmpb $0x66, %al
je 0x656a
cmpq $0x1, 0x18(%rbx)
jne 0x656a
cmpq %r14, 0x20(%rbx)
jbe 0x6596
leaq 0x15ca(%rip), %r15      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1040
incq 0x30(%rbx)
decq 0x10(%rbx)
incq %r14
cmpq %r14, 0x20(%rbx)
ja 0x6545
jmp 0x6596
cmpq %r14, 0x10(%rbx)
jbe 0x6596
leaq 0x1598(%rip), %r15      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1040
incq 0x30(%rbx)
incq %r14
cmpq %r14, 0x10(%rbx)
ja 0x6577
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_p
t_tags			*put_zero_p(t_tags *ids, size_t len)
{
	if (ids->current_flag[1] == '0' && ids->period == 1 && ids->maxwth < len)
		return (ids);
	else if (ids->current_type == 'p' && ids->current_flag[1] == '0'
	&& ids->period == 0)
		len += 2;
	if (ids->maxwth >= len)
	{
		maxwth_write(ids, len);
		return (ids);
	}
	while (ids->minwth > len)
	{
		write(1, "0", 1);
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x30, 0x59(%rdi)
jne 0x65db
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x65ca
cmpq %r14, 0x20(%rbx)
jb 0x661a
cmpb $0x70, 0x5e(%rbx)
jne 0x65db
leaq 0x2(%r14), %rcx
testq %rax, %rax
cmoveq %rcx, %r14
cmpq %r14, 0x20(%rbx)
jae 0x660f
cmpq %r14, 0x10(%rbx)
jbe 0x661a
leaq 0x1521(%rip), %r15      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1040
incq 0x30(%rbx)
incq %r14
cmpq %r14, 0x10(%rbx)
ja 0x65ee
jmp 0x661a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6628
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: maxwth_write
static t_tags	*maxwth_write(t_tags *ids, size_t len)
{
	while (ids->maxwth > len)
	{
		if (ids->minwth == 0)
			ids->minwth++;
		write(1, "0", 1);
		ids->minwth--;
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, 0x20(%rdi)
jbe 0x6683
movq %rsi, %r14
movq 0x10(%rbx), %rax
leaq 0x14c6(%rip), %r15      # 0x7b0f
testq %rax, %rax
jne 0x6656
movq $0x1, 0x10(%rbx)
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1040
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
decq %rax
movq %rax, 0x10(%rbx)
incq %r14
incq 0x30(%rbx)
cmpq %r14, %rcx
ja 0x6649
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/put_zeros.c
// Function: put_zero_oxu
t_tags			*put_zero_oxu(t_tags *ids, size_t len)
{
	if (ids->current_type == 'u' && ids->current_flag[1] == '0'
	&& ids->period == 1 && ids->maxwth < len)
		return (ids);
	if ((ids->current_type == 'o' || ids->current_type == 'x'
	|| ids->current_type == 'X') && ((ids->current_flag[1] == '0'
	&& ids->period == 1 && ids->maxwth < len)
	|| (ids->current_flag[4] == '-' && ids->minwth > len && ids->period == 0)))
		return (ids);
	if ((ids->current_type == 'x' || ids->current_type == 'X')
	&& ids->current_flag[0] == '#' && ids->maxwth <= len)
		len += 2;
	if (ids->maxwth >= len)
	{
		maxwth_write(ids, len);
		return (ids);
	}
	while (ids->minwth > len)
	{
		write(1, "0", 1);
		len++;
		ids->printed_chars++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x5e(%rdi), %eax
cmpl $0x74, %eax
jg 0x66b6
cmpl $0x58, %eax
je 0x66d5
cmpl $0x6f, %eax
je 0x66d5
jmp 0x6715
cmpl $0x78, %eax
je 0x66d5
cmpl $0x75, %eax
jne 0x6715
cmpb $0x30, 0x59(%rbx)
jne 0x6715
cmpq $0x1, 0x18(%rbx)
jne 0x6715
cmpq %r14, 0x20(%rbx)
jae 0x6715
jmp 0x6754
cmpb $0x30, 0x59(%rbx)
jne 0x66e8
cmpq $0x1, 0x18(%rbx)
jne 0x66e8
cmpq %r14, 0x20(%rbx)
jb 0x6754
cmpb $0x2d, 0x5c(%rbx)
jne 0x66fb
cmpq %r14, 0x10(%rbx)
jbe 0x66fb
cmpq $0x0, 0x18(%rbx)
je 0x6754
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x6715
cmpb $0x23, 0x58(%rbx)
jne 0x6715
cmpq %r14, 0x20(%rbx)
leaq 0x2(%r14), %rax
cmovbeq %rax, %r14
cmpq %r14, 0x20(%rbx)
jae 0x6749
cmpq %r14, 0x10(%rbx)
jbe 0x6754
leaq 0x13e7(%rip), %r15      # 0x7b0f
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1040
incq 0x30(%rbx)
incq %r14
cmpq %r14, 0x10(%rbx)
ja 0x6728
jmp 0x6754
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6628
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeResizeSetSize
int aeResizeSetSize(aeEventLoop *eventLoop, int setsize) {
    int i;

    if (setsize == eventLoop->setsize) return AE_OK;
    if (eventLoop->maxfd >= setsize) return AE_ERR;
    if (aeApiResize(eventLoop,setsize) == -1) return AE_ERR;

    eventLoop->events = realloc(eventLoop->events,sizeof(aeFileEvent)*setsize);
    eventLoop->fired = realloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);
    eventLoop->setsize = setsize;

    /* Make sure that if we created new slots, they are initialized with
     * an AE_NONE mask. */
    for (i = eventLoop->maxfd+1; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return AE_OK;
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x4(%rdi)
je 0x2e78
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, (%rdi)
jge 0x2e6d
movq 0x38(%r14), %r12
movq 0x8(%r12), %rdi
movslq %ebx, %r15
leaq (,%r15,4), %rax
leaq (%rax,%rax,2), %rsi
callq 0x2310
movq %rax, 0x8(%r12)
movq 0x18(%r14), %rdi
movq %r15, %rsi
shlq $0x5, %rsi
callq 0x2310
movq %rax, 0x18(%r14)
movq 0x20(%r14), %rdi
leaq (,%r15,8), %rsi
callq 0x2310
movq %rax, 0x20(%r14)
movl %r15d, 0x4(%r14)
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
movl $0x0, %eax
cmpl %r15d, %edx
jge 0x2e6d
movq 0x18(%r14), %rdx
subl %ecx, %ebx
addl $-0x2, %ebx
leaq 0x4(%rbx), %rax
andq $-0x4, %rax
movq %rbx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shlq $0x5, %rcx
addq %rdx, %rcx
addq $0x80, %rcx
xorl %edx, %edx
movdqa 0x527b(%rip), %xmm1     # 0x8010
movdqa 0x5283(%rip), %xmm2     # 0x8020
movdqa 0x528b(%rip), %xmm3     # 0x8030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x2df7
movl $0x0, -0x60(%rcx)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x2e0d
movl $0x0, -0x40(%rcx)
por %xmm1, %xmm5
pxor %xmm3, %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
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x2e49
movl $0x0, -0x20(%rcx)
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2e5a
movl $0x0, (%rcx)
addq $0x4, %rdx
subq $-0x80, %rcx
cmpq %rdx, %rax
jne 0x2dad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeDeleteTimeEvent
int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te, *prev = NULL;

    te = eventLoop->timeEventHead;
    while(te) {
        if (te->id == id) {
            if (prev == NULL)
                eventLoop->timeEventHead = te->next;
            else
                prev->next = te->next;
            if (te->finalizerProc)
                te->finalizerProc(eventLoop, te->clientData);
            free(te);
            return AE_OK;
        }
        prev = te;
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x31d5
cmpq %rsi, (%rbx)
jne 0x318f
xorl %ecx, %ecx
jmp 0x31a6
movq %rbx, %rdx
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
je 0x31d5
movq %rdx, %rcx
movq %rbx, %rdx
cmpq %rsi, (%rbx)
jne 0x3192
leaq 0x28(%rdi), %rax
leaq 0x30(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rax, %rdx
movq 0x30(%rbx), %rax
movq %rax, (%rdx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x31cb
movq 0x28(%rbx), %rsi
callq *%rax
movq %rbx, %rdi
callq 0x2030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_init
void assoc_init(void) {
    unsigned int hash_size = hashsize(HASHPOWER) * sizeof(void*);
    hashtable = malloc(hash_size);
    if (! hashtable) {
        fprintf(stderr, "Failed to init hashtable.\n");
        exit(1);
    }
    memset(hashtable, 0, hash_size);
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x800000, %esi         # imm = 0x800000
callq 0x2220
movq %rax, 0x9a2d(%rip)      # 0xd258
testq %rax, %rax
je 0x3832
popq %rax
retq
callq 0x2480
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_find
item *assoc_find(char *key) {
    ub4 hv = hash(key, strlen(key), 0) & hashmask(HASHPOWER);
    item *it = hashtable[hv];

    while (it) {
        if (strcmp(key, ITEM_key(it)) == 0)
            return it;
        it = it->h_next;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2120
xorl %r14d, %r14d
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x362c
andl $0xfffff, %eax          # imm = 0xFFFFF
movq 0x99f8(%rip), %rcx      # 0xd258
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x388a
xorl %r14d, %r14d
leaq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
je 0x3887
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x386c
jmp 0x388a
movq %r15, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_insert
int assoc_insert(char *key, item *it) {
    ub4 hv;
    assert(assoc_find(key) == 0);  /* shouldn't have duplicately named things defined */
    hv = hash(key, strlen(key), 0) & hashmask(HASHPOWER);
    it->h_next = hashtable[hv];
    hashtable[hv] = it;
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2120
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x362c
andl $0xfffff, %eax          # imm = 0xFFFFF
movq 0x999d(%rip), %rcx      # 0xd258
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x10(%rbx)
movq %rbx, (%rcx,%rax,8)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/assoc.c
// Function: assoc_delete
void assoc_delete(char *key) {
    item **before = _hashitem_before(key);
    if (*before) {
        item *nxt = (*before)->h_next;
        (*before)->h_next = 0;   /* probably pointless, but whatever. */
        *before = nxt;
        return;
    }
    /* Note:  we never actually get here.  the callers don't delete things
       they can't find. */
    assert(*before != 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2120
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x362c
movq %rax, %r14
andl $0xfffff, %r14d         # imm = 0xFFFFF
movq 0x9956(%rip), %r12      # 0xd258
movq (%r12,%r14,8), %r15
testq %r15, %r15
je 0x3950
leaq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
je 0x393d
movq %r15, %r14
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x3950
leaq 0x30(%r15), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
jne 0x391b
addq $0x10, %r14
jmp 0x3941
leaq (%r12,%r14,8), %r14
movq 0x10(%r15), %rax
movq $0x0, 0x10(%r15)
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_create
command_service_ptr command_service_create() {
    command_service_ptr cmd_srv;
    cmd_srv = (command_service_ptr)calloc(1, sizeof(command_service));
    if (NULL == cmd_srv) {
        exit(-1);
    }
    return cmd_srv;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x18, %esi
callq 0x2220
testq %rax, %rax
je 0x3973
popq %rcx
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2410
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_run
int32_t command_service_run(command_service_ptr service, char *cmd_s, int argc, char **argv) {
    command_info_ptr cmd;
    for (cmd = service->command_list; NULL != cmd; cmd = cmd->next) {
        if (FIXED_PREFIX == cmd->type && strncmp(cmd_s, cmd->cmd, cmd->cmd_len) == 0) {
            return cmd->handler(cmd_s, argc, argv);
        }
        if (FULL_MATCH == cmd->type && strcmp(cmd_s, cmd->cmd) == 0) {
            return cmd->handler(cmd_s, argc, argv);
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x3b0d
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl 0xc(%r15), %eax
testl %eax, %eax
je 0x3af5
cmpl $0x1, %eax
jne 0x3b04
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %r14, %rdi
callq 0x2070
jmp 0x3b00
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x3b1d
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x3ad7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r15), %rax
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/command.c
// Function: command_service_destory
void command_service_destory(command_service_ptr service) {
    command_info_ptr cmd, next_cmd;
    
    if (NULL == service) {
        return;
    }
    cmd = service->command_list;
    while (NULL != cmd) {
        next_cmd = cmd->next;
        free(cmd->cmd);
        free(cmd);
        cmd = next_cmd;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x3b69
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x3b62
movq (%rbx), %rdi
movq 0x18(%rbx), %r14
callq 0x2030
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3b46
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/zuocheng-liu[P]ae-memcached/src/connection.c
// Function: conn_cleanup
void conn_cleanup(conn *c) {
    if (c->item) {
        item_free(c->item);
        c->item = 0;
    }

    if (c->ileft) {
        for (; c->ileft > 0; c->ileft--,c->icurr++) {
            item_remove(*(c->icurr));
        }
    }

    if (c->write_and_free) {
        free(c->write_and_free);
        c->write_and_free = 0;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x3ee9
callq 0x4742
movq $0x0, 0x68(%rbx)
cmpl $0x0, 0xb8(%rbx)
jle 0x3f27
movq 0xb0(%rbx), %rax
movq (%rax), %rdi
callq 0x489a
movl 0xb8(%rbx), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0xb8(%rbx)
movq 0xb0(%rbx), %rax
addq $0x8, %rax
movq %rax, 0xb0(%rbx)
cmpl $0x1, %ecx
jg 0x3ef9
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3f3d
callq 0x2030
movq $0x0, 0x50(%rbx)
popq %rbx
retq