LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/set_tags_and_print.c
// Function: read_format
int				read_format(t_tags *ids)
{
	while (ids->format[ids->i])
	{
		if (ids->format[ids->i] == '%' && ids->format[ids->i + 1] == '%')
		{
			write(1, &ids->format[ids->i], 1);
			ids->i += 2;
			ids->printed_chars++;
		}
		else if (ids->format[ids->i] == '%')
			call_identifier_readers(ids);
		else
		{
			write(1, &ids->format[ids->i], 1);
			ids->printed_chars++;
			ids->i++;
		}
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
pushq $0x1
popq %r15
movq (%rbx), %rsi
movq 0x28(%rbx), %rax
movzbl (%rsi,%rax), %ecx
addq %rax, %rsi
cmpl $0x25, %ecx
je 0x4742
testl %ecx, %ecx
je 0x47a2
movl %r14d, %edi
movq %r15, %rdx
callq 0x1040
incq 0x30(%rbx)
incq 0x28(%rbx)
jmp 0x4716
cmpb $0x25, 0x1(%rsi)
jne 0x475e
movl %r14d, %edi
movq %r15, %rdx
callq 0x1040
addq $0x2, 0x28(%rbx)
incq 0x30(%rbx)
jmp 0x4716
incq %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x4549
movq %rbx, %rdi
callq 0x51b1
movq %rbx, %rdi
callq 0x5167
movq %rbx, %rdi
callq 0x5113
movq %rbx, %rdi
callq 0x50ac
movq %rbx, %rdi
callq 0x5080
movq %rbx, %rdi
callq 0x4658
jmp 0x4716
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/get_next_line.c
// Function: get_next_line
int			get_next_line(const int fd, char **line)
{
	char		buff[BUFF_SIZE + 1];
	static char	*str[MAX_FD];
	char		*ptr;
	int			ret;

	if (!line || fd > MAX_FD || fd < 0)
		return (-1);
	if (str[fd] == NULL)
		if (!(str[fd] = ft_strnew(0)))
			return (-1);
	while ((ret = read(fd, buff, BUFF_SIZE)) > 0)
	{
		buff[ret] = '\0';
		ptr = ft_strjoin(str[fd], buff);
		free(str[fd]);
		str[fd] = ptr;
		if (ft_strchr(str[fd], '\n'))
			break ;
	}
	if (ret < 0)
		return (-1);
	if (ret == 0 && str[fd][0] == '\0')
		return (0);
	else
		return (rest_of_line(&str[fd], line));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
sete %al
cmpl $0x1301, %edi           # imm = 0x1301
setae %cl
orb %al, %cl
pushq $-0x1
popq %r15
jne 0x48cf
movq %rsi, %r14
movl %edi, %r12d
movl %edi, %eax
leaq 0x6885(%rip), %rcx      # 0xb070
leaq (%rcx,%rax,8), %rbx
cmpq $0x0, (%rbx)
jne 0x4808
xorl %edi, %edi
callq 0x4344
movq %rax, (%rbx)
testq %rax, %rax
je 0x48cf
movq %r14, -0x38(%rbp)
leaq -0x2a(%rbp), %r13
pushq $0x1
popq %r14
movl %r12d, %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1060
testl %eax, %eax
jle 0x485e
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, -0x2a(%rbp,%rax)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x4294
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1030
movq %r15, (%rbx)
movq %r15, %rdi
pushq $0xa
popq %rsi
callq 0x41bc
testq %rax, %rax
je 0x4814
movq (%rbx), %rdi
jmp 0x486c
pushq $-0x1
popq %r15
js 0x48cf
movq (%rbx), %rdi
cmpb $0x0, (%rdi)
je 0x48e1
xorl %r14d, %r14d
movzbl (%rdi,%r14), %eax
testl %eax, %eax
je 0x48b2
cmpl $0xa, %eax
je 0x4882
incq %r14
jmp 0x486f
xorl %esi, %esi
movq %r14, %rdx
callq 0x446c
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
leaq (%rax,%r14), %rdi
incq %rdi
callq 0x4228
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
jmp 0x48cb
xorl %esi, %esi
movq %r14, %rdx
callq 0x446c
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x4204
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x48cf
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_memalloc.c
// Function: ft_memalloc
void	*ft_memalloc(size_t size)
{
	char	*str;
	size_t	i;

	if (!(str = (void*)malloc(size)))
		return (NULL);
	i = 0;
	while (i < size)
	{
		str[i] = '\0';
		i++;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1070
testq %rax, %rax
je 0x490b
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0x490b
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x48fd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	int i;

	i = 0;
	while (src[i] != '\0')
	{
		dst[i] = src[i];
		i++;
	}
	dst[i] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x4950
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x4941
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_c.c
// Function: print_c
t_tags	*print_c(t_tags *ids)
{
	char	c;

	c = (char)va_arg(ids->arguments, int);
	if (ids->minwth > 0 && ids->current_flag[4] == '\0')
		minwth_print(ids, 1);
	write(1, &c, 1);
	ids->printed_chars++;
	if (ids->minwth > 0 && ids->current_flag[4] != '\0')
		minwth_print(ids, 1);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4979
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x4985
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movb (%rax), %al
movb %al, -0x9(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0x49a2
cmpb $0x0, 0x5c(%rbx)
jne 0x49a2
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5fc4
pushq $0x1
popq %rdi
leaq -0x9(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x1040
incq 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x49cd
cmpb $0x0, 0x5c(%rbx)
je 0x49cd
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5fc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_p.c
// Function: print_p
t_tags			*print_p(t_tags *ids)
{
	uintmax_t	ptr;
	char		*str;

	ptr = (unsigned long)va_arg(ids->arguments, unsigned long int);
	str = imaxtoa_base(ptr, 16);
	if (ids->minwth > 0 && ids->current_flag[4] != '-')
		minwth_print(ids, ft_strlen(str) + 2);
	ft_putstr("0x");
	if (ids->period == 1 && ids->maxwth == 0 && ptr == 0)
	{
		ids->printed_chars += 2;
		period_zero(ids);
		return (ids);
	}
	if ((ids->current_flag[1] == '0' && ft_strlen(str) + 2 < ids->minwth &&
	ids->minwth > 0) || (ids->period == 1 && ids->maxwth > ft_strlen(str)))
		put_zero_p(ids, ft_strlen(str));
	ft_putstr(str);
	ids->printed_chars += ft_strlen(str) + 2;
	if (ids->current_flag[4] == '-' && ((ids->maxwth >= ft_strlen(str) + 2
	&& ids->period == 1) || ids->minwth > 0))
		minwth_print(ids, ft_strlen(str) + 2);
	free(str);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4d19
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x4d25
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x53cd
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x4d57
cmpb $0x2d, 0x5c(%rbx)
je 0x4d57
movq %r14, %rdi
callq 0x431c
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x5fc4
leaq 0x2d18(%rip), %rdi      # 0x7a76
callq 0x4194
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x4d77
orq 0x20(%rbx), %r15
je 0x4e2f
cmpb $0x30, 0x59(%rbx)
jne 0x4d93
movq %r14, %rdi
callq 0x431c
addq $0x2, %rax
cmpq 0x10(%rbx), %rax
jb 0x4daa
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x4dbd
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x431c
cmpq %rax, %r15
jbe 0x4dbd
movq %r14, %rdi
callq 0x431c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5e04
movq %r14, %rdi
callq 0x4194
movq %r14, %rdi
callq 0x431c
movq 0x30(%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x30(%rbx)
cmpb $0x2d, 0x5c(%rbx)
jne 0x4e19
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x431c
addq $0x2, %rax
cmpq %rax, %r15
jb 0x4dfe
cmpq $0x1, 0x18(%rbx)
je 0x4e05
cmpq $0x0, 0x10(%rbx)
je 0x4e19
movq %r14, %rdi
callq 0x431c
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x5fc4
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x2, 0x30(%rbx)
movq %rbx, %rdi
callq 0x5b48
jmp 0x4e21
nop
// File: /workspace/github_c_makefile_star2_O2/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_s.c
// Function: print_s
t_tags			*print_s(t_tags *ids)
{
	char	*str;
	size_t	len;

	str = va_arg(ids->arguments, char*);
	if (str == NULL)
		str = "(null)";
	if (ids->period == 1 && ids->maxwth < ft_strlen(str))
		str = ft_strsub(str, 0, ids->maxwth);
	else
		str = ft_strsub(str, 0, ft_strlen(str));
	len = ft_strlen(str);
	if (ids->minwth > 0 && ids->current_flag[4] == '\0'
		&& ids->current_flag[1] == '\0')
		minwth_print(ids, len);
	if (ids->current_flag[1] == '0' && len < ids->minwth)
		put_zero_df(ids, len);
	ft_putstr(str);
	ids->printed_chars += len;
	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
movl 0x68(%rdi), %ecx
cmpq $0x28, %rcx
ja 0x4e65
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x4e71
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %rax
testq %rax, %rax
leaq 0x2bfb(%rip), %r14      # 0x7a79
cmovneq %rax, %r14
cmpq $0x1, 0x18(%rbx)
jne 0x4ea0
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x431c
cmpq %rax, %r15
jae 0x4ea0
movq 0x20(%rbx), %rdx
jmp 0x4eab
movq %r14, %rdi
callq 0x431c
movq %rax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x446c
movq %rax, %r14
movq %rax, %rdi
callq 0x431c
movq %rax, %r15
cmpq $0x0, 0x10(%rbx)
je 0x4ee1
cmpb $0x0, 0x5c(%rbx)
jne 0x4ee1
cmpb $0x0, 0x59(%rbx)
jne 0x4ee1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
cmpb $0x30, 0x59(%rbx)
jne 0x4ef8
cmpq 0x10(%rbx), %r15
jae 0x4ef8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5cf8
movq %r14, %rdi
callq 0x4194
addq %r15, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x4f1c
cmpb $0x2d, 0x5c(%rbx)
jne 0x4f1c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5672
movq %rax, %r15
cmpb $0x78, 0x5e(%rbx)
jne 0x4f5f
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x5332
jmp 0x4f6a
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x52cc
movq %rax, %r14
movq %rax, %rdi
callq 0x431c
movq %rax, %r12
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x4f98
movq 0x20(%rbx), %rcx
orq %r15, %rcx
jne 0x4f98
movq %rbx, %rdi
callq 0x5b48
jmp 0x5064
testq %r15, %r15
jne 0x4fad
cmpb $0x23, 0x58(%rbx)
jne 0x4fad
cmpb $0x2d, 0x5c(%rbx)
jne 0x5070
cmpq %r12, 0x10(%rbx)
jbe 0x4fd0
cmpb $0x2d, 0x5c(%rbx)
je 0x4fd0
cmpq $0x1, %rax
je 0x4fc5
cmpb $0x30, 0x59(%rbx)
je 0x4fd0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5fc4
testq %r15, %r15
je 0x5001
cmpb $0x23, 0x58(%rbx)
jne 0x5001
cmpb $0x78, 0x5e(%rbx)
leaq 0x2a90(%rip), %rax      # 0x7a76
leaq 0x2a93(%rip), %rsi      # 0x7a80
cmoveq %rax, %rsi
pushq $0x1
popq %rdi
pushq $0x2
popq %rdx
callq 0x1040
addq $0x2, 0x30(%rbx)
cmpb $0x30, 0x59(%rbx)
jne 0x5014
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5ef3
jmp 0x5021
cmpq $0x1, 0x18(%rbx)
jne 0x5021
cmpq %r12, 0x20(%rbx)
ja 0x5007
movq %r14, %rdi
callq 0x4194
addq %r12, 0x30(%rbx)
testq %r15, %r15
jne 0x5044
cmpb $0x23, 0x58(%rbx)
jne 0x5044
cmpb $0x2d, 0x5c(%rbx)
jne 0x5044
addq $-0x2, %r12
jmp 0x5051
cmpq $0x0, 0x10(%rbx)
je 0x505c
cmpb $0x2d, 0x5c(%rbx)
jne 0x505c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5fc4
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 0x5fc4
jmp 0x5001
nop
// File: /workspace/github_c_makefile_star2_O2/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), %dl
testb %dl, %dl
je 0x50aa
movq (%rax), %rdi
movq 0x28(%rax), %rsi
incq %rcx
cmpb %dl, (%rdi,%rsi)
jne 0x508b
movb %dl, 0x5e(%rax)
incq %rsi
movq %rsi, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5111
movabsq $0x110000001, %rdi      # imm = 0x110000001
btq %rsi, %rdi
jae 0x5111
movq 0x50(%rax), %rsi
xorl %edi, %edi
movl $0x1, %r8d
xorl %r9d, %r9d
movb (%rsi,%rdi), %r10b
testb %r10b, %r10b
jne 0x5106
jmp 0x5111
movl %r9d, %r9d
movb %r10b, 0x5f(%rax,%r9)
incq %rdx
movq %rdx, 0x28(%rax)
movb (%rsi,%rdi), %r10b
movl %r8d, %r9d
cmpb (%rcx,%rdx), %r10b
je 0x50f0
incq %rdi
jmp 0x50e5
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5165
incq 0x18(%rax)
incq %rdx
movq %rdx, 0x28(%rax)
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x5165
movzbl %sil, %esi
addq 0x20(%rax), %rsi
movq %rsi, 0x20(%rax)
movb 0x1(%rcx,%rdx), %dil
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x512b
imulq $0xa, %rsi, %rsi
movq %rsi, 0x20(%rax)
jmp 0x512b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
incq %rdx
movb -0x1(%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x51af
movzbl %sil, %esi
addq 0x10(%rax), %rsi
movq %rsi, 0x10(%rax)
movb (%rcx,%rdx), %dil
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x51a9
imulq $0xa, %rsi, %rsi
movq %rsi, 0x10(%rax)
movq %rdx, 0x28(%rax)
jmp 0x5175
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r10d, %r10d
movabsq $0x1, %rdx
movl $0x1, %esi
movslq %r10d, %rdi
movb (%rcx,%rdi), %r9b
testb %r9b, %r9b
je 0x529d
movq (%rax), %rdi
movq 0x28(%rax), %r8
incl %r10d
cmpb (%rdi,%r8), %r9b
jne 0x51ce
cmpb $0x23, %r9b
jne 0x5212
leaq 0x1(%r8), %r10
movq %r10, 0x28(%rax)
testq %r8, %r8
je 0x520f
movb $0x23, 0x58(%rax)
movb 0x1(%rdi,%r8), %r9b
movq %r10, %r8
jmp 0x51ee
movq %rdx, %r8
cmpb $0x30, (%rdi,%r8)
jne 0x5232
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rax)
testq %r8, %r8
je 0x522f
movb $0x30, 0x59(%rax)
movq %r9, %r8
jmp 0x5212
movq %rdx, %r8
cmpb $0x20, (%rdi,%r8)
jne 0x5252
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rax)
testq %r8, %r8
je 0x524f
movb $0x20, 0x5a(%rax)
movq %r9, %r8
jmp 0x5232
movq %rdx, %r8
cmpb $0x2b, (%rdi,%r8)
jne 0x5272
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rax)
testq %r8, %r8
je 0x526f
movb $0x2b, 0x5b(%rax)
movq %r9, %r8
jmp 0x5252
movq %rdx, %r8
cmpb $0x2d, (%rdi,%r8)
jne 0x5292
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rax)
testq %r8, %r8
je 0x528f
movb $0x2d, 0x5c(%rax)
movq %r9, %r8
jmp 0x5272
movq %rdx, %r8
movb (%rcx), %r9b
movl %esi, %r10d
jmp 0x51e8
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x52bd
movq %rdi, %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x52c7
incq %rcx
xorl %edx, %edx
divq %rsi
jmp 0x52ae
movabsq $0x1, %rcx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x52a0
movq %rax, %r15
movq %rax, %rdi
callq 0x4344
movq %rax, %rcx
testq %rax, %rax
je 0x5324
testq %r14, %r14
jne 0x52fc
movb $0x30, (%rcx)
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x2779(%rip), %rdi      # 0x7a83
testq %r14, %r14
je 0x5324
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
movq %rax, %r14
jmp 0x530a
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x52a0
movq %rax, %r15
movq %rax, %rdi
callq 0x4344
movq %rax, %rcx
testq %rax, %rax
je 0x538a
testq %r14, %r14
jne 0x5362
movb $0x30, (%rcx)
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x2738(%rip), %rdi      # 0x7aa8
testq %r14, %r14
je 0x538a
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
movq %rax, %r14
jmp 0x5370
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x53be
movq %rdi, %rax
negq %rax
cmovsq %rdi, %rax
shrq $0x3f, %rdi
testq %rax, %rax
jle 0x53c8
incq %rdi
xorl %edx, %edx
divq %rsi
jmp 0x53af
movabsq $0x1, %rdi
movq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
negq %rax
jno 0x53e1
leaq 0x26f1(%rip), %rdi      # 0x7acd
jmp 0x4228
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5398
movq %rax, %r15
movq %rax, %rdi
callq 0x4344
testq %rax, %rax
je 0x5439
movq %rax, %rcx
testq %r14, %r14
jne 0x5411
movb $0x30, (%rcx)
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x2689(%rip), %rdi      # 0x7aa8
testq %r14, %r14
jle 0x543b
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
movq %rax, %r14
jmp 0x541f
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2676(%rip), %rsi      # 0x7ae1
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x54a3
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x5492
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x549e
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x263d(%rip), %rsi      # 0x7ae7
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x54e2
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x54d1
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x54dd
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x2568(%rip), %rsi      # 0x7a51
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
fldt -0x1c(%rbp)
jne 0x5510
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 0x551a
orl $-0x1, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25a3(%rip), %rsi      # 0x7ae1
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x5571
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5562
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x556e
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movslq (%rax), %r15
leaq 0x256c(%rip), %rsi      # 0x7ae4
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x55ac
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x559c
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x55a8
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movswq (%rax), %r15
leaq 0x2534(%rip), %rsi      # 0x7ae7
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x55e6
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x55d7
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x55e3
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
leaq 0x24f6(%rip), %rsi      # 0x7ae3
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x5621
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5611
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x561d
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movsbq (%rax), %r15
leaq 0x24be(%rip), %rsi      # 0x7ae6
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x565b
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x564c
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5658
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
testq %r15, %r15
jns 0x5664
orl $-0x1, 0x40(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2454(%rip), %rsi      # 0x7ae1
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x56c0
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x56b1
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x56bd
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movl (%rax), %r15d
leaq 0x241d(%rip), %rsi      # 0x7ae4
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x56fb
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x56eb
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x56f7
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movzwl (%rax), %r15d
leaq 0x23e5(%rip), %rsi      # 0x7ae7
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x5735
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5726
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5732
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
leaq 0x23a7(%rip), %rsi      # 0x7ae3
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x5770
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5760
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x576c
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movzbl (%rax), %r15d
leaq 0x236f(%rip), %rsi      # 0x7ae6
movq %r14, %rdi
callq 0x41e0
testl %eax, %eax
jne 0x57aa
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x579b
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x57a7
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
// File: /workspace/github_c_makefile_star2_O2/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 0x5523
movq %rax, %r15
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5398
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x582b
movq 0x20(%rbx), %rcx
orq %r15, %rcx
je 0x592c
movq 0x10(%rbx), %rcx
cmpq %r14, %rcx
jbe 0x586c
cmpb $0x2d, 0x5c(%rbx)
je 0x586c
cmpb $0x30, 0x59(%rbx)
jne 0x5861
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 0x586c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fc4
cmpb $0x20, 0x5a(%rbx)
jne 0x5894
cmpl $0x1, 0x40(%rbx)
jne 0x5894
cmpb $0x0, 0x5b(%rbx)
jne 0x5894
leaq 0x210e(%rip), %rsi      # 0x7993
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
incq 0x30(%rbx)
testq %r15, %r15
js 0x589f
cmpb $0x2b, 0x5b(%rbx)
jne 0x58aa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x57b8
cmpq $0x1, 0x18(%rbx)
jne 0x58bc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5cf8
movslq 0x40(%rbx), %rax
imulq %rax, %r15
cmpb $0x0, 0x59(%rbx)
je 0x58dc
cmpq $0x0, 0x18(%rbx)
jne 0x58dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5cf8
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x53cd
movq %rax, %r15
movq %rax, %rdi
callq 0x4194
movq %r15, %rdi
callq 0x431c
addq %rax, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x5916
cmpb $0x2d, 0x5c(%rbx)
jne 0x5916
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fc4
movq %r15, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x5b48
jmp 0x591e
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x5672
movq %rax, %r12
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x5332
movq %rax, %r14
movq %rax, %rdi
callq 0x431c
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x597c
movq 0x20(%rbx), %rcx
orq %r12, %rcx
je 0x59e4
testq %r12, %r12
jne 0x5991
cmpb $0x23, 0x58(%rbx)
jne 0x5991
cmpb $0x2d, 0x5c(%rbx)
jne 0x5a11
cmpq %r15, 0x10(%rbx)
jbe 0x59b4
cmpb $0x2d, 0x5c(%rbx)
je 0x59b4
cmpq $0x1, %rax
je 0x59a9
cmpb $0x30, 0x59(%rbx)
je 0x59b4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
testq %r12, %r12
je 0x5a1d
cmpb $0x23, 0x58(%rbx)
jne 0x5a1d
cmpq $0x1, 0x18(%rbx)
jne 0x59cc
cmpq %r15, 0x20(%rbx)
ja 0x5a1d
leaq 0x2118(%rip), %rsi      # 0x7aeb
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
incq 0x30(%rbx)
jmp 0x5a1d
cmpq $0x0, 0x10(%rbx)
jne 0x5a07
cmpb $0x23, 0x58(%rbx)
jne 0x5a07
leaq 0x20f3(%rip), %rsi      # 0x7aeb
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
incq 0x30(%rbx)
movq %rbx, %rdi
callq 0x5b48
jmp 0x5a7f
leaq -0x1(%r15), %rsi
movq %rbx, %rdi
callq 0x5fc4
cmpb $0x30, 0x59(%rbx)
jne 0x5a30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ef3
jmp 0x5a3d
cmpq $0x1, 0x18(%rbx)
jne 0x5a3d
cmpq %r15, 0x20(%rbx)
ja 0x5a23
movq %r14, %rdi
callq 0x4194
addq %r15, 0x30(%rbx)
testq %r12, %r12
jne 0x5a5f
cmpb $0x23, 0x58(%rbx)
jne 0x5a5f
cmpb $0x2d, 0x5c(%rbx)
jne 0x5a5f
decq %r15
jmp 0x5a6c
cmpq $0x0, 0x10(%rbx)
je 0x5a77
cmpb $0x2d, 0x5c(%rbx)
jne 0x5a77
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x2d, 0x5c(%rdi)
jne 0x5ab2
leaq 0x2046(%rip), %rsi      # 0x7aed
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
movq 0x10(%rbx), %rax
leaq 0x1ed6(%rip), %r14      # 0x7993
pushq $0x1
popq %r15
pushq $0x1
popq %r12
cmpq $0x2, %rax
jb 0x5b17
cmpb $0x30, 0x59(%rbx)
je 0x5b17
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
jmp 0x5ac5
cmpb $0x30, 0x59(%rbx)
jne 0x5b1d
leaq 0x1fee(%rip), %rsi      # 0x7aeb
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
cmpq $0x2, %rax
jae 0x5af0
cmpb $0x2d, 0x5c(%rbx)
je 0x5b35
leaq 0x1fc3(%rip), %rsi      # 0x7aed
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x1040
incq 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movb 0x5a(%rdi), %cl
testq %rax, %rax
je 0x5b76
cmpb $0x20, %cl
je 0x5b6d
cmpb $0x2b, 0x5b(%rbx)
jne 0x5b86
decq %rax
movq %rax, 0x10(%rbx)
jmp 0x5b86
testb %cl, %cl
jne 0x5b84
cmpb $0x0, 0x5b(%rbx)
je 0x5c23
xorl %eax, %eax
leaq 0x1e06(%rip), %r14      # 0x7993
pushq $0x1
popq %r15
pushq $0x1
popq %r12
testq %rax, %rax
je 0x5bbf
cmpb $0x2d, 0x5c(%rbx)
je 0x5bbf
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
jmp 0x5b95
cmpb $0x2b, 0x5b(%rbx)
jne 0x5bce
leaq 0x1f1d(%rip), %r14      # 0x7ae9
jmp 0x5bd4
cmpb $0x20, 0x5a(%rbx)
jne 0x5bea
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x1040
incq 0x30(%rbx)
movq 0x10(%rbx), %rax
leaq 0x1da2(%rip), %r14      # 0x7993
pushq $0x1
popq %r15
pushq $0x1
popq %r12
testq %rax, %rax
je 0x5c23
cmpb $0x2d, 0x5c(%rbx)
jne 0x5c23
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
movq 0x10(%rbx), %rax
decq %rax
movq %rax, 0x10(%rbx)
incq 0x30(%rbx)
jmp 0x5bf9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5672
movq %rax, %r12
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5332
movq %rax, %r14
movq %rax, %rdi
callq 0x431c
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5c70
orq 0x20(%rbx), %r12
je 0x5cee
cmpq %r15, 0x10(%rbx)
jbe 0x5c93
cmpb $0x2d, 0x5c(%rbx)
je 0x5c93
cmpq $0x1, %rax
je 0x5c88
cmpb $0x30, 0x59(%rbx)
je 0x5c93
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
cmpb $0x30, 0x59(%rbx)
jne 0x5c9f
cmpq %r15, 0x10(%rbx)
ja 0x5cac
cmpq $0x1, 0x18(%rbx)
jne 0x5cb7
cmpq %r15, 0x20(%rbx)
jbe 0x5cb7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ef3
movq %r14, %rdi
callq 0x4194
addq %r15, 0x30(%rbx)
cmpq %r15, 0x10(%rbx)
jbe 0x5cda
cmpb $0x2d, 0x5c(%rbx)
jne 0x5cda
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fc4
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x5b48
jmp 0x5ce2
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x5e(%rdi), %al
cmpb $0x66, %al
jne 0x5d29
cmpq $0x0, 0x18(%rbx)
je 0x5d23
movq 0x20(%rbx), %rcx
incq %rcx
jmp 0x5d26
pushq $0x7
popq %rcx
addq %rcx, %r14
cmpb $0x2d, 0x5c(%rbx)
jne 0x5d40
cmpq %r14, 0x10(%rbx)
jbe 0x5d40
cmpq $0x0, 0x18(%rbx)
je 0x5df2
cmpb $0x2b, 0x5b(%rbx)
jne 0x5d59
cmpq $0x0, 0x18(%rbx)
jne 0x5d59
xorl %ecx, %ecx
cmpl $0x1, 0x40(%rbx)
sete %cl
addq %rcx, %r14
cmpb $0x30, 0x59(%rbx)
jne 0x5d77
cmpb $0x20, 0x5a(%rbx)
jne 0x5d77
cmpq %r14, 0x10(%rbx)
jbe 0x5d77
xorl %ecx, %ecx
cmpl $0x1, 0x40(%rbx)
sete %cl
addq %rcx, %r14
cmpl $-0x1, 0x40(%rbx)
jne 0x5d8b
movq 0x20(%rbx), %rcx
incq %rcx
cmpq %rcx, %r14
sbbq $0x0, %r14
cmpb $0x66, %al
je 0x5dc6
cmpq $0x1, 0x18(%rbx)
jne 0x5dc6
leaq 0x1d4e(%rip), %r15      # 0x7aeb
pushq $0x1
popq %r12
pushq $0x1
popq %r13
cmpq %r14, 0x20(%rbx)
jbe 0x5df2
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
incq 0x30(%rbx)
decq 0x10(%rbx)
incq %r14
jmp 0x5da5
leaq 0x1d1e(%rip), %r15      # 0x7aeb
pushq $0x1
popq %r12
pushq $0x1
popq %r13
cmpq %r14, 0x10(%rbx)
jbe 0x5df2
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
incq 0x30(%rbx)
incq %r14
jmp 0x5dd5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x30, 0x59(%rdi)
jne 0x5e3f
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5e2e
cmpq %r14, 0x20(%rbx)
jb 0x5e7c
cmpb $0x70, 0x5e(%rbx)
jne 0x5e3f
leaq 0x2(%r14), %rcx
testq %rax, %rax
cmoveq %rcx, %r14
cmpq %r14, 0x20(%rbx)
jae 0x5e71
leaq 0x1c9f(%rip), %r15      # 0x7aeb
pushq $0x1
popq %r12
pushq $0x1
popq %r13
cmpq %r14, 0x10(%rbx)
jbe 0x5e7c
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
incq %r14
incq 0x30(%rbx)
jmp 0x5e54
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e8e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c42(%rip), %r15      # 0x7aeb
pushq $0x1
popq %r12
pushq $0x1
popq %r13
cmpq %r14, 0x20(%rbx)
jbe 0x5ee1
cmpq $0x0, 0x10(%rbx)
jne 0x5ec6
movq $0x1, 0x10(%rbx)
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
decq 0x10(%rbx)
incq %r14
incq 0x30(%rbx)
jmp 0x5eb1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x5e(%rdi), %eax
cmpl $0x58, %eax
je 0x5f34
cmpl $0x6f, %eax
je 0x5f34
cmpl $0x78, %eax
je 0x5f34
cmpl $0x75, %eax
jne 0x5f74
cmpb $0x30, 0x59(%rbx)
jne 0x5f74
cmpq $0x1, 0x18(%rbx)
jne 0x5f74
cmpq %r14, 0x20(%rbx)
jae 0x5f74
jmp 0x5fb1
cmpb $0x30, 0x59(%rbx)
jne 0x5f47
cmpq $0x1, 0x18(%rbx)
jne 0x5f47
cmpq %r14, 0x20(%rbx)
jb 0x5fb1
cmpb $0x2d, 0x5c(%rbx)
jne 0x5f5a
cmpq %r14, 0x10(%rbx)
jbe 0x5f5a
cmpq $0x0, 0x18(%rbx)
je 0x5fb1
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x5f74
cmpb $0x23, 0x58(%rbx)
jne 0x5f74
cmpq %r14, 0x20(%rbx)
leaq 0x2(%r14), %rax
cmovbeq %rax, %r14
cmpq %r14, 0x20(%rbx)
jae 0x5fa6
leaq 0x1b6a(%rip), %r15      # 0x7aeb
pushq $0x1
popq %r12
pushq $0x1
popq %r13
cmpq %r14, 0x10(%rbx)
jbe 0x5fb1
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
incq %r14
incq 0x30(%rbx)
jmp 0x5f89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e8e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zuocheng-liu[P]ae-memcached/src/ae.c
// Function: aeCreateEventLoop
aeEventLoop *aeCreateEventLoop(int setsize) {
    aeEventLoop *eventLoop;
    int i;

    if ((eventLoop = malloc(sizeof(*eventLoop))) == NULL) goto err;
    eventLoop->events = malloc(sizeof(aeFileEvent)*setsize);
    eventLoop->fired = malloc(sizeof(aeFiredEvent)*setsize);
    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
    eventLoop->setsize = setsize;
    eventLoop->lastTime = time(NULL);
    eventLoop->timeEventHead = NULL;
    eventLoop->timeEventNextId = 0;
    eventLoop->stop = 0;
    eventLoop->maxfd = -1;
    eventLoop->beforesleep = NULL;
    if (aeApiCreate(eventLoop) == -1) goto err;
    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
    return eventLoop;

err:
    if (eventLoop) {
        free(eventLoop->events);
        free(eventLoop->fired);
        free(eventLoop);
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
pushq $0x48
popq %rdi
callq 0x22c0
testq %rax, %rax
je 0x2672
movq %rax, %rbx
movslq %r14d, %rbp
movq %rbp, %rdi
shlq $0x5, %rdi
callq 0x22c0
movq %rax, %r15
movq %rax, 0x18(%rbx)
leaq (,%rbp,8), %rdi
callq 0x22c0
movq %rax, %r12
movq %rax, 0x20(%rbx)
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x265a
movl %r14d, 0x4(%rbx)
xorl %edi, %edi
callq 0x22b0
movq %rax, 0x10(%rbx)
andq $0x0, 0x28(%rbx)
andq $0x0, 0x8(%rbx)
andl $0x0, 0x30(%rbx)
orl $-0x1, (%rbx)
andq $0x0, 0x40(%rbx)
pushq $0x10
popq %rdi
callq 0x22c0
testq %rax, %rax
je 0x265a
movq %rax, %r13
imulq $0xc, %rbp, %rdi
callq 0x22c0
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x2652
movq %rax, %rbp
movl $0x400, %edi            # imm = 0x400
callq 0x23f0
movl %eax, (%r13)
cmpl $-0x1, %eax
je 0x264a
movq %r13, 0x38(%rbx)
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
shlq $0x5, %r14
cmpq %rax, %r14
je 0x2674
andl $0x0, (%r15,%rax)
addq $0x20, %rax
jmp 0x263a
movq %rbp, %rdi
callq 0x2030
movq %r13, %rdi
callq 0x2030
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq