LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_o.c
// Function: convert_o
int				convert_o(t_mods modifiers, va_list ap, int i)
{
	uint64_t	num;
	int			nbyte;
	char		*tmp;
	char		*str;

	nbyte = 0;
	i == 16 ? modifiers.length = 'z' : 0;
	num = convert_length(modifiers.length, ap);
	if (modifiers.length == 'l' || modifiers.length / 2 == 'l' ||
		modifiers.length == 'z')
		tmp = num_string_u_base(num, 8);
	else
		tmp = ft_uitoa_base(num, 8);
	if (modifiers.fl.pound && tmp[0] != '0')
		str = ft_strjoin("0", tmp);
	else
		str = ft_strdup(tmp);
	free(tmp);
	(str[0] == '0' && modifiers.prcsn == 0 &&\
		!modifiers.fl.pound) ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		nbyte += left_justify(modifiers, str, nbyte);
	else
		nbyte += right_justify(modifiers, str, nbyte);
	return ((ft_pipewrench("-s", &str) + nbyte) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0xc(%rbp)
jne 0xe3c1
movq -0x38(%rbp), %rax
movl $0x7a, 0x1c(%rax)
jmp 0xe3c3
jmp 0xe3c3
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xe540
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x6c, 0x1c(%rax)
je 0xe402
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x6c, %eax
je 0xe402
movq -0x38(%rbp), %rax
cmpl $0x7a, 0x1c(%rax)
jne 0xe416
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
jmp 0xe42a
movq -0x18(%rbp), %rax
movl %eax, %edi
movl $0x8, %esi
callq 0x122b0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xe456
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xe456
movq -0x28(%rbp), %rsi
leaq 0x591a(%rip), %rdi      # 0x13d65
callq 0xbc60
movq %rax, -0x30(%rbp)
jmp 0xe463
movq -0x28(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xe495
movq -0x38(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xe495
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xe495
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe497
jmp 0xe497
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xe4db
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xe760
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xe513
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xe860
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq 0x5838(%rip), %rdi      # 0x13d52
leaq -0x30(%rbp), %rsi
movb $0x0, %al
callq 0xa8d0
addl -0x1c(%rbp), %eax
subl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_o.c
// Function: left_justify
static	int		left_justify(t_mods mod, char *num, int nbyte)
{
	int		len;

	len = (int)ft_strlen(num);
	if (mod.fl.fplus)
		nbyte += (int)write(1, "+", 1);
	else if (mod.fl.space)
		nbyte += (int)write(1, " ", 1);
	while (mod.prcsn-- > len)
		nbyte += (int)write(1, "0", 1);
	nbyte += (int)write(1, num, len);
	while (nbyte < mod.width)
		nbyte += (int)write(1, " ", 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
je 0xe7ae
movl $0x1, %edi
leaq 0x5cbd(%rip), %rsi      # 0x14459
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe7d5
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe7d3
movl $0x1, %edi
leaq 0x5b1f(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe7d5
jmp 0xe7d7
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x10(%rbp), %eax
jle 0xe809
movl $0x1, %edi
leaq 0x556e(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe7d7
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0xe84b
movl $0x1, %edi
leaq 0x5aa9(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe821
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_o.c
// Function: right_justify
static	int		right_justify(t_mods mod, char *num, int nbyte)
{
	int		len;

	len = (int)ft_strlen(num);
	nbyte = pad_width(mod, len, nbyte, mod.fl.fplus);
	if (mod.prcsn > len)
		while ((mod.prcsn--) - len > 0)
			nbyte += (int)write(1, "0", 1);
	return (nbyte += (int)write(1, num, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
movl 0xc(%rax), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xe930
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0x18(%rax), %eax
cmpl -0x10(%rbp), %eax
jle 0xe904
jmp 0xe8cd
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
subl -0x10(%rbp), %eax
cmpl $0x0, %eax
jle 0xe902
movl $0x1, %edi
leaq 0x5475(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xe8cd
jmp 0xe904
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_p.c
// Function: convert_p
int				convert_p(t_mods modifiers, va_list ap)
{
	intptr_t	input;
	char		*tmp;
	char		*addr;
	int			nbyte;

	input = va_arg(ap, intptr_t);
	if (input)
	{
		tmp = num_string_u_base(input, 16);
		nbyte = -1;
		while (tmp[++nbyte])
			tmp[nbyte] = ft_tolower(tmp[nbyte]);
		addr = ft_strjoin("0x", tmp);
		free(tmp);
	}
	else
		addr = ft_strdup("0x0");
	if (modifiers.fl.minus == 1)
		nbyte = left_justify(modifiers, addr, 0);
	else
		nbyte = right_justify(modifiers, addr, 0);
	free(addr);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x28, %eax
ja 0xeabf
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0xead6
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeb56
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0xcb10
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xeb37
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa370
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xeb01
movq -0x18(%rbp), %rsi
leaq 0x5919(%rip), %rdi      # 0x1445b
callq 0xbc60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0xeb66
leaq 0x5901(%rip), %rdi      # 0x1445e
callq 0xc1d0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xeba6
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xebf0
movl %eax, -0x24(%rbp)
jmp 0xebda
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xec90
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_p.c
// Function: left_justify
static	int		left_justify(t_mods mod, char *num, int nbyte)
{
	int		len;

	len = (int)ft_strlen(num);
	while (mod.prcsn-- > len)
		nbyte += (int)write(1, "0", 1);
	nbyte += (int)write(1, num, len);
	while (nbyte < mod.width)
		nbyte += (int)write(1, " ", 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x10(%rbp), %eax
jle 0xec45
movl $0x1, %edi
leaq 0x5132(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xec13
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0xec87
movl $0x1, %edi
leaq 0x566d(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xec5d
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_p.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, int neg)
{
	char	*pad_char;

	pad_char = " ";
	if (len > mod.prcsn || mod.prcsn == -1)
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (nbyte == 0)
			{
				while (mod.width - len - neg > nbyte)
					nbyte += (int)write(1, pad_char, 1);
			}
			else
				while (mod.width - len > nbyte)
					nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
		while (mod.width - mod.prcsn - neg > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
leaq 0x5432(%rip), %rax      # 0x142e2
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x18(%rcx), %eax
jg 0xeeca
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xef66
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x4(%rbp), %eax
jle 0xef64
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xeefb
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xeefb
leaq 0x4e70(%rip), %rax      # 0x13d65
movq %rax, -0x18(%rbp)
jmp 0xeefd
jmp 0xeefd
cmpl $0x0, -0x8(%rbp)
jne 0xef34
jmp 0xef05
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xef32
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xef05
jmp 0xef62
jmp 0xef36
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xef60
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xef36
jmp 0xef62
jmp 0xef64
jmp 0xef97
jmp 0xef68
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
subl 0x18(%rcx), %eax
subl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xef95
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xef68
jmp 0xef97
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_s.c
// Function: left_justify
static int	left_justify(t_mods mod, char *s, int len)
{
	int		nbyte;

	nbyte = 0;
	nbyte += (int)write(1, s, len);
	while (nbyte < mod.width)
		nbyte += (int)write(1, " ", 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0xf1f0
movl $0x1, %edi
leaq 0x5104(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xf1c6
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_s.c
// Function: right_justify
static int	right_justify(t_mods mod, char *s, int len)
{
	int		nbyte;

	nbyte = 0;
	if (mod.fl.fzero == 1)
	{
		while (mod.width-- > len)
			nbyte += (int)write(1, "0", 1);
	}
	else
	{
		while (mod.width-- > len)
			nbyte += (int)write(1, " ", 1);
	}
	return (nbyte += (int)write(1, s, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x1, 0x10(%rax)
jne 0xf25a
jmp 0xf226
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl -0xc(%rbp), %eax
jle 0xf258
movl $0x1, %edi
leaq 0x4b1f(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xf226
jmp 0xf290
jmp 0xf25c
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl -0xc(%rbp), %eax
jle 0xf28e
movl $0x1, %edi
leaq 0x5066(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xf25c
jmp 0xf290
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_u.c
// Function: convert_u
int				convert_u(t_mods modifiers, va_list ap, int i)
{
	uint64_t	num;
	int			nbyte;
	char		*str;

	nbyte = 0;
	if (i == 17)
		modifiers.length = 'z';
	num = convert_length(modifiers.length, ap);
	if (modifiers.length == 'l' || modifiers.length / 2 == 'l' ||
		modifiers.length == 'z')
		str = num_string_u_base(num, 10);
	else
		str = ft_uitoa_base(num, 10);
	str[0] == '0' && modifiers.prcsn == 0 ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		nbyte += left_justify(modifiers, str, nbyte);
	else
		nbyte += right_justify(modifiers, str, nbyte);
	if (str)
		free(str);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x11, -0xc(%rbp)
jne 0xf2df
movq -0x30(%rbp), %rax
movl $0x7a, 0x1c(%rax)
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xf400
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x6c, 0x1c(%rax)
je 0xf31e
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x6c, %eax
je 0xf31e
movq -0x30(%rbp), %rax
cmpl $0x7a, 0x1c(%rax)
jne 0xf332
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
jmp 0xf346
movq -0x18(%rbp), %rax
movl %eax, %edi
movl $0xa, %esi
callq 0x122b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xf365
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xf365
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0xf367
jmp 0xf367
movq -0x30(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xf3ab
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xf620
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xf3e3
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xf6c0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xf3f3
movq -0x28(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_x.c
// Function: convert_x
int				convert_x(t_mods modifiers, va_list ap, int i)
{
	uint64_t	num;
	int			nbyte;
	int			len;
	char		*str;

	nbyte = 0;
	len = -1;
	num = convert_length(modifiers.length, ap);
	if (modifiers.length == 'l' || modifiers.length / 2 == 'l' ||
		modifiers.length == 'z')
		str = num_string_u_base(num, 16);
	else
		str = ft_uitoa_base(num, 16);
	if (i == 8)
		while (str[++len])
			str[len] = ft_tolower(str[len]);
	str[0] == '0' && modifiers.prcsn == 0 ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		nbyte += left_justify(modifiers, str, nbyte, i);
	else
		nbyte += right_justify(modifiers, str, nbyte, i);
	if (str)
		free(str);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl 0x1c(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xfa30
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x6c, 0x1c(%rax)
je 0xf900
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x6c, %eax
je 0xf900
movq -0x30(%rbp), %rax
cmpl $0x7a, 0x1c(%rax)
jne 0xf914
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
jmp 0xf928
movq -0x18(%rbp), %rax
movl %eax, %edi
movl $0x10, %esi
callq 0x122b0
movq %rax, -0x28(%rbp)
cmpl $0x8, -0xc(%rbp)
jne 0xf968
jmp 0xf930
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf966
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa370
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf930
jmp 0xf968
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xf987
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xf987
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0xf989
jmp 0xf989
movq -0x30(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xf9d0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xfc50
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xfa0b
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xfd60
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfa1b
movq -0x28(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_x.c
// Function: left_justify
static	int		left_justify(t_mods mod, char *num, int nbyte, int capital)
{
	int		len;

	len = (int)ft_strlen(num);
	if (mod.fl.pound && num[0] != '0' && num[0] != '\0')
	{
		if (capital == 8)
			nbyte += (int)write(1, "0x", 2);
		else
			nbyte += (int)write(1, "0X", 2);
	}
	while (mod.prcsn-- > len)
		nbyte += (int)write(1, "0", 1);
	nbyte += (int)write(1, num, len);
	while (nbyte < mod.width)
		nbyte += (int)write(1, " ", 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
cmpl $0x0, 0x4(%rax)
je 0xfcdd
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xfcdd
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xfcdd
cmpl $0x8, -0x10(%rbp)
jne 0xfcbf
movl $0x1, %edi
leaq 0x47ae(%rip), %rsi      # 0x1445b
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfcdb
movl $0x1, %edi
leaq 0x479e(%rip), %rsi      # 0x14469
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfcdd
jmp 0xfcdf
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x14(%rbp), %eax
jle 0xfd11
movl $0x1, %edi
leaq 0x4066(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfcdf
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0xfd53
movl $0x1, %edi
leaq 0x45a1(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfd29
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_x.c
// Function: right_justify
static	int		right_justify(t_mods mod, char *num, int nbyte, int capital)
{
	int		len;

	len = ft_strlen(num);
	if (mod.fl.pound && num[0] != '0' && num[0] != '\0')
	{
		if (mod.fl.fzero && mod.prcsn == -1)
			nbyte += (int)write(1, capital == 8 ? "0x" : "0X", 2);
		nbyte = pad_width(mod, len, nbyte, num);
		if (!mod.fl.fzero || mod.prcsn > -1)
			nbyte += (int)write(1, capital == 8 ? "0x" : "0X", 2);
	}
	else
		nbyte = pad_width(mod, len, nbyte, num);
	if (mod.prcsn > len)
		while ((mod.prcsn--) - len > 0)
			nbyte += (int)write(1, "0", 1);
	return (nbyte += (int)write(1, num, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
cmpl $0x0, 0x4(%rax)
je 0xfe75
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xfe75
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xfe75
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xfdf8
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xfdf8
movl -0x10(%rbp), %ecx
leaq 0x4694(%rip), %rsi      # 0x14469
leaq 0x467f(%rip), %rax      # 0x1445b
cmpl $0x8, %ecx
cmoveq %rax, %rsi
movl $0x1, %edi
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xff10
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0xc(%rbp)
cmpl $0x0, 0x10(%rax)
je 0xfe46
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jle 0xfe73
movl -0x10(%rbp), %ecx
leaq 0x4619(%rip), %rsi      # 0x14469
leaq 0x4604(%rip), %rax      # 0x1445b
cmpl $0x8, %ecx
cmoveq %rax, %rsi
movl $0x1, %edi
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfead
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xff10
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xfef2
jmp 0xfebb
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jle 0xfef0
movl $0x1, %edi
leaq 0x3e87(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xfebb
jmp 0xfef2
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_percent.c
// Function: convert_percent
int				convert_percent(t_mods modifiers)
{
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(modifiers.width, modifiers.fl.fzero));
	}
	return ((int)write(1, "%", 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x100c7
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x10110
movl %eax, -0x4(%rbp)
jmp 0x100fe
movq -0x10(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jle 0x100e5
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
movl 0x10(%rax), %esi
callq 0x10170
movl %eax, -0x4(%rbp)
jmp 0x100fe
movl $0x1, %edi
leaq 0x437b(%rip), %rsi      # 0x1446c
movl $0x1, %edx
callq 0x1050
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_percent.c
// Function: left_justify
static int		left_justify(int width)
{
	int		n;

	n = (int)write(1, "%", 1);
	if (n < width)
		while (n < width)
			n += (int)write(1, " ", 1);
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
leaq 0x4345(%rip), %rsi      # 0x1446c
movl $0x1, %edx
callq 0x1050
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x10166
jmp 0x1013e
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x10164
movl $0x1, %edi
leaq 0x4190(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x1013e
jmp 0x10166
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/get_mod.c
// Function: get_mod
t_mod			get_mod(char **str, va_list ap)
{
	t_mod modifiers;

	modifiers.fl = get_flags(str);
	modifiers.width = get_width(str, ap);
	if (modifiers.width < 0)
	{
		modifiers.width *= -1;
		modifiers.fl.minus = 1;
	}
	modifiers.prcsn = get_precision(str, ap);
	modifiers.length = get_length(str);
	return (modifiers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x24(%rbp), %rdi
callq 0x102c0
movq -0x30(%rbp), %rdi
movq -0x24(%rbp), %rax
movq %rax, (%rdi)
movq -0x1c(%rbp), %rax
movq %rax, 0x8(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x10(%rdi)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x103c0
movq -0x30(%rbp), %rdi
movl %eax, 0x14(%rdi)
cmpl $0x0, 0x14(%rdi)
jge 0x1028a
movq -0x30(%rbp), %rax
imull $-0x1, 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10500
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x10610
movq -0x30(%rbp), %rcx
movl %eax, %edx
movq -0x38(%rbp), %rax
movl %edx, 0x1c(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/get_mod.c
// Function: get_flags
static t_fl		get_flags(char **str)
{
	t_fl	flag;

	flag.space = 0;
	flag.pound = 0;
	flag.fplus = 0;
	flag.minus = 0;
	flag.fzero = 0;
	while (is_flag(**str))
	{
		if (**str == ' ')
			flag.space = 1;
		else if (**str == '#')
			flag.pound = 1;
		else if (**str == '+')
			flag.fplus = 1;
		else if (**str == '-')
			flag.minus = 1;
		else if (**str == '0')
			flag.fzero = 1;
		(*str)++;
	}
	return (flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xc890
cmpl $0x0, %eax
je 0x103b5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1032c
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x103a2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x10348
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0x103a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x10364
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
jmp 0x1039e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x10380
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x1039c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x1039a
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x1039c
jmp 0x1039e
jmp 0x103a0
jmp 0x103a2
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x102f9
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: ft_padding
int				ft_padding(char *buf, int len, t_mod mod, int nbyte)
{
	char	*pad_char;

	if ((pad_char = " ") && (len > mod.prcsn || mod.prcsn == -1))
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (!nbyte)
			{
				if (mod.fl.space && mod.fl.fzero)
					add_one_to_buf(&buf, *pad_char, &nbyte);
				while (mod.width - len - mod.neg > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
			else
			{
				while (mod.width - len > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
		}
	}
	else
		while (mod.width - mod.prcsn - mod.neg > nbyte)
			add_one_to_buf(&buf, *pad_char, &nbyte);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x3aa1(%rip), %rax      # 0x142e2
movq %rax, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x10850
jmp 0x10923
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jg 0x1086a
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x10923
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x10921
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1089b
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0x1089b
leaq 0x34d0(%rip), %rax      # 0x13d65
movq %rax, -0x18(%rbp)
jmp 0x1089d
jmp 0x1089d
cmpl $0x0, -0x10(%rbp)
jne 0x108f6
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x108ca
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x108ca
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x10780
jmp 0x108cc
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
subl -0xc(%rbp), %eax
subl 0x20(%rcx), %eax
cmpl -0x10(%rbp), %eax
jle 0x108f4
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x10780
jmp 0x108cc
jmp 0x1091f
jmp 0x108f8
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x1091d
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x10780
jmp 0x108f8
jmp 0x1091f
jmp 0x10921
jmp 0x1094f
jmp 0x10925
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
subl 0x18(%rcx), %eax
subl 0x20(%rcx), %eax
cmpl -0x10(%rbp), %eax
jle 0x1094d
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0x10780
jmp 0x10925
jmp 0x1094f
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: left_jut
void			left_jut(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	if ((len = (int)ft_strlen(num)) && mod.neg == 1)
		ft_strcpy(buf, "-");
	else if (mod.neg == 0)
	{
		if (mod.fl.fplus)
			ft_strcpy(buf, "+");
		else if (mod.fl.space)
			ft_strcpy(buf, "-");
	}
	buf++;
	while (mod.prcsn-- > len)
	{
		ft_strcpy(buf, "0");
		buf++;
	}
	add_to_buf(&buf, num, &nbyte, len);
	while (nbyte < mod.width)
	{
		add_one_to_buf(&buf, ' ', &nbyte);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x109a8
movq -0x20(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x109a8
movq -0x8(%rbp), %rdi
leaq 0x3ab6(%rip), %rsi      # 0x14457
callq 0xbac0
jmp 0x109ed
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x109eb
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x109ce
movq -0x8(%rbp), %rdi
leaq 0x3a92(%rip), %rsi      # 0x14459
callq 0xbac0
jmp 0x109e9
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x109e7
movq -0x8(%rbp), %rdi
leaq 0x3a75(%rip), %rsi      # 0x14457
callq 0xbac0
jmp 0x109e9
jmp 0x109eb
jmp 0x109ed
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x18(%rbp), %eax
jle 0x10a2b
movq -0x8(%rbp), %rdi
leaq 0x334d(%rip), %rsi      # 0x13d65
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x109f9
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0x107d0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x10a5f
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x14(%rbp), %rdx
callq 0x10780
jmp 0x10a3f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/c_to_buf.c
// Function: c_to_buf
int				c_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	char	c;
	int		n;

	c = va_arg(ap, int);
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(buf, c, modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(buf, c, modifiers.width, modifiers.fl.fzero));
	}
	n = 0;
	add_one_to_buf(&buf, c, &n);
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x28, %eax
ja 0x10ab3
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x10aca
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
movb %cl, -0x19(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x10af8
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movl 0x14(%rcx), %edx
movsbl %al, %esi
callq 0x10b50
movl %eax, -0x4(%rbp)
jmp 0x10b3e
movq -0x38(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jle 0x10b20
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movl 0x14(%rcx), %edx
movl 0x10(%rcx), %ecx
movsbl %al, %esi
callq 0x10bb0
movl %eax, -0x4(%rbp)
jmp 0x10b3e
movl $0x0, -0x20(%rbp)
movsbl -0x19(%rbp), %esi
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0x10780
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/c_to_buf.c
// Function: left_justify
static int		left_justify(char *buf, char c, int width)
{
	int		n;

	n = 0;
	add_one_to_buf(&buf, c, &n);
	if (n < width)
		while (n < width)
		{
			add_one_to_buf(&buf, ' ', &n);
		}
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movsbl -0x9(%rbp), %esi
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0x10780
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x10ba5
jmp 0x10b87
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x10ba3
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x14(%rbp), %rdx
callq 0x10780
jmp 0x10b87
jmp 0x10ba5
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/c_to_buf.c
// Function: right_justify
static int		right_justify(char *buf, char c, int width, int fzero)
{
	int		n;

	n = 0;
	if (fzero)
	{
		while (width-- > 1)
		{
			add_one_to_buf(&buf, '0', &n);
		}
	}
	else
	{
		while (width-- > 1)
		{
			add_one_to_buf(&buf, ' ', &n);
		}
	}
	add_one_to_buf(&buf, c, &n);
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x10bfd
jmp 0x10bd7
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x1, %eax
jle 0x10bfb
leaq -0x8(%rbp), %rdi
movl $0x30, %esi
leaq -0x18(%rbp), %rdx
callq 0x10780
jmp 0x10bd7
jmp 0x10c25
jmp 0x10bff
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x1, %eax
jle 0x10c23
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x18(%rbp), %rdx
callq 0x10780
jmp 0x10bff
jmp 0x10c25
movsbl -0x9(%rbp), %esi
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x10780
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/i_to_buf.c
// Function: i_to_buf
int				i_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	int64_t	num;
	char	*str;

	num = convert_length(modifiers.length, ap);
	modifiers.neg = (num < 0) ? 1 : 0;
	modifiers.neg == 1 ? num *= -1 : 0;
	str = num_string_base(num, 10);
	str[0] == '0' && modifiers.prcsn == 0 ? str[0] = '\0' : 0;
	if (modifiers.fl.minus == 1)
		left_jut(buf, str, modifiers, 0);
	else
		right_justify(buf, str, modifiers, 0);
	free(str);
	return (ft_strlen(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x10d50
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
xorl %ecx, %ecx
movl $0x1, %edx
cmpq $0x0, %rsi
cmovll %edx, %ecx
movl %ecx, 0x20(%rax)
cmpl $0x1, 0x20(%rax)
jne 0x10c95
imulq $-0x1, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x10c97
jmp 0x10c97
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0xcbf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x10cc8
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x10cc8
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x10cca
jmp 0x10cca
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x10d02
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %edx, %edx
callq 0x10960
jmp 0x10d2e
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorl %edx, %edx
callq 0x10f70
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0xbf10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/i_to_buf.c
// Function: right_justify
static void		right_justify(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	if (mod.neg == 1)
		neg_justify(buf, mod, num);
	else if (mod.neg == 0)
		pos_justify(buf, mod, ft_strlen(num));
	if (mod.prcsn > (len = ft_strlen(num)))
	{
		while ((mod.prcsn--) - len > 0)
		{
			ft_strcpy(buf, "0");
			buf++;
		}
	}
	nbyte = ft_strlen(buf);
	ft_strncpy(buf + nbyte, num, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, 0x20(%rax)
jne 0x10fbb
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11090
jmp 0x10ffe
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x10ffc
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdi
movl %eax, %esi
movl 0x20(%rcx), %edx
movq %rsp, %rax
movl %edx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x11180
jmp 0x10ffe
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movl %ecx, -0x18(%rbp)
cmpl %ecx, %eax
jle 0x11057
jmp 0x11020
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
subl -0x18(%rbp), %eax
cmpl $0x0, %eax
jle 0x11055
movq -0x8(%rbp), %rdi
leaq 0x2d23(%rip), %rsi      # 0x13d65
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11020
jmp 0x11057
movq -0x8(%rbp), %rdi
callq 0xbf10
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0xbb20
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/i_to_buf.c
// Function: neg_justify
static void		neg_justify(char *buf, t_mod mod, char *num)
{
	int		nbyte;

	nbyte = 0;
	if (mod.fl.fzero && mod.prcsn < 0 && mod.width > (int)ft_strlen(num))
	{
		ft_strcpy(buf, "-");
		buf++;
		nbyte++;
	}
	nbyte = ft_padding(buf, ft_strlen(num), mod, nbyte);
	if (!mod.fl.fzero || mod.prcsn > 0 || !nbyte)
	{
		ft_strcpy(buf, "-");
		buf++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, 0x10(%rax)
je 0x11101
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jge 0x11101
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jle 0x11101
movq -0x8(%rbp), %rdi
leaq 0x3370(%rip), %rsi      # 0x14457
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl %eax, %esi
movl -0x14(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10820
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
cmpl $0x0, 0x10(%rax)
je 0x1115c
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jg 0x1115c
cmpl $0x0, -0x14(%rbp)
jne 0x11178
movq -0x8(%rbp), %rdi
leaq 0x32f0(%rip), %rsi      # 0x14457
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/i_to_buf.c
// Function: pos_justify
static void		pos_justify(char *buf, t_mod mod, int len)
{
	int		nbyte;

	nbyte = 0;
	if (mod.fl.fplus && mod.fl.fzero && mod.prcsn < 0 &&
		mod.width > len && (mod.fl.space = -1))
	{
		ft_strcpy(buf, "+");
		buf++;
		nbyte++;
	}
	mod.neg = mod.fl.fplus;
	nbyte = ft_padding(buf, len, mod, nbyte);
	if ((mod.fl.fplus && mod.fl.space != -1))
	{
		ft_strcpy(buf, "+");
		buf++;
		nbyte++;
	}
	if (!mod.fl.fplus && mod.fl.space && !nbyte)
	{
		ft_strcpy(buf, " ");
		buf++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x111fb
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x111fb
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jge 0x111fb
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x111fb
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movb $0x1, %al
testb $0x1, %al
jne 0x111d6
jmp 0x111fb
movq -0x8(%rbp), %rdi
leaq 0x3278(%rip), %rsi      # 0x14459
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
movl %eax, 0x20(%rcx)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl 0x20(%rcx), %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x10820
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x1126a
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x1126a
movq -0x8(%rbp), %rdi
leaq 0x3209(%rip), %rsi      # 0x14459
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1129f
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1129f
cmpl $0x0, -0x10(%rbp)
jne 0x1129f
movq -0x8(%rbp), %rdi
leaq 0x3054(%rip), %rsi      # 0x142e2
callq 0xbac0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/s_to_buf.c
// Function: left_justify
static int	left_justify(char *buf, char *s, int len, t_mod mod)
{
	int		nbyte;

	nbyte = 0;
	add_to_buf(&buf, s, &nbyte, len);
	while (nbyte < mod.width)
	{
		add_one_to_buf(&buf, ' ', &nbyte);
	}
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x107d0
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x114e6
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x18(%rbp), %rdx
callq 0x10780
jmp 0x114c6
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/s_to_buf.c
// Function: right_justify
static int	right_justify(char *buf, char *s, int len, t_mod mod)
{
	int		nbyte;

	nbyte = 0;
	if (mod.fl.fzero == 1)
	{
		while (mod.width-- > len)
		{
			add_one_to_buf(&buf, '0', &nbyte);
		}
	}
	else
	{
		while (mod.width-- > len)
		{
			add_one_to_buf(&buf, ' ', &nbyte);
		}
	}
	add_to_buf(&buf, s, &nbyte, len);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, 0x10(%rax)
jne 0x11544
jmp 0x1151a
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl -0x14(%rbp), %eax
jle 0x11542
leaq -0x8(%rbp), %rdi
movl $0x30, %esi
leaq -0x18(%rbp), %rdx
callq 0x10780
jmp 0x1151a
jmp 0x11570
jmp 0x11546
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl -0x14(%rbp), %eax
jle 0x1156e
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
leaq -0x18(%rbp), %rdx
callq 0x10780
jmp 0x11546
jmp 0x11570
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x107d0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)