LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_memset.c
// Function: set_byte
static inline uint64_t	set_byte(unsigned char c)
{
	uint64_t	c_each_byte;

	c_each_byte = c & 0xff;
	c_each_byte = (c_each_byte << 8) | c_each_byte;
	c_each_byte = (c_each_byte << 16) | c_each_byte;
	c_each_byte = (c_each_byte << 32) | c_each_byte;
	return (c_each_byte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
andl $0xff, %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x20, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	if ((unsigned char)*s == c)
		return ((char *)s);
	while (*(s++))
		if ((unsigned char)*s == c)
			return ((char *)s);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6451
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6487
jmp 0x6453
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x647f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x647d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6487
jmp 0x6453
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strchri.c
// Function: ft_strchri
size_t	ft_strchri(const char *s, int c)
{
	size_t	n;

	n = 2;
	if (!c)
		return (0);
	if ((unsigned char)*s == (unsigned char)c)
		return (1);
	while (*(s++))
	{
		if ((unsigned char)*s == (unsigned char)c)
			return (n);
		n++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x2, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x64b3
movq $0x0, -0x8(%rbp)
jmp 0x6515
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x64ce
movq $0x1, -0x8(%rbp)
jmp 0x6515
jmp 0x64d0
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x650d
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x64ff
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6515
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x64d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strjoin.c
// Function: ft_strjoin
char			*ft_strjoin(char const *s1, char const *s2)
{
	char	*pc;
	size_t	n1;
	size_t	n2;

	n1 = s1 ? ft_strlen(s1) : 0;
	n2 = s2 ? ft_strlen(s2) : 0;
	if (n1 + n2 == 0)
		return (0);
	if (!(pc = (char *)malloc(sizeof(char) * (n1 + n2 + 1))))
		return (0);
	ft_strncpy(pc, s1, n1);
	ft_strncpy(pc + n1, s2, n2);
	pc[n1 + n2] = 0;
	return (pc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6546
movq -0x10(%rbp), %rdi
callq 0x3140
movq %rax, -0x38(%rbp)
jmp 0x654e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x654e
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x656c
movq -0x18(%rbp), %rdi
callq 0x3140
movq %rax, -0x40(%rbp)
jmp 0x6574
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x6574
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq $0x0, %rax
jne 0x6594
movq $0x0, -0x8(%rbp)
jmp 0x65fb
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x3690
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x65bd
movq $0x0, -0x8(%rbp)
jmp 0x65fb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x35a0
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x35a0
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t	i;

	i = 0;
	while (*(s++))
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, (%rax)
je 0x6642
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6620
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strncpy.c
// Function: ft_strncpy
char	*ft_strncpy(char *s1, const char *s2, size_t n)
{
	char	*pc;
	size_t	len;

	if ((pc = ft_memccpy(s1, s2, 0, n)))
	{
		len = pc - s1;
		ft_bzero(pc, n - len);
	}
	return (s1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
xorl %edx, %edx
callq 0x3520
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x66a1
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq -0x28(%rbp), %rsi
callq 0x3130
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_wstrlen.c
// Function: ft_wstrlen
size_t		ft_wstrlen(unsigned *str)
{
	size_t	len;

	len = 0;
	while (*str != L'\0')
		len += ft_wcharlen(*(str++));
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x670d
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
movl (%rax), %edi
callq 0x32f0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x66e4
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_wcharlen.c
// Function: ft_wcharlen
size_t	ft_wcharlen(unsigned wc)
{
	if (wc < 0x80)
		return (1);
	if (wc < 0x800)
		return (2);
	if (wc < 0x10000)
		return (3);
	return (4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jae 0x673a
movq $0x1, -0x8(%rbp)
jmp 0x6768
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jae 0x674d
movq $0x2, -0x8(%rbp)
jmp 0x6768
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0x6760
movq $0x3, -0x8(%rbp)
jmp 0x6768
movq $0x4, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strcpy.c
// Function: ft_strcpy
char				*ft_strcpy(char *s1, const char *s2)
{
	char		*cs1;
	const char	*cs2;

	cs1 = s1;
	cs2 = s2;
	if ((((uintptr_t)s1 & 0x7) == ((uintptr_t)s2 & 0x7)))
	{
		if (align_address(&cs1, &cs2))
			return (s1);
		loopword(&cs1, &cs2);
	}
	while (1)
	{
		if (!(*cs1 = *cs2))
			return (s1);
		++cs1;
		++cs2;
	}
	return (s1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
movq -0x18(%rbp), %rcx
andq $0x7, %rcx
cmpq %rcx, %rax
jne 0x67ce
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6810
cmpl $0x0, %eax
je 0x67c1
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6804
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6880
jmp 0x67d0
movq -0x28(%rbp), %rax
movb (%rax), %al
movq -0x20(%rbp), %rcx
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x67ea
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6804
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x67d0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strcpy.c
// Function: align_address
static inline int	align_address(char **cs1,
						const char **cs2)
{
	while ((uintptr_t)*cs1 & 0x7)
	{
		if (!(**cs1 = **cs2))
			return (1);
		++(*cs1);
		++(*cs2);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x686a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x684c
movl $0x1, -0x4(%rbp)
jmp 0x6871
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x681c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/ft_strcpy.c
// Function: loopword
static inline void	loopword(char **cs1, const char **cs2)
{
	uint64_t	*ll1;
	uint64_t	*ll2;
	uint64_t	one_each_byte;

	ll1 = (uint64_t *)*cs1;
	ll2 = (uint64_t *)*cs2;
	one_each_byte = 0x0101010101010101L;
	while (1)
	{
		if (((*ll2 - one_each_byte) & ~*ll2) & (one_each_byte << 7))
			break ;
		*ll1++ = *ll2++;
	}
	*cs1 = (char *)ll1;
	*cs2 = (char *)ll2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq -0x28(%rbp), %rcx
shlq $0x7, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x68dc
jmp 0x6902
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x18(%rbp)
movq %rcx, (%rax)
jmp 0x68b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ft_printf.c
// Function: ft_printf
int		ft_printf(const char *format, ...)
{
	t_printf	pf;

	ft_bzero(&pf, sizeof(pf));
	pf.fd = 1;
	if (!(pf.format = (char *)format))
		return (-1);
	va_start(pf.ap, format);
	while (*pf.format)
	{
		if (*pf.format == '%')
		{
			++pf.format;
			if (!*pf.format)
				break ;
			else
				pf_parse(&pf);
		}
		else
			pf_buffer_write(&pf, pf.format, 1);
		++pf.format;
	}
	pf.flag = write(pf.fd, pf.buff, pf.index);
	va_end(pf.ap);
	return (pf.len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x6967
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x98, %esi
callq 0x3130
movl $0x1, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x69c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6a7f
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6a4b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x6a28
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6a1a
jmp 0x6a4b
leaq -0xa8(%rbp), %rdi
callq 0x33b0
jmp 0x6a3d
movq -0x28(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x1, %edx
callq 0x3500
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x69ee
movl -0x9c(%rbp), %edi
leaq -0xa8(%rbp), %rsi
addq $0x24, %rsi
movslq -0x98(%rbp), %rdx
callq 0x3100
movl %eax, -0x18(%rbp)
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
movl -0xa8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ft_printf.c
// Function: ft_dprintf
int		ft_dprintf(int fd, const char *format, ...)
{
	t_printf	pf;

	ft_bzero(&pf, sizeof(pf));
	pf.fd = fd;
	if (!(pf.format = (char *)format))
		return (-1);
	va_start(pf.ap, format);
	while (*pf.format)
	{
		if (*pf.format == '%')
		{
			++pf.format;
			if (!*pf.format)
				break ;
			else
				pf_parse(&pf);
		}
		else
			pf_buffer_write(&pf, pf.format, 1);
		++pf.format;
	}
	pf.flag = write(pf.fd, pf.buff, pf.index);
	va_end(pf.ap);
	return (pf.len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x6ad7
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x98, %esi
callq 0x3130
movl -0x8(%rbp), %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6b2e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6bea
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6bb6
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x6b93
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6b85
jmp 0x6bb6
leaq -0xa8(%rbp), %rdi
callq 0x33b0
jmp 0x6ba8
movq -0x28(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x1, %edx
callq 0x3500
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6b59
movl -0x9c(%rbp), %edi
leaq -0xa8(%rbp), %rsi
addq $0x24, %rsi
movslq -0x98(%rbp), %rdx
callq 0x3100
movl %eax, -0x18(%rbp)
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
movl -0xa8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ft_printf.c
// Function: ft_nprintf
int		ft_nprintf(const char *format, ...)
{
	t_printf	pf;

	ft_bzero(&pf, sizeof(pf));
	pf.noprint = 1;
	if (!(pf.format = (char *)format))
		return (-1);
	va_start(pf.ap, format);
	while (*pf.format)
	{
		if (*pf.format == '%')
		{
			++pf.format;
			if (!*pf.format)
				break ;
			else
				pf_parse(&pf);
		}
		else
			pf_buffer_write(&pf, pf.format, 1);
		++pf.format;
	}
	va_end(pf.ap);
	return (pf.len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x6c47
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x98, %esi
callq 0x3130
movl $0x1, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6ca3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6d3f
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6d2b
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x6d08
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6cfa
jmp 0x6d2b
leaq -0xa8(%rbp), %rdi
callq 0x33b0
jmp 0x6d1d
movq -0x28(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x1, %edx
callq 0x3500
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6cce
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
movl -0xa8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ft_printf.c
// Function: ft_sprintf
char	*ft_sprintf(const char *format, ...)
{
	t_printf	pf;

	ft_bzero(&pf, sizeof(pf));
	pf.noprint = 2;
	if (!(pf.format = (char *)format))
		return (0);
	pf.pc = ft_strnew(PF_BUFF_SIZE);
	va_start(pf.ap, format);
	while (*pf.format)
	{
		if (*pf.format == '%')
		{
			++pf.format;
			if (!*pf.format)
				break ;
			pf_parse(&pf);
		}
		else
			pf_buffer_write(&pf, pf.format, 1);
		++pf.format;
	}
	end_sprintf(&pf);
	va_end(pf.ap);
	return (pf.pc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
testb %al, %al
je 0x6dd7
movaps %xmm0, -0x130(%rbp)
movaps %xmm1, -0x120(%rbp)
movaps %xmm2, -0x110(%rbp)
movaps %xmm3, -0x100(%rbp)
movaps %xmm4, -0xf0(%rbp)
movaps %xmm5, -0xe0(%rbp)
movaps %xmm6, -0xd0(%rbp)
movaps %xmm7, -0xc0(%rbp)
movq %r9, -0x138(%rbp)
movq %r8, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
movq %rdx, -0x150(%rbp)
movq %rsi, -0x158(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x98, %esi
callq 0x3130
movl $0x2, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6e34
movq $0x0, -0x8(%rbp)
jmp 0x6ee9
movl $0x40, %edi
callq 0x3330
movq %rax, -0x20(%rbp)
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
leaq -0x160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6eca
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x6ea7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e99
jmp 0x6eca
leaq -0xa8(%rbp), %rdi
callq 0x33b0
jmp 0x6ebc
movq -0x28(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movl $0x1, %edx
callq 0x3500
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6e6d
leaq -0xa8(%rbp), %rdi
callq 0x3300
leaq -0xa8(%rbp), %rax
addq $0x68, %rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_buffer.c
// Function: pf_char_write
void				pf_char_write(t_printf *pf)
{
	char	*tmp;

	tmp = pf->pc;
	pf->pc = ft_strjoin(tmp, pf->buff);
	if (tmp)
		free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x24, %rsi
callq 0x3530
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x6f4a
movq -0x10(%rbp), %rdi
callq 0x3110
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_buffer.c
// Function: pf_padding
int					pf_padding(t_printf *pf, int n)
{
	char		c;

	c = (pf->flag & F_ZERO || pf->option_padding) ? '0' : ' ';
	if (pf->padding > 0)
		if ((!n && !(pf->flag & F_MINUS)) || (n && (pf->flag & F_MINUS))
			|| pf->option_padding)
			while (pf->padding--)
				pf_buffer_write(pf, &c, 1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0x1000000, %ecx        # imm = 0x1000000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xe(%rbp)
jne 0x6f87
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
setne %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %dl
movl $0x20, %eax
movl $0x30, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x7013
cmpl $0x0, -0xc(%rbp)
jne 0x6fc1
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
je 0x6fe5
cmpl $0x0, -0xc(%rbp)
je 0x6fdb
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
jne 0x6fe5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x7011
jmp 0x6fe7
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl $0x0, %eax
je 0x700f
movq -0x8(%rbp), %rdi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x3500
jmp 0x6fe7
jmp 0x7011
jmp 0x7013
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_buffer.c
// Function: pf_buffer_write
int					pf_buffer_write(t_printf *pf, void *str, size_t size)
{
	if (!pf->noprint)
		pf_stdout(pf, str, size);
	else
		pf_not_stdout(pf, str, size);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x7051
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7070
jmp 0x7062
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_buffer.c
// Function: pf_stdout
static inline void	pf_stdout(t_printf *pf, void *str, size_t size)
{
	size_t		i;
	int			diff;
	int			ret;

	i = 0;
	while ((size_t)(PF_BUFF_SIZE - pf->index) < size)
	{
		diff = PF_BUFF_SIZE - pf->index;
		ft_memcpy((void *)(pf->buff + pf->index),
		(void *)((char *)str + i), diff);
		size -= diff;
		i += diff;
		pf->len += diff;
		ret = write(pf->fd, pf->buff, pf->index + diff);
		pf->index = 0;
	}
	ft_memcpy((void *)(pf->buff + pf->index),
	(void *)((char *)str + i), size);
	(void)ret;
	pf->index += size;
	pf->len += size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movl $0x40, %eax
subl 0x10(%rcx), %eax
cltq
cmpq -0x18(%rbp), %rax
jae 0x7131
movq -0x8(%rbp), %rcx
movl $0x40, %eax
subl 0x10(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3440
movslq -0x24(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0x24(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x24, %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rdx
callq 0x3100
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x708c
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3440
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_buffer.c
// Function: pf_not_stdout
static inline void	pf_not_stdout(t_printf *pf, void *str, size_t size)
{
	size_t		i;
	int			diff;

	i = 0;
	while ((size_t)(PF_BUFF_SIZE - pf->index) < size)
	{
		diff = PF_BUFF_SIZE - pf->index;
		ft_memcpy((void *)(pf->buff + pf->index),
		(void *)((char *)(str) + i), diff);
		size -= diff;
		i += diff;
		pf->len += diff;
		if (pf->pc)
		{
			(pf->buff)[pf->index + diff] = 0;
			pf_char_write(pf);
		}
		pf->index = 0;
	}
	ft_memcpy((void *)(pf->buff + pf->index),
	(void *)((char *)(str) + i), size);
	pf->index += size;
	pf->len += size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movl $0x40, %eax
subl 0x10(%rcx), %eax
cltq
cmpq -0x18(%rbp), %rax
jae 0x724a
movq -0x8(%rbp), %rcx
movl $0x40, %eax
subl 0x10(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3440
movslq -0x24(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movslq -0x24(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x723a
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, 0x24(%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x3570
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x719c
movq -0x8(%rbp), %rdi
addq $0x24, %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3440
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_number.c
// Function: finish_printf
static inline void	finish_printf(uintmax_t n, int b, char s[70], t_printf *pf)
{
	(pf->flag & F_ZERO) ? pf_padding(pf, 0) : 0;
	pf->padding = pf->precision - pf->printed;
	pf->option_padding = 1;
	pf_padding(pf, 0);
	pf->option_padding = 0;
	pf_itoa_fill(n, b, s, pf);
	pf_buffer_write(pf, s, pf->printed);
	pf->padding = pf->length - pf->precision;
	pf_padding(pf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x7528
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x752a
jmp 0x752a
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x20(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3050
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x3500
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_number_2.c
// Function: pf_itoa_quote
void				pf_itoa_quote(uintmax_t n, int b, char s[70], t_printf *pf)
{
	int		quote;
	int		len;
	int		c;

	c = (char)pf->flag;
	len = pf->printed;
	if (len < 4)
		quote = -3;
	else
		quote = 0;
	c = (c == 'P' || c == 'X') ? 55 : 87;
	while (len--)
	{
		s[len] = n % b;
		s[len] += (s[len] < 10) ? '0' : c;
		if (len && ++quote == 3)
		{
			s[--len] = ',';
			quote = 0;
		}
		n /= b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x90(%rax), %eax
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x7ffc
movl $0xfffffffd, -0x24(%rbp) # imm = 0xFFFFFFFD
jmp 0x8003
movl $0x0, -0x24(%rbp)
movb $0x1, %al
cmpl $0x50, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
je 0x8018
cmpl $0x58, -0x2c(%rbp)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
movl $0x57, %eax
movl $0x37, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
je 0x80d4
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jge 0x8075
movl $0x30, %eax
movl %eax, -0x34(%rbp)
jmp 0x807b
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0x28(%rbp)
je 0x80be
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x3, %eax
jne 0x80be
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
movb $0x2c, (%rax,%rcx)
movl $0x0, -0x24(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
jmp 0x802e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_number_2.c
// Function: pf_sign
int					pf_sign(t_printf *pf)
{
	if (pf->flag & F_NEGATIF)
		pf_buffer_write(pf, "-", 1);
	else if (pf->flag & F_PLUS)
		pf_buffer_write(pf, "+", 1);
	else
		pf_buffer_write(pf, " ", 1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x8117
movq -0x8(%rbp), %rdi
leaq 0x422b(%rip), %rsi      # 0xc336
movl $0x1, %edx
callq 0x3500
jmp 0x8159
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
je 0x8142
movq -0x8(%rbp), %rdi
leaq 0x4202(%rip), %rsi      # 0xc338
movl $0x1, %edx
callq 0x3500
jmp 0x8157
movq -0x8(%rbp), %rdi
leaq 0x3ec9(%rip), %rsi      # 0xc016
movl $0x1, %edx
callq 0x3500
jmp 0x8159
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_number_2.c
// Function: pf_itoa_fill
void				pf_itoa_fill(uintmax_t n, int b, char s[70], t_printf *pf)
{
	int		len;
	int		c;

	if (!(pf->flag & F_QUOTE))
	{
		c = (char)pf->flag;
		len = pf->printed;
		c = (c == 'P' || c == 'X') ? 55 : 87;
		while (len--)
		{
			s[len] = n % b;
			s[len] += (s[len] < 10) ? '0' : c;
			n /= b;
		}
	}
	else
		pf_itoa_quote(n, b, s, pf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
jne 0x8256
movq -0x20(%rbp), %rax
movl 0x90(%rax), %eax
movsbl %al, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
movb $0x1, %al
cmpl $0x50, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x81ce
cmpl $0x58, -0x28(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %dl
movl $0x57, %eax
movl $0x37, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
je 0x8254
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jge 0x8227
movl $0x30, %eax
movl %eax, -0x30(%rbp)
jmp 0x822d
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
jmp 0x81e4
jmp 0x826a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3320
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_other.c
// Function: pf_parse_atoi
int					pf_parse_atoi(char **str)
{
	long	i;

	i = 0;
	while (**str >= '0' && **str <= '9')
	{
		if (i > 2147483647)
		{
			i = 2147483648;
			(*str)++;
		}
		else
			i = i * 10 + *(*str)++ - '0';
	}
	if (i == 2147483648)
		return (-1);
	return ((int)i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x19(%rbp)
jl 0x82a7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x82b0
jmp 0x82fa
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jle 0x82d3
movl $0x80000000, %eax       # imm = 0x80000000
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x82f8
imulq $0xa, -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movsbq (%rcx), %rcx
addq %rcx, %rax
subq $0x30, %rax
movq %rax, -0x18(%rbp)
jmp 0x8280
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, -0x18(%rbp)
jne 0x830e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8315
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_other.c
// Function: pf_putvoid
void				pf_putvoid(t_printf *pf)
{
	pf->padding = pf->length - 1;
	if (pf->padding > 0)
	{
		pf_padding(pf, 0);
		pf_buffer_write(pf, pf->format, 1);
		pf_padding(pf, 1);
	}
	else
		pf_buffer_write(pf, pf->format, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x837b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rsi
movl $0x1, %edx
callq 0x3500
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
jmp 0x8394
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rsi
movl $0x1, %edx
callq 0x3500
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_other.c
// Function: pf_putpointer
void				pf_putpointer(t_printf *pf)
{
	void	*pv;

	pv = va_arg(pf->ap, void *);
	pf->flag |= F_SHARP;
	pf->flag &= ~F_QUOTE;
	pf->printed = 1;
	pf->length -= 2;
	pf_itoa_base((uintmax_t)pv, 16, pf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x20(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x28, %eax
ja 0x83df
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x83f6
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
orl $0x4000000, %ecx        # imm = 0x4000000
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xf7ffffff, %ecx       # imm = 0xF7FFFFFF
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x10, %esi
callq 0x30e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_other.c
// Function: pf_getlen
void				pf_getlen(t_printf *pf)
{
	int			*pi;
	intmax_t	*pm;
	size_t		*pz;

	if (!(pf->flag & (F_INTMAX | F_SIZE_T)))
	{
		pi = va_arg(pf->ap, int *);
		*pi = (pf->len);
	}
	else if (pf->flag & F_INTMAX)
	{
		pm = va_arg(pf->ap, intmax_t *);
		*pm = (pf->len);
	}
	else if (pf->flag & F_SIZE_T)
	{
		pz = va_arg(pf->ap, size_t *);
		*pz = (pf->len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x60000000, %eax       # imm = 0x60000000
cmpl $0x0, %eax
jne 0x84e2
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x30(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x28, %eax
ja 0x84af
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rbp)
jmp 0x84c6
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x85d6
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x20000000, %eax       # imm = 0x20000000
cmpl $0x0, %eax
je 0x855b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x48(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0x8529
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x8540
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x85d4
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x40000000, %eax       # imm = 0x40000000
cmpl $0x0, %eax
je 0x85d2
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x60(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x28, %eax
ja 0x85a2
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x85b9
movq -0x60(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x85d4
jmp 0x85d6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_parsing.c
// Function: pf_parse
void				pf_parse(t_printf *pf)
{
	int	i;

	pf->flag = 0;
	pf->length = 0;
	pf->precision = 0;
	pf_parse_flag(pf);
	pf_parse_length_precision(pf);
	i = pf->precision;
	pf->precision = (i >= 0) ? i : 0;
	pf->flag &= (i >= 0) ? pf->flag : ~F_DOT;
	i = pf->length;
	pf->length = (i >= 0) ? i : 0;
	(pf->flag & (F_MINUS | F_QUOTE)) ? pf->flag &= ~F_ZERO : 0;
	(pf->flag & F_PLUS) ? pf->flag &= ~F_SPACE : 0;
	pf->flag |= (pf->format)[0];
	pf_parse_conversion(pf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x8730
movq -0x8(%rbp), %rdi
callq 0x8870
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x863a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x8641
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x8641
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x0, -0xc(%rbp)
jl 0x8660
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x866a
movl $0xffdfffff, %eax       # imm = 0xFFDFFFFF
movl %eax, -0x14(%rbp)
jmp 0x866a
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
andl 0x90(%rax), %ecx
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x8695
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x869c
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x869c
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x8400000, %eax        # imm = 0x8400000
cmpl $0x0, %eax
je 0x86d2
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xfeffffff, %ecx       # imm = 0xFEFFFFFF
movl %ecx, 0x90(%rax)
jmp 0x86d4
jmp 0x86d4
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x800000, %eax         # imm = 0x800000
cmpl $0x0, %eax
je 0x8700
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xfdffffff, %ecx       # imm = 0xFDFFFFFF
movl %ecx, 0x90(%rax)
jmp 0x8702
jmp 0x8702
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movsbl (%rax), %ecx
movq -0x8(%rbp), %rax
orl 0x90(%rax), %ecx
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rdi
callq 0x8ad0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_parsing.c
// Function: pf_parse_flag
static inline void	pf_parse_flag(t_printf *pf)
{
	int	i;

	while ((i = ft_strchri("-+0 #'*", (pf->format)[0])) && (++pf->format))
		pf->flag |= (1 << (21 + i));
	if (pf->flag & F_WILDCARD)
	{
		pf->flag &= ~F_WILDCARD;
		i = (int)va_arg(pf->ap, int);
		if (pf->flag & F_DOT)
			pf->precision = i;
		else
			pf->length = i;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movsbl (%rax), %esi
leaq 0x3be9(%rip), %rdi      # 0xc33a
callq 0x35b0
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
je 0x8785
movq -0x8(%rbp), %rcx
movq 0x80(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x80(%rcx)
cmpq $0x0, %rax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x878e
jmp 0x87af
movl -0xc(%rbp), %ecx
addl $0x15, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x90(%rax), %ecx
movl %ecx, 0x90(%rax)
jmp 0x873c
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x10000000, %eax       # imm = 0x10000000
cmpl $0x0, %eax
je 0x885c
movq -0x8(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0xefffffff, %ecx       # imm = 0xEFFFFFFF
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x20(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x28, %eax
ja 0x8810
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x8827
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x200000, %eax         # imm = 0x200000
cmpl $0x0, %eax
je 0x8850
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x885a
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x885c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_parsing.c
// Function: pf_parse_conversion
static inline void	pf_parse_conversion(t_printf *pf)
{
	char	c;

	c = (char)pf->flag;
	pf->flag |= c < 97 && c != 'X' ? F_1LONG | F_2LONG : 0;
	if (!c)
		pf->format--;
	else if (c == 's' || c == 'S')
		(pf->flag & (F_1LONG | F_2LONG)) ? pf_putwstr(pf) : pf_putstr(pf);
	else if (c == 'c' || c == 'C')
		(pf->flag & (F_1LONG | F_2LONG)) ? pf_putwchar(pf) : pf_putchar(pf);
	else if (c == 'D' || c == 'I' || c == 'd' || c == 'i')
		pf_putnbr(pf);
	else if (pf_get_base(pf, c))
		pf_putnbr_base(pf);
	else if (c == 'p' || c == 'P')
		pf_putpointer(pf);
	else if (c == 'n' || c == 'N')
		pf_getlen(pf);
	else if (c == 'F' || c == 'f')
		pf_putdouble(pf);
	else if (c)
		pf_putvoid(pf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0x61, %ecx
movb %al, -0xa(%rbp)
jge 0x8b04
movsbl -0x9(%rbp), %eax
cmpl $0x58, %eax
setne %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %dl
xorl %ecx, %ecx
movl $0x30000, %eax          # imm = 0x30000
testb $0x1, %dl
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x90(%rax), %ecx
movl %ecx, 0x90(%rax)
cmpb $0x0, -0x9(%rbp)
jne 0x8b45
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x80(%rax)
jmp 0x8c88
movsbl -0x9(%rbp), %eax
cmpl $0x73, %eax
je 0x8b57
movsbl -0x9(%rbp), %eax
cmpl $0x53, %eax
jne 0x8b84
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x30000, %eax          # imm = 0x30000
cmpl $0x0, %eax
je 0x8b76
movq -0x8(%rbp), %rdi
callq 0x3280
jmp 0x8b7f
movq -0x8(%rbp), %rdi
callq 0x3040
jmp 0x8c86
movsbl -0x9(%rbp), %eax
cmpl $0x63, %eax
je 0x8b96
movsbl -0x9(%rbp), %eax
cmpl $0x43, %eax
jne 0x8bc3
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x30000, %eax          # imm = 0x30000
cmpl $0x0, %eax
je 0x8bb5
movq -0x8(%rbp), %rdi
callq 0x3270
jmp 0x8bbe
movq -0x8(%rbp), %rdi
callq 0x31f0
jmp 0x8c84
movsbl -0x9(%rbp), %eax
cmpl $0x44, %eax
je 0x8be7
movsbl -0x9(%rbp), %eax
cmpl $0x49, %eax
je 0x8be7
movsbl -0x9(%rbp), %eax
cmpl $0x64, %eax
je 0x8be7
movsbl -0x9(%rbp), %eax
cmpl $0x69, %eax
jne 0x8bf5
movq -0x8(%rbp), %rdi
callq 0x3590
jmp 0x8c82
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x8c90
cmpl $0x0, %eax
je 0x8c12
movq -0x8(%rbp), %rdi
callq 0x3070
jmp 0x8c80
movsbl -0x9(%rbp), %eax
cmpl $0x70, %eax
je 0x8c24
movsbl -0x9(%rbp), %eax
cmpl $0x50, %eax
jne 0x8c2f
movq -0x8(%rbp), %rdi
callq 0x30a0
jmp 0x8c7e
movsbl -0x9(%rbp), %eax
cmpl $0x6e, %eax
je 0x8c41
movsbl -0x9(%rbp), %eax
cmpl $0x4e, %eax
jne 0x8c4c
movq -0x8(%rbp), %rdi
callq 0x3390
jmp 0x8c7c
movsbl -0x9(%rbp), %eax
cmpl $0x46, %eax
je 0x8c5e
movsbl -0x9(%rbp), %eax
cmpl $0x66, %eax
jne 0x8c69
movq -0x8(%rbp), %rdi
callq 0x30f0
jmp 0x8c7a
cmpb $0x0, -0x9(%rbp)
je 0x8c78
movq -0x8(%rbp), %rdi
callq 0x3060
jmp 0x8c7a
jmp 0x8c7c
jmp 0x8c7e
jmp 0x8c80
jmp 0x8c82
jmp 0x8c84
jmp 0x8c86
jmp 0x8c88
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_parsing.c
// Function: pf_get_base
static inline int	pf_get_base(t_printf *pf, char c)
{
	if (ft_strchr("ouxXbOUB", c))
	{
		if (c == 'o' || c == 'O')
			pf->base = 8;
		else if (c == 'u' || c == 'U')
			pf->base = 10;
		else if (c == 'x' || c == 'X')
			pf->base = 16;
		else
			pf->base = 2;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %esi
leaq 0x3695(%rip), %rdi      # 0xc342
callq 0x3420
cmpq $0x0, %rax
je 0x8d3d
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
je 0x8cce
movsbl -0x11(%rbp), %eax
cmpl $0x4f, %eax
jne 0x8cde
movq -0x10(%rbp), %rax
movl $0x8, 0x94(%rax)
jmp 0x8d34
movsbl -0x11(%rbp), %eax
cmpl $0x75, %eax
je 0x8cf0
movsbl -0x11(%rbp), %eax
cmpl $0x55, %eax
jne 0x8d00
movq -0x10(%rbp), %rax
movl $0xa, 0x94(%rax)
jmp 0x8d32
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
je 0x8d12
movsbl -0x11(%rbp), %eax
cmpl $0x58, %eax
jne 0x8d22
movq -0x10(%rbp), %rax
movl $0x10, 0x94(%rax)
jmp 0x8d30
movq -0x10(%rbp), %rax
movl $0x2, 0x94(%rax)
jmp 0x8d32
jmp 0x8d34
movl $0x1, -0x4(%rbp)
jmp 0x8d44
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)