LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/source/sort_paths.c
// Function: sort_paths
void	sort_paths(t_info *info)
{
	int		i;

	i = -1;
	while (info->path_n_1 > 1 && info->valid_indexes[++i + 1][0] != EMPTY)
	{
		if (info->rooms[info->valid_indexes[i + 1][0]]->length
		< info->rooms[info->valid_indexes[i][0]]->length)
		{
			swap_paths(info, i, 1);
			i = -1;
		}
	}
	i = -1;
	while (info->path_n_2 > 1 && info->valid_indexes_2[++i + 1][0] != EMPTY)
	{
		if (info->rooms[info->valid_indexes_2[i + 1][0]]->length_2
		< info->rooms[info->valid_indexes_2[i][0]]->length_2)
		{
			swap_paths(info, i, 2);
			i = -1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x1060(%rcx)
movb %al, -0xd(%rbp)
jle 0x68dc
movq -0x8(%rbp), %rax
movq 0x1898(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x68e5
jmp 0x6959
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x1898(%rcx), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x44(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x1898(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x44(%rcx), %eax
jge 0x6954
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x65d0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x68a3
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x1064(%rcx)
movb %al, -0xe(%rbp)
jle 0x6999
movq -0x8(%rbp), %rax
movq 0x18a0(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, (%rax)
setne %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
testb $0x1, %al
jne 0x69a2
jmp 0x6a16
movq -0x8(%rbp), %rax
movq 0x18a8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18a0(%rcx), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl 0x48(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x18a8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x18a0(%rdx), %rdx
movslq -0xc(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x48(%rcx), %eax
jge 0x6a11
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x65d0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x6960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	int		res;
	int		sign;

	res = 0;
	sign = 1;
	while (*str && (*str == '\r' || *str == '\n' || *str == '\t' ||
					*str == '\f' || *str == '\v' || *str == ' '))
		str++;
	if (str[0] == '-')
		sign = -1;
	if (*str == '+' || *str == '-')
		str++;
	while (*str && *str >= '0' && *str <= '9')
	{
		res = res * 10 + (*str - 48);
		if (res > 999999)
			return (-1);
		str++;
	}
	if (*str && !ft_isdigit(*str))
		exit_error_no_info("ERROR: Coordinate not Int!");
	return (res * sign);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x6ab6
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x1a(%rbp)
je 0x6ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1a(%rbp)
je 0x6ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x1a(%rbp)
je 0x6ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x1a(%rbp)
je 0x6ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x1a(%rbp)
je 0x6ab0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x6abf
jmp 0x6ad0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6a3a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6ae3
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x6afb
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6b07
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6b09
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1b(%rbp)
je 0x6b3b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x1b(%rbp)
jl 0x6b3b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x6b44
jmp 0x6b77
imull $0xa, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0xf423f, -0x14(%rbp)   # imm = 0xF423F
jle 0x6b69
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6baa
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6b09
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6ba0
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x6bc0
cmpl $0x0, %eax
jne 0x6ba0
leaq 0x5e0a(%rip), %rdi      # 0xc9a5
callq 0x4f30
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_itoa.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	size_t		count;
	long		nbr;
	char		*str;

	nbr = (long)n;
	count = ft_nbrcount((intmax_t)n);
	if (!(str = ft_strnew(count)))
		return (NULL);
	count--;
	if (nbr == 0)
		str[0] = '0';
	if (nbr < 0)
	{
		str[0] = '-';
		nbr *= -1;
	}
	while (nbr > 0)
	{
		str[count] = nbr % 10 + '0';
		nbr /= 10;
		count--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x7610
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7220
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6c5d
movq $0x0, -0x8(%rbp)
jmp 0x6cdc
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c77
movq -0x28(%rbp), %rax
movb $0x30, (%rax)
cmpq $0x0, -0x20(%rbp)
jge 0x6c8e
movq -0x28(%rbp), %rax
movb $0x2d, (%rax)
imulq $-0x1, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6c90
cmpq $0x0, -0x20(%rbp)
jle 0x6cd4
movq -0x20(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
addq $0x30, %rdx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6c90
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putendl.c
// Function: ft_putendl
void	ft_putendl(char const *s)
{
	int len;

	if (s)
	{
		len = ft_strlen(s);
		write(1, s, len);
		ft_putchar('\n');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6d5b
movq -0x8(%rbp), %rdi
callq 0x71c0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
movl $0x1, %edi
callq 0x1040
movl $0xa, %edi
callq 0x6cf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char const *s, int fd)
{
	int len;

	if (s)
	{
		len = ft_strlen(s);
		write(fd, s, len);
		ft_putchar_fd('\n', fd);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6daf
movq -0x8(%rbp), %rdi
callq 0x71c0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x1040
movl -0xc(%rbp), %esi
movl $0xa, %edi
callq 0x7dd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_putnbr.c
// Function: ft_putnbr
void	ft_putnbr(int n)
{
	long	k;

	k = n;
	if (n < 0)
	{
		ft_putchar('-');
		k = k * -1;
	}
	if (k / 10 > 0)
		ft_putnbr(k / 10);
	ft_putchar('0' + k % 10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x6dec
movl $0x2d, %edi
callq 0x6cf0
imulq $-0x1, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
cmpq $0x0, %rax
jle 0x6e15
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movl %eax, %edi
callq 0x6dc0
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
addq $0x30, %rdx
movb %dl, %al
movsbl %al, %edi
callq 0x6cf0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	int i;

	i = 0;
	while (s[i])
	{
		if (s[i] == c)
			return ((char*)(s + i));
		i++;
	}
	if (s[i] == '\0' && c == '\0')
		return ((char*)(s + i));
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x6ecd
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x14(%rbp), %eax
jne 0x6ec2
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6efd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e92
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x6ef5
cmpl $0x0, -0x14(%rbp)
jne 0x6ef5
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6efd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int	i;

	i = 0;
	while (s1[i] && s2[i] && s1[i] == s2[i])
		++i;
	return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x6f6f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x6f6f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x6f78
jmp 0x6f83
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6f23
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	int		i;
	int		c;
	char	*dst;

	i = 0;
	c = 0;
	while (s1[i])
		i++;
	dst = (char*)ft_memalloc(sizeof(*dst) * (i + 1));
	if (!dst)
		return (NULL);
	while (c < i)
	{
		dst[c] = s1[c];
		c++;
	}
	dst[c] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x7003
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6fea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x7d60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x702a
movq $0x0, -0x8(%rbp)
jmp 0x7069
jmp 0x702c
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7055
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x702c
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strequ.c
// Function: ft_strequ
int		ft_strequ(char const *s1, char const *s2)
{
	while (s1[0] != '\0' && !(*(s1) ^ *(s2)))
	{
		s1++;
		s2++;
	}
	return (!(*(s1) ^ *(s2)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x70b8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x70c1
jmp 0x70db
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x708c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	int		a;
	int		b;
	int		x;
	char	*joint;

	if (!s1 || !s2)
		return (NULL);
	a = ft_strlen(s1);
	b = ft_strlen(s2);
	x = 0;
	if (!(joint = ft_strnew(a + b)))
		return (NULL);
	joint = ft_strcpy(joint, s1);
	while (x < b)
	{
		joint[a + x] = s2[x];
		x++;
	}
	return (joint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x711e
cmpq $0x0, -0x18(%rbp)
jne 0x712b
movq $0x0, -0x8(%rbp)
jmp 0x71b3
movq -0x10(%rbp), %rdi
callq 0x71c0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x71c0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rdi
callq 0x7220
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x716c
movq $0x0, -0x8(%rbp)
jmp 0x71b3
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e00
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x71ab
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x717d
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t	i;

	i = 0;
	if (!s || s == NULL)
		return (0);
	while (s[i] != '\0')
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x71de
cmpq $0x0, -0x10(%rbp)
jne 0x71e8
movq $0x0, -0x8(%rbp)
jmp 0x7211
jmp 0x71ea
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x7209
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x71ea
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strnew.c
// Function: ft_strnew
char	*ft_strnew(size_t size)
{
	char	*str;

	str = (char*)ft_memalloc(size + 1);
	if (!str)
		return (NULL);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x7d60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x724e
movq $0x0, -0x8(%rbp)
jmp 0x7256
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsplit.c
// Function: ft_strsplit
char		**ft_strsplit(char const *s, char c)
{
	unsigned int	i;
	size_t			start;
	char			**str;
	int				y;

	y = 0;
	i = 0;
	start = 0;
	if (!s)
		return (NULL);
	if (!(str = (char**)ft_memalloc(sizeof(char*) * (ft_count(s, (int)c) + 1))))
		return (NULL);
	while (y < ft_count(s, (int)c))
	{
		while (s[i] == (int)c)
			i++;
		start = i;
		while (s[i] && s[i] != (int)c)
			i++;
		if (!(str[y] = ft_strsub(s, start, (i - start))))
			return (NULL);
		i++;
		y++;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x729c
movq $0x0, -0x8(%rbp)
jmp 0x73ab
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x73c0
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x7d60
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x72cf
movq $0x0, -0x8(%rbp)
jmp 0x73ab
jmp 0x72d1
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x73c0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x73a3
jmp 0x72f3
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7311
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x72f3
movl -0x18(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x7344
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x734d
jmp 0x7358
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7318
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movl -0x18(%rbp), %eax
movl %eax, %edx
subq -0x20(%rbp), %rdx
callq 0x7510
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x738c
movq $0x0, -0x8(%rbp)
jmp 0x73ab
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x72d1
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsplit.c
// Function: ft_count
static int	ft_count(const char *str, int d)
{
	int	i;
	int	count;

	i = 0;
	count = 0;
	while (str[i])
	{
		if ((str[i] != d && str[i + 1] == d) ||
				(str[i] != d && str[i + 1] == '\0'))
			count++;
		i++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x7449
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0xc(%rbp), %eax
je 0x740e
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl -0xc(%rbp), %eax
je 0x7435
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0xc(%rbp), %eax
je 0x743e
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x743e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x73d9
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strstr.c
// Function: ft_strstr
char	*ft_strstr(const char *haystack, const char *needle)
{
	int	i;
	int	t;

	i = 0;
	t = 0;
	if (needle[t] == '\0')
		return ((char*)haystack);
	while (haystack[i])
	{
		t = 0;
		while (haystack[i + t] == needle[t])
		{
			t++;
			if (needle[t] == '\0')
				return ((char*)haystack + (i));
		}
		i++;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x7485
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x74fd
jmp 0x7487
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x74f5
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x74ea
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x74e8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x74fd
jmp 0x749c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7487
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_strsub.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char			*sub;
	size_t			i;
	unsigned int	index;

	if (!s)
		return (NULL);
	sub = (char*)malloc(sizeof(char) * (len + 1));
	i = 0;
	index = 0;
	if (!sub || start > ft_strlen(s))
		return (NULL);
	while (s[start] != '\0' && i < len)
	{
		sub[index] = s[start];
		index++;
		start++;
		i++;
	}
	sub[index] = '\0';
	return (sub);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7537
movq $0x0, -0x8(%rbp)
jmp 0x75fd
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1070
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x757e
movl -0x14(%rbp), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jbe 0x7588
movq $0x0, -0x8(%rbp)
jmp 0x75fd
jmp 0x758a
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x75ad
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x75b6
jmp 0x75ea
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x758a
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/libft/ft_nbrcount.c
// Function: ft_nbrcount
size_t	ft_nbrcount(intmax_t nbr)
{
	size_t count;

	count = 0;
	if (nbr == 0)
		return (1);
	if (nbr < 0)
	{
		nbr *= -1;
		count++;
	}
	while (nbr > 0)
	{
		nbr /= 10;
		count++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7631
movq $0x1, -0x8(%rbp)
jmp 0x767e
cmpq $0x0, -0x10(%rbp)
jge 0x764d
imulq $-0x1, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x764f
cmpq $0x0, -0x10(%rbp)
jle 0x7676
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x764f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: set_ids
t_tags	*set_ids(t_tags *ids)
{
	ids->i = 0;
	ids->printed_chars = 0;
	ids->flag = "#0 +-";
	ids->arg_type = "%cCspdDiouxXf";
	ids->modifiers = "hlL";
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq 0x5305(%rip), %rcx      # 0xc9c0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x52fc(%rip), %rcx      # 0xc9c6
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq 0x52fb(%rip), %rcx      # 0xc9d4
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: create_tmp_ids
t_tags	*create_tmp_ids(t_tags *ids)
{
	ids->minwth = 0;
	ids->period = 0;
	ids->maxwth = 0;
	ids->negative = 1;
	ids->double_len = 0;
	ids->current_type = '\0';
	ids->current_flag[0] = '\0';
	ids->current_flag[1] = '\0';
	ids->current_flag[2] = '\0';
	ids->current_flag[3] = '\0';
	ids->current_flag[4] = '\0';
	ids->current_flag[5] = '\0';
	ids->current_modifier[0] = '\0';
	ids->current_modifier[1] = '\0';
	ids->current_modifier[2] = '\0';
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5e(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x59(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5a(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5b(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5d(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5f(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x61(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/ft_printf.c
// Function: ft_printf
int		ft_printf(const char *format, ...)
{
	t_tags	*ids;

	if (!(ids = (t_tags*)malloc(sizeof(t_tags))))
		return (-1);
	ids->format = format;
	set_ids(ids);
	if (format)
	{
		va_start(ids->arguments, format);
		read_format(ids);
		va_end(ids->arguments);
	}
	free(ids);
	return (ids->printed_chars);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x77c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x80, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x7809
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7871
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x7690
cmpq $0x0, -0x10(%rbp)
je 0x785d
movq -0x18(%rbp), %rax
addq $0x68, %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x18(%rbp), %rdi
callq 0x7980
movq -0x18(%rbp), %rax
addq $0x68, %rax
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/set_tags_and_print.c
// Function: read_arg_type
t_tags			*read_arg_type(t_tags *ids)
{
	if (ids->current_type == 'c')
		print_c(ids);
	if (ids->current_type == 's')
		print_s(ids);
	if (ids->current_type == 'p')
		print_p(ids);
	if (ids->current_type == 'd' || ids->current_type == 'i')
		print_d(ids);
	if (ids->current_type == '%')
		print_percent(ids);
	if (ids->current_type == 'o')
		print_o(ids);
	if (ids->current_type == 'u')
		print_u(ids);
	if (ids->current_type == 'x' || ids->current_type == 'X')
		print_x(ids);
	if (ids->current_type == 'f')
		print_f(ids);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x63, %eax
jne 0x78a2
movq -0x8(%rbp), %rdi
callq 0x7e60
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x73, %eax
jne 0x78b8
movq -0x8(%rbp), %rdi
callq 0x8800
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x70, %eax
jne 0x78ce
movq -0x8(%rbp), %rdi
callq 0x85e0
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x64, %eax
je 0x78e8
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x69, %eax
jne 0x78f1
movq -0x8(%rbp), %rdi
callq 0x9c20
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x25, %eax
jne 0x7907
movq -0x8(%rbp), %rdi
callq 0xa1e0
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x6f, %eax
jne 0x791d
movq -0x8(%rbp), %rdi
callq 0x9ed0
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x75, %eax
jne 0x7933
movq -0x8(%rbp), %rdi
callq 0xa500
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x78, %eax
je 0x794d
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x58, %eax
jne 0x7956
movq -0x8(%rbp), %rdi
callq 0x89a0
movq -0x8(%rbp), %rax
movsbl 0x5e(%rax), %eax
cmpl $0x66, %eax
jne 0x796c
movq -0x8(%rbp), %rdi
callq 0x7f40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x7a7e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x7a16
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x7a16
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x7a79
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x7a39
movq -0x8(%rbp), %rdi
callq 0x7a90
jmp 0x7a77
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x7a79
jmp 0x798c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/set_tags_and_print.c
// Function: call_identifier_readers
static t_tags	*call_identifier_readers(t_tags *ids)
{
	ids->i++;
	create_tmp_ids(ids);
	scan_flags(ids);
	scan_minwth(ids);
	scan_period_maxwth(ids);
	scan_modifier(ids);
	scan_arg_type(ids);
	read_arg_type(ids);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x76f0
movq -0x8(%rbp), %rdi
callq 0x9000
movq -0x8(%rbp), %rdi
callq 0x8f30
movq -0x8(%rbp), %rdi
callq 0x8e20
movq -0x8(%rbp), %rdi
callq 0x8d20
movq -0x8(%rbp), %rdi
callq 0x8c80
movq -0x8(%rbp), %rdi
callq 0x7880
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7b25
cmpl $0x1300, -0x8(%rbp)     # imm = 0x1300
jg 0x7b25
cmpl $0x0, -0x8(%rbp)
jge 0x7b31
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c4f
movslq -0x8(%rbp), %rcx
leaq 0x8534(%rip), %rax      # 0x10070
cmpq $0x0, (%rax,%rcx,8)
jne 0x7b6f
xorl %eax, %eax
movl %eax, %edi
callq 0x7220
movslq -0x8(%rbp), %rdx
leaq 0x8519(%rip), %rcx      # 0x10070
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x7b6d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c4f
jmp 0x7b6f
jmp 0x7b71
movl -0x8(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x1060
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x7bfc
movslq -0x24(%rbp), %rax
movb $0x0, -0x12(%rbp,%rax)
movslq -0x8(%rbp), %rcx
leaq 0x84d2(%rip), %rax      # 0x10070
movq (%rax,%rcx,8), %rdi
leaq -0x12(%rbp), %rsi
callq 0x7100
movq %rax, -0x20(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x84b6(%rip), %rax      # 0x10070
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x20(%rbp), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x849e(%rip), %rax      # 0x10070
movq %rdx, (%rax,%rcx,8)
movslq -0x8(%rbp), %rcx
leaq 0x848f(%rip), %rax      # 0x10070
movq (%rax,%rcx,8), %rdi
movl $0xa, %esi
callq 0x6e80
cmpq $0x0, %rax
je 0x7bf7
jmp 0x7bfc
jmp 0x7b71
cmpl $0x0, -0x24(%rbp)
jge 0x7c0b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7c4f
cmpl $0x0, -0x24(%rbp)
jne 0x7c31
movslq -0x8(%rbp), %rcx
leaq 0x8454(%rip), %rax      # 0x10070
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7c31
movl $0x0, -0x4(%rbp)
jmp 0x7c4f
movslq -0x8(%rbp), %rax
leaq 0x8434(%rip), %rdi      # 0x10070
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7c60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/get_next_line.c
// Function: rest_of_line
static int	rest_of_line(char **str, char **line)
{
	size_t		i;
	char		*next;

	i = 0;
	while (str[0][i] != '\n' && str[0][i] != '\0')
		i++;
	if (str[0][i] == '\n')
	{
		*line = ft_strsub(str[0], 0, i);
		next = ft_strdup(str[0] + (i + 1));
		free(str[0]);
		str[0] = next;
	}
	else
	{
		*line = ft_strsub(str[0], 0, i);
		ft_strdel(&str[0]);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x7ca9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x7cb2
jmp 0x7cc0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7c78
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x7d24
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x7510
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq $0x1, %rax
addq %rax, %rdi
callq 0x6fd0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7d49
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x7510
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x7d89
movq $0x0, -0x8(%rbp)
jmp 0x7dbd
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7db5
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7d91
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x18(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x28, %eax
ja 0x7e9f
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x20(%rbp)
jmp 0x7eb6
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x7ee5
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x0, %eax
jne 0x7ee5
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xac00
movl $0x1, %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x7f2e
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x0, %eax
je 0x7f2e
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xac00
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_f.c
// Function: print_f
t_tags				*print_f(t_tags *ids)
{
	long double	nbr;

	nbr = cast_double(ids, 0);
	nbr = nbr * ids->negative;
	nbr = approximize_nbr(ids, nbr);
	print_front(ids, nbr);
	if (ids->maxwth > 0 || (ids->maxwth == 0 && ids->period == 0))
	{
		write(1, ".", 1);
		ids->printed_chars++;
		print_decimals
(ids, nbr - (long long)nbr, ids->maxwth == 0 ? 6 : ids->maxwth);
	}
	else if (ids->current_flag[0] == '#' && ids->period == 1
	&& ids->maxwth == 0)
	{
		write(1, ".", 1);
		ids->printed_chars++;
	}
	if (ids->current_flag[4] == '-' &&
	((ids->period == 0 && ids->double_len + 7 < ids->minwth) ||
	(ids->double_len + 1 + ids->maxwth < ids->minwth)))
		minwth_print(ids, ids->double_len);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rsp, %rax
fldz
fstpt (%rax)
callq 0x9580
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x24(%rbp)
fildl -0x24(%rbp)
fmulp %st, %st(1)
fstpt -0x20(%rbp)
movq -0x8(%rbp), %rdi
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x8110
fstpt -0x20(%rbp)
movq -0x8(%rbp), %rdi
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x8210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
ja 0x7fc2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8056
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8056
leaq 0x4a2f(%rip), %rsi      # 0xc9f8
movl $0x1, %edi
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
incq %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
fldt -0x20(%rbp)
fnstcw -0x3a(%rbp)
movzwl -0x3a(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x3c(%rbp)
fldcw -0x3c(%rbp)
fld %st(0)
fistpll -0x38(%rbp)
fldcw -0x3a(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
fildll -0x30(%rbp)
fsubrp %st, %st(1)
fstpt -0x48(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x8033
movl $0x6, %eax
movq %rax, -0x58(%rbp)
jmp 0x803f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
fldt -0x48(%rbp)
movq -0x58(%rbp), %rsi
movq %rsp, %rax
fstpt (%rax)
callq 0x8380
jmp 0x80a1
movq -0x8(%rbp), %rax
movsbl 0x58(%rax), %eax
cmpl $0x23, %eax
jne 0x809f
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x809f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x809f
movl $0x1, %edi
leaq 0x4973(%rip), %rsi      # 0xc9f8
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x80a1
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
jne 0x80fe
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x80cf
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x7, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x80ed
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
addq 0x20(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x80fe
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0xac00
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_f.c
// Function: approximize_nbr
static long double	approximize_nbr(t_tags *ids, long double nbr)
{
	long double		factor;
	size_t			count;

	factor = ids->maxwth == 0 && ids->period == 1 ? 0.499 : 0.500;
	count = ids->maxwth == 0 ? 6 : ids->maxwth;
	if (ids->period == 1 && ids->maxwth == 0)
		count = 0;
	while (count > 0 && count--)
		factor /= 10;
	nbr += factor;
	return (nbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x41(%rbp)
jne 0x813d
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
movsd 0x488e(%rip), %xmm0     # 0xc9d8
movsd 0x488e(%rip), %xmm1     # 0xc9e0
movsd %xmm1, -0x58(%rbp)
movsd %xmm0, -0x50(%rbp)
jne 0x8168
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
fldl -0x40(%rbp)
fstpt -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x818e
movl $0x6, %eax
movq %rax, -0x60(%rbp)
jmp 0x819a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x81c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x81c0
movq $0x0, -0x38(%rbp)
jmp 0x81c2
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x61(%rbp)
jbe 0x81e7
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x81f0
jmp 0x8200
fldt -0x30(%rbp)
flds 0x47f7(%rip)            # 0xc9f0
fdivrp %st, %st(1)
fstpt -0x30(%rbp)
jmp 0x81c2
fldt -0x30(%rbp)
fldt -0x20(%rbp)
faddp %st, %st(1)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_f.c
// Function: print_front
static t_tags		*print_front(t_tags *ids, long double nbr)
{
	intmax_t	casted;
	size_t		len;
	char		*front;

	casted = (long long)nbr;
	front = imaxtoa_base(casted, 10);
	len = ft_strlen(front);
	print_space_flag(ids, len);
	if (ids->current_flag[4] != '-' &&
	((ids->period == 0 && len + 7 < ids->minwth)
	|| (len + 1 + ids->maxwth < ids->minwth)))
		minwth_print(ids, len);
	if (ids->current_flag[1] == '0' && len < ids->minwth)
		put_zero_df(ids, len);
	if (ids->negative == -1 && ids->current_flag[3] != '+')
	{
		write(1, "-", 1);
		ids->printed_chars++;
	}
	if (ids->current_flag[3] == '+')
		put_plusminus(ids, ids->negative);
	ft_putstr(front);
	ids->printed_chars += len;
	free(front);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fnstcw -0x42(%rbp)
movzwl -0x42(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x44(%rbp)
fldcw -0x44(%rbp)
fistpll -0x40(%rbp)
fldcw -0x42(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0xa, %esi
callq 0x9480
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x71c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8470
movq -0x8(%rbp), %rax
movsbl 0x5c(%rax), %eax
cmpl $0x2d, %eax
je 0x82c3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x829c
movq -0x30(%rbp), %rax
addq $0x7, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x82b6
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
addq 0x20(%rcx), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x82c3
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xac00
movq -0x8(%rbp), %rax
movsbl 0x59(%rax), %eax
cmpl $0x30, %eax
jne 0x82eb
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x82eb
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa6c0
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x40(%rax)
jne 0x8328
movq -0x8(%rbp), %rax
movsbl 0x5b(%rax), %eax
cmpl $0x2b, %eax
je 0x8328
movl $0x1, %edi
leaq 0x46b6(%rip), %rsi      # 0xc9c4
movl $0x1, %edx
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movsbl 0x5b(%rax), %eax
cmpl $0x2b, %eax
jne 0x8346
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x40(%rax), %rsi
callq 0x9bb0
movq -0x38(%rbp), %rdi
callq 0x6e40
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)