LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x1060(%rdi)
jl 0x4464
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x1898(%rbx), %rax
movslq %esi, %rcx
movq 0x10(%rax,%rcx,8), %rcx
movslq (%rcx), %rcx
cmpq $-0x1, %rcx
je 0x4464
incl %esi
movq 0x18a8(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x44(%rcx), %ecx
movslq %esi, %rdi
movq (%rax,%rdi,8), %rax
movslq (%rax), %rax
movq (%rdx,%rax,8), %rax
cmpl 0x44(%rax), %ecx
jge 0x445b
movq %rbx, %rdi
movl $0x1, %edx
callq 0x4260
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x1, 0x1060(%rbx)
jg 0x440e
cmpl $0x2, 0x1064(%rbx)
jl 0x44c8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x18a0(%rbx), %rax
movslq %esi, %rcx
movq 0x10(%rax,%rcx,8), %rcx
movslq (%rcx), %rcx
cmpq $-0x1, %rcx
je 0x44c8
incl %esi
movq 0x18a8(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
movl 0x48(%rcx), %ecx
movslq %esi, %rdi
movq (%rax,%rdi,8), %rax
movslq (%rax), %rax
movq (%rdx,%rax,8), %rax
cmpl 0x48(%rax), %ecx
jge 0x44bf
movq %rbx, %rdi
movl $0x2, %edx
callq 0x4260
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpl $0x1, 0x1064(%rbx)
jg 0x4472
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movzbl (%rdi), %ebx
leal -0x9(%rbx), %eax
cmpl $0x5, %eax
jae 0x44e7
incq %rdi
jmp 0x44d7
cmpl $0x20, %ebx
je 0x44e2
cmpl $0x2b, %ebx
je 0x44f6
cmpl $0x2d, %ebx
jne 0x44f9
incq %rdi
movb (%rdi), %al
leal -0x30(%rax), %ecx
xorl %r14d, %r14d
cmpb $0x9, %cl
ja 0x452f
incq %rdi
xorl %r14d, %r14d
leal (%r14,%r14,4), %ecx
addb $-0x30, %al
movzbl %al, %eax
leal (%rax,%rcx,2), %r14d
cmpl $0xf423f, %r14d         # imm = 0xF423F
jg 0x4559
movb (%rdi), %al
leal -0x30(%rax), %ecx
incq %rdi
cmpb $0x9, %cl
jbe 0x450c
testb %al, %al
je 0x454b
movsbl %al, %edi
callq 0x4564
testl %eax, %eax
jne 0x454b
leaq 0x34db(%rip), %rdi      # 0x7a21
callq 0x34ac
movl %r14d, %eax
negl %eax
cmpl $0x2d, %ebx
cmovnel %r14d, %eax
jmp 0x455e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %r15
movq %r15, %rdi
callq 0x4ad8
movq %rax, %r14
movq %rax, %rdi
callq 0x48f4
testq %rax, %rax
je 0x4613
movq %rax, %rcx
movq %r15, %rsi
negq %rsi
cmovsq %r15, %rsi
testl %r15d, %r15d
jg 0x45d3
sete %al
movzbl %al, %eax
leal (%rax,%rax,2), %eax
addl $0x2d, %eax
movb %al, (%rcx)
testl %ebx, %ebx
je 0x4615
leaq (%r14,%rcx), %rdi
decq %rdi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %esi, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rdi)
decq %rdi
cmpq $0x9, %rsi
movq %rdx, %rsi
ja 0x45e8
jmp 0x4615
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x467b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x48d0
movslq %eax, %rdx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1040
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4624
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x46af
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x48d0
movslq %eax, %rdx
movl %ebx, %edi
movq %r14, %rsi
callq 0x1040
movl $0xa, %edi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f28
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movslq %edi, %rbx
testl %ebx, %ebx
jns 0x46ca
movl $0x2d, %edi
callq 0x4624
negq %rbx
cmpq $0xa, %rbx
jl 0x46ec
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rbx, %rax
mulq %rcx
movq %rdx, %rdi
shrq $0x3, %rdi
callq 0x46b0
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
movq %rbx, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
shrl $0x2, %edx
addl %eax, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %eax
subl %eax, %ebx
addb $0x30, %bl
movsbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4624
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x4768
movsbl %cl, %ecx
cmpl %esi, %ecx
je 0x4775
movb 0x1(%rdi,%rax), %cl
incq %rax
jmp 0x4754
addq %rax, %rdi
xorl %eax, %eax
testl %esi, %esi
cmoveq %rdi, %rax
jmp 0x477b
addq %rax, %rdi
movq %rdi, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %al
xorl %ecx, %ecx
testb %al, %al
je 0x479a
cmpb (%rsi,%rcx), %al
jne 0x479a
movb 0x1(%rdi,%rcx), %al
incq %rcx
jmp 0x4788
movzbl %al, %eax
movzbl (%rsi,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x47d9
movl %r14d, %edi
callq 0x4ef4
testq %rax, %rax
je 0x47fb
cmpq $0x1, %r14
jne 0x47ff
xorl %ecx, %ecx
jmp 0x4814
xorl %eax, %eax
jmp 0x4818
decq %r14
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x4804
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rdi), %cl
testb %cl, %cl
je 0x483d
incq %rdi
cmpb (%rsi), %cl
jne 0x483d
incq %rsi
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x482d
xorl %eax, %eax
cmpb (%rsi), %cl
sete %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x48c0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x48d0
movq %rax, %r12
movq %rbx, %rdi
callq 0x48d0
movq %rax, %r14
addl %r12d, %eax
movslq %eax, %rdi
callq 0x48f4
testq %rax, %rax
je 0x48c3
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f4c
testl %r14d, %r14d
jle 0x48c5
movslq %r12d, %rdx
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq %rax, %rcx
addq %rdx, %rcx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r14
jne 0x48ae
jmp 0x48c5
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x49ab
movl %esi, %ebx
movq %rdi, %r14
movsbl %bl, %r12d
movl %r12d, %esi
callq 0x49c0
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x4ef4
testq %rax, %rax
je 0x49ab
movq %rax, %r15
movq %r14, %rdi
movl %r12d, %esi
callq 0x49c0
testl %eax, %eax
jle 0x49ae
movl %r12d, -0x2c(%rbp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movl %r12d, %esi
movl %esi, %eax
incl %esi
cmpb %bl, (%r14,%rax)
je 0x495f
decl %esi
movl %esi, %r12d
movl %r12d, %edx
movb (%r14,%rdx), %cl
incl %r12d
testb %cl, %cl
je 0x4980
cmpb %bl, %cl
jne 0x496e
subq %rax, %rdx
movq %r14, %rdi
callq 0x4a48
movq %rax, (%r15,%r13,8)
testq %rax, %rax
je 0x49ab
incq %r13
movq %r14, %rdi
movl -0x2c(%rbp), %esi
callq 0x49c0
cltq
cmpq %rax, %r13
jl 0x495c
jmp 0x49ae
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rdi), %cl
testb %cl, %cl
je 0x49f5
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
cmpl %esi, %ecx
je 0x49ea
movsbl (%rdi), %edx
cmpl %esi, %edx
jne 0x49e1
incl %eax
jmp 0x49ea
cmpl %esi, %ecx
je 0x49ea
cmpb $0x0, (%rdi)
je 0x49dd
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x49cf
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, (%rsi)
je 0x4a40
cmpb $0x0, (%rdi)
je 0x4a44
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rdi, %rcx
xorl %edx, %edx
xorl %r8d, %r8d
movb (%rcx,%r8), %r9b
cmpb (%rsi,%r8), %r9b
jne 0x4a28
cmpb $0x0, 0x1(%rsi,%r8)
leaq 0x1(%r8), %r8
jne 0x4a10
jmp 0x4a38
incq %rcx
cmpb $0x0, 0x1(%rdi,%rdx)
leaq 0x1(%rdx), %rdx
jne 0x4a0d
jmp 0x4a3e
addq %rdx, %rdi
movq %rdi, %rax
popq %rbp
retq
movq %rdi, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a85
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leaq 0x1(%rdx), %rdi
callq 0x1080
testq %rax, %rax
je 0x4a85
movq %rax, %rbx
movl %r15d, %r13d
movq %r12, %rdi
callq 0x48d0
cmpq %r13, %rax
jae 0x4a99
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb (%r12,%r13), %al
testb %al, %al
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0x4ad0
incl %r15d
xorl %ecx, %ecx
movl %ecx, %edx
movl %ecx, %esi
movb %al, (%rbx,%rsi)
incq %rcx
leal (%r15,%rdx), %eax
movb (%r12,%rax), %al
testb %al, %al
je 0x4acc
cmpq %r14, %rcx
jb 0x4ab1
movl %ecx, %eax
jmp 0x4ad2
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
jmp 0x4a87
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x4b11
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
shrq $0x3f, %rdi
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
incq %rdi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x4af9
jmp 0x4b16
movl $0x1, %edi
movq %rdi, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
leaq 0x2f0b(%rip), %rcx      # 0x7a3c
movq %rcx, 0x8(%rdi)
leaq 0x2f06(%rip), %rcx      # 0x7a42
movq %rcx, 0x48(%rdi)
leaq 0x2f09(%rip), %rcx      # 0x7a50
movq %rcx, 0x50(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r14
movq %rsi, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rcx, -0xa8(%rbp)
movq %r8, -0xa0(%rbp)
movq %r9, -0x98(%rbp)
testb %al, %al
je 0x4bd3
movaps %xmm0, -0x90(%rbp)
movaps %xmm1, -0x80(%rbp)
movaps %xmm2, -0x70(%rbp)
movaps %xmm3, -0x60(%rbp)
movaps %xmm4, -0x50(%rbp)
movaps %xmm5, -0x40(%rbp)
movaps %xmm6, -0x30(%rbp)
movaps %xmm7, -0x20(%rbp)
movl $0x80, %edi
callq 0x1080
testq %rax, %rax
je 0x4c4b
movq %rax, %rbx
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
leaq 0x2e46(%rip), %rax      # 0x7a3c
movq %rax, 0x8(%rbx)
leaq 0x2e41(%rip), %rax      # 0x7a42
movq %rax, 0x48(%rbx)
leaq 0x2e44(%rip), %rax      # 0x7a50
movq %rax, 0x50(%rbx)
testq %r14, %r14
je 0x4c3e
leaq -0xc0(%rbp), %rax
movq %rax, 0x78(%rbx)
leaq 0x10(%rbp), %rax
movq %rax, 0x70(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, 0x68(%rbx)
movq %rbx, %rdi
callq 0x4cfb
movq %rbx, %rdi
callq 0x1030
movl 0x30(%rbx), %eax
jmp 0x4c50
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x63, 0x5e(%rdi)
jne 0x4c73
movq %rbx, %rdi
callq 0x4f70
cmpb $0x73, 0x5e(%rbx)
jne 0x4c81
movq %rbx, %rdi
callq 0x54a8
cmpb $0x70, 0x5e(%rbx)
jne 0x4c8f
movq %rbx, %rdi
callq 0x5360
movzbl 0x5e(%rbx), %eax
cmpl $0x69, %eax
je 0x4c9d
cmpl $0x64, %eax
jne 0x4ca5
movq %rbx, %rdi
callq 0x5fb3
cmpb $0x25, 0x5e(%rbx)
jne 0x4cb3
movq %rbx, %rdi
callq 0x6280
cmpb $0x6f, 0x5e(%rbx)
jne 0x4cc1
movq %rbx, %rdi
callq 0x6114
cmpb $0x75, 0x5e(%rbx)
jne 0x4ccf
movq %rbx, %rdi
callq 0x6416
movzbl 0x5e(%rbx), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x4ce3
movq %rbx, %rdi
callq 0x559c
cmpb $0x66, 0x5e(%rbx)
jne 0x4cf1
movq %rbx, %rdi
callq 0x4ff8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rsi
movq 0x28(%rbx), %rax
movzbl (%rsi,%rax), %ecx
addq %rax, %rsi
cmpl $0x25, %ecx
je 0x4d38
testl %ecx, %ecx
je 0x4da1
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
incq 0x28(%rbx)
jmp 0x4d04
cmpb $0x25, 0x1(%rsi)
jne 0x4d58
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
addq $0x2, 0x28(%rbx)
incq 0x30(%rbx)
jmp 0x4d04
cmpb $0x25, %cl
jne 0x4d1f
incq %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x4b4d
movq %rbx, %rdi
callq 0x5898
movq %rbx, %rdi
callq 0x5834
movq %rbx, %rdi
callq 0x57b8
movq %rbx, %rdi
callq 0x573c
movq %rbx, %rdi
callq 0x56fc
movq %rbx, %rdi
callq 0x4c5c
jmp 0x4d04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jne 0x4edb
movq %rsi, %r14
movl %edi, %r12d
movl %edi, %eax
leaq 0x6287(%rip), %rcx      # 0xb070
leaq (%rcx,%rax,8), %rbx
cmpq $0x0, (%rbx)
jne 0x4e06
xorl %edi, %edi
callq 0x48f4
movq %rax, (%rbx)
testq %rax, %rax
je 0x4edb
movq %r14, -0x38(%rbp)
leaq -0x2a(%rbp), %r13
movl $0x1, %edx
movl %r12d, %edi
movq %r13, %rsi
callq 0x1070
movq %rax, %r14
testl %r14d, %r14d
jle 0x4e5e
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, -0x2a(%rbp,%rax)
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x4848
movq %rax, %r15
movq (%rbx), %rdi
callq 0x1030
movq %r15, (%rbx)
movq %r15, %rdi
movl $0xa, %esi
callq 0x474c
testq %rax, %rax
je 0x4e0e
testl %r14d, %r14d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
js 0x4edb
jne 0x4e73
movq (%rbx), %rax
cmpb $0x0, (%rax)
je 0x4eed
movq (%rbx), %rdi
xorl %r14d, %r14d
movzbl (%rdi,%r14), %eax
testl %eax, %eax
je 0x4ebc
cmpl $0xa, %eax
je 0x4e8c
incq %r14
jmp 0x4e79
xorl %esi, %esi
movq %r14, %rdx
callq 0x4a48
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
leaq (%rax,%r14), %rdi
incq %rdi
callq 0x47cc
movq %rax, %r14
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
jmp 0x4ed5
xorl %esi, %esi
movq %r14, %rdx
callq 0x4a48
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x47a8
movl $0x1, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x4edb
nop
// File: /workspace/github_c_makefile_star2_O1/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
movb (%rsi), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x4f67
movb %dl, (%rax,%rcx)
movb 0x1(%rsi,%rcx), %dl
incq %rcx
jmp 0x4f57
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4f91
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x4f9d
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movb (%rax), %al
movb %al, -0x9(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0x4fbc
cmpb $0x0, 0x5c(%rbx)
jne 0x4fbc
movl $0x1, %esi
movq %rbx, %rdi
callq 0x67cc
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1040
incq 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x4fed
cmpb $0x0, 0x5c(%rbx)
je 0x4fed
movl $0x1, %esi
movq %rbx, %rdi
callq 0x67cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/print_f.c
// Function: print_decimals
static t_tags		*print_decimals(t_tags *ids, long double nbr, size_t count)
{
	uintmax_t	casted;

	nbr *= 10;
	casted = (uintmax_t)nbr;
	ft_putnbr(casted);
	ids->printed_chars++;
	ids->double_len++;
	nbr -= casted;
	if (count > 1)
		print_decimals(ids, nbr, count - 1);
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
fldt 0x10(%rbp)
movl $0x0, -0x30(%rbp)
fmuls 0x27a7(%rip)            # 0x7a58
flds 0x27a5(%rip)            # 0x7a5c
xorl %r13d, %r13d
fxch %st(1)
fucomi %st(1), %st
setae %r12b
fldz
fcmovnb %st(2), %st
fstp %st(2)
fld %st(0)
fstpt -0x5c(%rbp)
fsubp %st, %st(1)
fnstcw -0x2a(%rbp)
movzwl -0x2a(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x32(%rbp)
fldcw -0x32(%rbp)
fistpll -0x50(%rbp)
fldcw -0x2a(%rbp)
movq -0x50(%rbp), %r15
movl %r15d, %edi
callq 0x46b0
incq 0x30(%rbx)
incq 0x38(%rbx)
cmpq $0x2, %r14
jb 0x5344
movb %r12b, %r13b
shlq $0x3f, %r13
xorl %eax, %eax
xorq %r13, %r15
movq %r15, -0x48(%rbp)
sets %al
fildll -0x48(%rbp)
leaq 0x2761(%rip), %rcx      # 0x7a80
fadds (%rcx,%rax,4)
fldt -0x5c(%rbp)
fsubp %st, %st(1)
decq %r14
testb $0x1, -0x30(%rbp)
movq -0x40(%rbp), %rax
cmoveq %rbx, %rax
movq %rax, -0x40(%rbp)
movb $0x1, %al
movl %eax, -0x30(%rbp)
jmp 0x52ab
testb $0x1, -0x30(%rbp)
cmovneq -0x40(%rbp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x5385
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5391
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
movl $0x10, %esi
movq %r15, %rdi
callq 0x5b46
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x53c5
cmpb $0x2d, 0x5c(%rbx)
je 0x53c5
movq %r14, %rdi
callq 0x48d0
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x67cc
leaq 0x26be(%rip), %rdi      # 0x7a8a
callq 0x4720
cmpq $0x1, 0x18(%rbx)
jne 0x53e2
orq 0x20(%rbx), %r15
je 0x5497
cmpb $0x30, 0x59(%rbx)
jne 0x53fa
movq %r14, %rdi
callq 0x48d0
addq $0x2, %rax
cmpq 0x10(%rbx), %rax
jb 0x5412
cmpq $0x1, 0x18(%rbx)
jne 0x5425
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x48d0
cmpq %rax, %r15
jbe 0x5425
movq %r14, %rdi
callq 0x48d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x65fc
movq %r14, %rdi
callq 0x4720
movq %r14, %rdi
callq 0x48d0
movq 0x30(%rbx), %rcx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, 0x30(%rbx)
cmpb $0x2d, 0x5c(%rbx)
jne 0x5481
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x48d0
addq $0x2, %rax
cmpq %rax, %r15
jb 0x5466
cmpq $0x1, 0x18(%rbx)
je 0x546d
cmpq $0x0, 0x10(%rbx)
je 0x5481
movq %r14, %rdi
callq 0x48d0
leaq 0x2(%rax), %rsi
movq %rbx, %rdi
callq 0x67cc
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 0x6344
jmp 0x5489
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x54cd
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x54d9
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %rax
testq %rax, %rax
leaq 0x25a7(%rip), %r14      # 0x7a8d
cmovneq %rax, %r14
cmpq $0x1, 0x18(%rbx)
jne 0x5508
movq 0x20(%rbx), %r15
movq %r14, %rdi
callq 0x48d0
cmpq %rax, %r15
jae 0x5508
movq 0x20(%rbx), %rdx
jmp 0x5513
movq %r14, %rdi
callq 0x48d0
movq %rax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4a48
movq %rax, %r14
movq %rax, %rdi
callq 0x48d0
movq %rax, %r15
cmpq $0x0, 0x10(%rbx)
je 0x5549
cmpb $0x0, 0x5c(%rbx)
jne 0x5549
cmpb $0x0, 0x59(%rbx)
jne 0x5549
movq %rbx, %rdi
movq %r15, %rsi
callq 0x67cc
cmpb $0x30, 0x59(%rbx)
jne 0x5560
cmpq 0x10(%rbx), %r15
jae 0x5560
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64f4
movq %r14, %rdi
callq 0x4720
addq %r15, 0x30(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x5584
cmpb $0x2d, 0x5c(%rbx)
jne 0x5584
movq %rbx, %rdi
movq %r15, %rsi
callq 0x67cc
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_O1/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 0x5e1c
movq %rax, %r15
cmpb $0x78, 0x5e(%rbx)
jne 0x55c9
movl $0x10, %esi
movq %r15, %rdi
callq 0x5a85
jmp 0x55d6
movl $0x10, %esi
movq %r15, %rdi
callq 0x59fa
movq %rax, %r14
movq %rax, %rdi
callq 0x48d0
movq %rax, %r12
movq 0x18(%rbx), %rax
cmpq $0x1, %rax
jne 0x5604
movq 0x20(%rbx), %rcx
orq %r15, %rcx
jne 0x5604
movq %rbx, %rdi
callq 0x6344
jmp 0x56ee
testq %r15, %r15
jne 0x5615
cmpb $0x23, 0x58(%rbx)
jne 0x5615
cmpb $0x2d, 0x5c(%rbx)
jne 0x5649
movq 0x10(%rbx), %rcx
cmpq %r12, %rcx
jbe 0x562d
cmpb $0x2d, 0x5c(%rbx)
je 0x562d
cmpb $0x30, 0x59(%rbx)
movq %r12, %rsi
jne 0x564e
cmpq %r12, %rcx
jbe 0x5656
cmpb $0x30, 0x59(%rbx)
jne 0x5656
cmpq $0x1, %rax
jne 0x5656
cmpb $0x2d, 0x5c(%rbx)
movq %r12, %rsi
jne 0x564e
jmp 0x5656
leaq -0x2(%r12), %rsi
movq %rbx, %rdi
callq 0x67cc
testq %r15, %r15
je 0x568b
cmpb $0x23, 0x58(%rbx)
jne 0x568b
cmpb $0x78, 0x5e(%rbx)
leaq 0x241e(%rip), %rax      # 0x7a8a
leaq 0x2421(%rip), %rsi      # 0x7a94
cmoveq %rax, %rsi
movl $0x2, %edx
movl $0x1, %edi
callq 0x1040
addq $0x2, 0x30(%rbx)
cmpb $0x30, 0x59(%rbx)
jne 0x569e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x66e1
jmp 0x56ab
cmpq $0x1, 0x18(%rbx)
jne 0x56ab
cmpq %r12, 0x20(%rbx)
ja 0x5691
movq %r14, %rdi
callq 0x4720
addq %r12, 0x30(%rbx)
testq %r15, %r15
jne 0x56ce
cmpb $0x23, 0x58(%rbx)
jne 0x56ce
cmpb $0x2d, 0x5c(%rbx)
jne 0x56ce
addq $-0x2, %r12
jmp 0x56db
cmpq $0x0, 0x10(%rbx)
je 0x56e6
cmpb $0x2d, 0x5c(%rbx)
jne 0x56e6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x67cc
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_O1/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_arg_type
t_tags	*scan_arg_type(t_tags *ids)
{
	int	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x48(%rdi), %rcx
movb (%rcx), %sil
testb %sil, %sil
je 0x573a
movq (%rax), %rdi
movq 0x28(%rax), %rdx
movb (%rdi,%rdx), %dil
incq %rcx
cmpb %sil, %dil
je 0x572f
movb (%rcx), %sil
incq %rcx
testb %sil, %sil
jne 0x571d
jmp 0x573a
movb %dil, 0x5e(%rax)
incq %rdx
movq %rdx, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %edx
addl $-0x4c, %edx
cmpl $0x20, %edx
ja 0x57b6
movabsq $0x110000001, %rsi      # imm = 0x110000001
btq %rdx, %rsi
jae 0x57b6
movq 0x50(%rax), %rdx
cmpb $0x0, (%rdx)
je 0x57b6
movq 0x28(%rax), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
movb (%rcx,%rdi), %r9b
cmpb %r9b, (%rdx,%rsi)
jne 0x57ab
movl %r8d, %r8d
movq %rdi, %r10
movb %r9b, 0x5f(%rax,%r8)
incq %rdi
movq %rdi, 0x28(%rax)
movb 0x1(%rcx,%r10), %r9b
movl $0x1, %r8d
cmpb %r9b, (%rdx,%rsi)
je 0x5785
movl $0x1, %r8d
cmpb $0x0, 0x1(%rdx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x5778
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5832
incq 0x18(%rax)
movq 0x28(%rax), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rax)
movb 0x1(%rcx,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x5832
movq 0x20(%rax), %r8
addq $0x2, %rdx
addb $-0x30, %sil
movzbl %sil, %edi
addq %r8, %rdi
movq %rdi, 0x20(%rax)
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x581a
addq %rdi, %rdi
leaq (%rdi,%rdi,4), %rdi
movq %rdi, 0x20(%rax)
movq %rdx, 0x28(%rax)
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %r9d
incq %rdx
movq %rdi, %r8
cmpb $0xa, %r9b
jb 0x57f2
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/MikeyLHolm[P]Hive-lem-in/libftprintf/srcs/scan_tags.c
// Function: scan_minwth
t_tags	*scan_minwth(t_tags *ids)
{
	while (ids->format[ids->i] >= '0' && ids->format[ids->i] <= '9')
	{
		ids->minwth += ids->format[ids->i] - 48;
		if (ids->format[ids->i + 1] >= '0' && ids->format[ids->i + 1] <= '9')
			ids->minwth = ids->minwth * 10;
		ids->i++;
	}
	return (ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x28(%rdi), %rdx
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0x9, %dil
ja 0x5896
movq 0x10(%rax), %r8
incq %rdx
addb $-0x30, %sil
movzbl %sil, %edi
addq %r8, %rdi
movq %rdi, 0x10(%rax)
movb (%rcx,%rdx), %sil
addb $-0x30, %sil
cmpb $0x9, %sil
ja 0x587e
addq %rdi, %rdi
leaq (%rdi,%rdi,4), %rdi
movq %rdi, 0x10(%rax)
movq %rdx, 0x28(%rax)
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %r9d
incq %rdx
movq %rdi, %r8
cmpb $0xa, %r9b
jb 0x5856
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpb $0x0, (%rcx)
je 0x59cb
movq (%rax), %rdx
xorl %edi, %edi
movq 0x28(%rax), %rsi
movslq %edi, %r8
movb (%rcx,%r8), %r8b
cmpb (%rdx,%rsi), %r8b
jne 0x59b9
cmpb $0x23, (%rdx,%rsi)
jne 0x58e9
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%rax)
testq %rsi, %rsi
je 0x58ee
movb $0x23, 0x58(%rax)
cmpb $0x23, 0x1(%rdx,%rsi)
movq %rdi, %rsi
je 0x58cc
jmp 0x58f3
movq %rsi, %rdi
jmp 0x58f3
movl $0x1, %edi
cmpb $0x30, (%rdx,%rdi)
jne 0x5916
leaq 0x1(%rdi), %rsi
movq %rsi, 0x28(%rax)
testq %rdi, %rdi
je 0x591b
movb $0x30, 0x59(%rax)
cmpb $0x30, 0x1(%rdx,%rdi)
movq %rsi, %rdi
je 0x58f9
jmp 0x5920
movq %rdi, %rsi
jmp 0x5920
movl $0x1, %esi
cmpb $0x20, (%rdx,%rsi)
jne 0x5943
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%rax)
testq %rsi, %rsi
je 0x5948
movb $0x20, 0x5a(%rax)
cmpb $0x20, 0x1(%rdx,%rsi)
movq %rdi, %rsi
je 0x5926
jmp 0x594d
movq %rsi, %rdi
jmp 0x594d
movl $0x1, %edi
cmpb $0x2b, (%rdx,%rdi)
jne 0x5970
leaq 0x1(%rdi), %r8
movq %r8, 0x28(%rax)
testq %rdi, %rdi
je 0x5975
movb $0x2b, 0x5b(%rax)
cmpb $0x2b, 0x1(%rdx,%rdi)
movq %r8, %rdi
je 0x5953
jmp 0x597b
movq %rdi, %r8
jmp 0x597b
movl $0x1, %r8d
cmpb $0x2d, (%rdx,%r8)
jne 0x59a0
leaq 0x1(%r8), %rsi
movq %rsi, 0x28(%rax)
testq %r8, %r8
je 0x59a5
movb $0x2d, 0x5c(%rax)
cmpb $0x2d, 0x1(%rdx,%r8)
movq %rsi, %r8
je 0x5982
jmp 0x59aa
movq %r8, %rsi
jmp 0x59aa
movl $0x1, %esi
movb (%rcx), %dil
cmpb (%rdx,%rsi), %dil
je 0x58c6
xorl %edi, %edi
movslq %edi, %rsi
leaq 0x1(%rsi), %rdi
cmpb $0x0, 0x1(%rcx,%rsi)
jne 0x58b1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x59f0
xorl %ecx, %ecx
incq %rcx
movq %rdi, %rax
xorl %edx, %edx
divq %rsi
cmpq %rsi, %rdi
movq %rax, %rdi
jae 0x59db
jmp 0x59f5
movl $0x1, %ecx
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x5a2a
xorl %r15d, %r15d
movq %r14, %rcx
incq %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x5a15
jmp 0x5a30
movl $0x1, %r15d
movq %r15, %rdi
callq 0x48f4
testq %rax, %rax
je 0x5a75
movq %rax, %rcx
testq %r14, %r14
jne 0x5a48
movb $0x30, (%rcx)
testq %r14, %r14
je 0x5a77
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x203c(%rip), %rdi      # 0x7a97
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x5a5b
jmp 0x5a77
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x5ab5
xorl %r15d, %r15d
movq %r14, %rcx
incq %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x5aa0
jmp 0x5abb
movl $0x1, %r15d
movq %r15, %rdi
callq 0x48f4
testq %rax, %rax
je 0x5b00
movq %rax, %rcx
testq %r14, %r14
jne 0x5ad3
movb $0x30, (%rcx)
testq %r14, %r14
je 0x5b02
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x1fd6(%rip), %rdi      # 0x7abc
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x5ae6
jmp 0x5b02
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b3c
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
shrq $0x3f, %rdi
incq %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
cmpq %rsi, %rcx
movq %rax, %rcx
jae 0x5b27
jmp 0x5b41
movl $0x1, %edi
movq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b5a
leaq 0x1f8c(%rip), %rdi      # 0x7ae1
jmp 0x47cc
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
jae 0x5b92
movq %r14, %rcx
negq %rcx
cmovsq %r14, %rcx
movq %r14, %r15
shrq $0x3f, %r15
incq %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
cmpq %rbx, %rcx
movq %rax, %rcx
jae 0x5b7d
jmp 0x5b98
movl $0x1, %r15d
movq %r15, %rdi
callq 0x48f4
testq %rax, %rax
je 0x5bdd
movq %rax, %rcx
testq %r14, %r14
jne 0x5bb0
movb $0x30, (%rcx)
testq %r14, %r14
jle 0x5bdf
leaq (%r15,%rcx), %rsi
decq %rsi
leaq 0x1ef9(%rip), %rdi      # 0x7abc
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %rbx, %r14
movq %rax, %r14
jae 0x5bc3
jmp 0x5bdf
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_O1/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 0x1ee6(%rip), %rsi      # 0x7af5
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5c47
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x5c36
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x5c42
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x1ead(%rip), %rsi      # 0x7afb
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5c86
movl 0x6c(%rbx), %ecx
cmpq $0xa0, %rcx
ja 0x5c75
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x10, %ecx
movl %ecx, 0x6c(%rbx)
jmp 0x5c81
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
fldl (%rax)
fstpt -0x1c(%rbp)
leaq 0x1dc5(%rip), %rsi      # 0x7a52
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
fldt -0x1c(%rbp)
jne 0x5cb4
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 0x5cc1
movl $0xffffffff, 0x40(%rbx) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e10(%rip), %rsi      # 0x7af5
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5d18
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5d09
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5d15
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movslq (%rax), %r15
leaq 0x1dd9(%rip), %rsi      # 0x7af8
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5d53
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5d43
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5d4f
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movswq (%rax), %r15
leaq 0x1da1(%rip), %rsi      # 0x7afb
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5d8d
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5d7e
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5d8a
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
leaq 0x1d63(%rip), %rsi      # 0x7af7
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5dc8
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5db8
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5dc4
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movsbq (%rax), %r15
leaq 0x1d2b(%rip), %rsi      # 0x7afa
movq %r14, %rdi
callq 0x4780
testl %eax, %eax
jne 0x5e02
movl 0x68(%rbx), %ecx
cmpq $0x28, %rcx
ja 0x5df3
movq %rcx, %rax
addq 0x78(%rbx), %rax
addl $0x8, %ecx
movl %ecx, 0x68(%rbx)
jmp 0x5dff
movq 0x70(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rax), %r15
testq %r15, %r15
jns 0x5e0e
movl $0xffffffff, 0x40(%rbx) # imm = 0xFFFFFFFF
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq