LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strndup
char	*ft_strndup(const char *s, size_t len)
{
	char	*dup;

	if (!s)
		return (NULL);
	if (!(dup = (char *)malloc(len + 1)))
		return (NULL);
	dup[len] = '\0';
	while (len-- > 0)
		dup[len] = s[len];
	return (dup);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc2a1
movq $0x0, -0x8(%rbp)
jmp 0xc303
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc2c2
movq $0x0, -0x8(%rbp)
jmp 0xc303
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
jbe 0xc2fb
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xc2ce
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_countwords
int				ft_countwords(char const *str, char c)
{
	int count;
	int	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xc3d6
jmp 0xc340
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xc35f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc340
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xc38d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xc38d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc38f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
je 0xc3bd
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xc3c6
jmp 0xc3d1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc38f
jmp 0xc32c
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char	**arr;
	int		i;
	int		j;

	if (!s || !(arr = (char **)malloc(sizeof(*arr) * ft_countwords(s, c) + 1)))
		return (NULL);
	i = -1;
	j = 0;
	while (++i < ft_countwords(s, c))
	{
		while (s[j] == c)
			j++;
		if (!(arr[i] = ft_strsub(s, j, word_len(&s[j], c))))
			arr[i] = NULL;
		j += (int)word_len(&s[j], c);
	}
	arr[i] = 0;
	return (arr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc420
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0xc310
movslq %eax, %rdi
shlq $0x3, %rdi
addq $0x1, %rdi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc42d
movq $0x0, -0x8(%rbp)
jmp 0xc50c
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0xc310
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0xc4f4
jmp 0xc463
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0xc482
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xc463
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0xc520
movq -0x38(%rbp), %rdi
movl -0x30(%rbp), %esi
movq %rax, %rdx
callq 0xc110
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xc4d5
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0xc520
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xc43b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: word_len
static size_t	word_len(char const *str, char c)
{
	size_t	i;
	size_t	len;

	i = 0;
	len = 0;
	while (str[i] == c)
		i++;
	while (str[i] != c && str[i])
	{
		i++;
		len++;
	}
	return (len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xc560
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc53e
jmp 0xc562
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
je 0xc590
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xc599
jmp 0xc5b3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc562
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strtrim
char			*ft_strtrim(char const *s)
{
	char	*new;
	size_t	start;
	size_t	end;
	size_t	new_len;

	if (!s)
		return (NULL);
	start = 0;
	end = ft_strlen(s) - 1;
	if (!has_whitespace((char *)s, &start, &end))
		return (ft_strdup(s));
	new_len = (start == ft_strlen(s)) ? 0 : ft_strlen(s) - start - \
											(ft_strlen(s) - end);
	if (!(new = ft_strnew(new_len + 1)))
		return (NULL);
	ft_strncpy(new, &s[start], new_len + 1);
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc5e0
movq $0x0, -0x8(%rbp)
jmp 0xc6bc
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xc6d0
cmpl $0x0, %eax
jne 0xc621
movq -0x10(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x8(%rbp)
jmp 0xc6bc
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0xc646
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xc672
movq -0x10(%rbp), %rdi
callq 0xbf10
subq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
callq 0xc020
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xc69b
movq $0x0, -0x8(%rbp)
jmp 0xc6bc
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
callq 0xbb20
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: has_whitespace
static int		has_whitespace(char *str, size_t *i, size_t *j)
{
	while (str[*i] == ' ' || str[*i] == '\t' || str[*i] == '\r' ||\
		str[*i] == '\f' || str[*i] == '\n' || *i > ft_strlen(str))
		(*i)++;
	while (str[*i] == ' ' || str[*i] == '\t' || str[*i] == '\r' ||\
		str[*i] == '\f' || str[*j] == '\n')
		(*j)--;
	if (*i || *j < ft_strlen(str))
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
je 0xc789
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x21(%rbp)
je 0xc789
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x21(%rbp)
je 0xc789
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x21(%rbp)
je 0xc789
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0xc789
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xc792
jmp 0xc7a5
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xc6e4
jmp 0xc7a7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x31(%rbp)
je 0xc823
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x31(%rbp)
je 0xc823
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x31(%rbp)
je 0xc823
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x31(%rbp)
je 0xc823
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc82c
jmp 0xc83f
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0xc7a7
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc869
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xc872
movl $0x1, -0x4(%rbp)
jmp 0xc879
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/finders.c
// Function: get_undef_length
int		get_undef_length(char x)
{
	if (x == 'z' || x == 'j')
		return (1);
	if (x == 'h' || x == 'l')
		return (2);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
je 0xc90c
movsbl -0x5(%rbp), %eax
cmpl $0x6a, %eax
jne 0xc915
movl $0x1, -0x4(%rbp)
jmp 0xc937
movsbl -0x5(%rbp), %eax
cmpl $0x68, %eax
je 0xc927
movsbl -0x5(%rbp), %eax
cmpl $0x6c, %eax
jne 0xc930
movl $0x2, -0x4(%rbp)
jmp 0xc937
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/finders.c
// Function: get_type_specifier
int		get_type_specifier(char x)
{
	char	*str;
	int		i;

	i = -1;
	str = "%dcspouxfb";
	while (str[++i])
		if (x == str[i])
			return (i + 1);
	str = ".i...OUXFB";
	while (--i >= 0)
		if (x == str[i])
			return (i + 11);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq 0x7abc(%rip), %rax      # 0x14414
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xc993
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xc991
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xc9d4
jmp 0xc95c
leaq 0x7a85(%rip), %rax      # 0x1441f
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0xc9cd
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xc9cb
movl -0x14(%rbp), %eax
addl $0xb, %eax
movl %eax, -0x4(%rbp)
jmp 0xc9d4
jmp 0xc99e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: get_pre_float
int			get_pre_float(long double number, int ret)
{
	long double		tmp;

	tmp = number - (int)number;
	tmp = number - tmp;
	ret = (int)tmp;
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
fldt 0x10(%rbp)
fstpt -0x10(%rbp)
movl %edi, -0x14(%rbp)
fldt -0x10(%rbp)
fnstcw -0x3e(%rbp)
movzwl -0x3e(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x40(%rbp)
fldcw -0x40(%rbp)
fistl -0x3c(%rbp)
fldcw -0x3e(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
fildl -0x38(%rbp)
fsubrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x10(%rbp)
fldt -0x30(%rbp)
fsubrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
fnstcw -0x42(%rbp)
movzwl -0x42(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x44(%rbp)
fldcw -0x44(%rbp)
fistpl -0x34(%rbp)
fldcw -0x42(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: set_flags
void		set_flags(t_flag *fl, char c)
{
	if (c == ' ')
		fl->space = 1;
	else if (c == '#')
		fl->pound = 1;
	else if (c == '+')
		fl->fplus = 1;
	else if (c == '-')
		fl->minus = 1;
	else if (c == '0')
		fl->fzero = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jne 0xcaa3
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
jmp 0xcb01
movsbl -0x9(%rbp), %eax
cmpl $0x23, %eax
jne 0xcab9
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0xcaff
movsbl -0x9(%rbp), %eax
cmpl $0x2b, %eax
jne 0xcacf
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
jmp 0xcafd
movsbl -0x9(%rbp), %eax
cmpl $0x2d, %eax
jne 0xcae5
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0xcafb
movsbl -0x9(%rbp), %eax
cmpl $0x30, %eax
jne 0xcaf9
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0xcafb
jmp 0xcafd
jmp 0xcaff
jmp 0xcb01
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_u_base
char		*num_string_u_base(unsigned long long num, int base)
{
	unsigned long long	tmp;
	int					len;
	char				*str;

	len = 0;
	tmp = num;
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcb4e
leaq 0x7229(%rip), %rdi      # 0x13d65
callq 0xc1d0
movq %rax, -0x30(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xcbe6
jmp 0xcb50
cmpq $0x0, -0x20(%rbp)
jbe 0xcb73
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
jmp 0xcb50
movslq -0x24(%rbp), %rdi
callq 0xc020
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xcb90
movq $0x0, -0x8(%rbp)
jmp 0xcbe6
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xcbde
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
leaq 0x788c(%rip), %rax      # 0x14440
movb (%rax,%rdx), %dl
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcb99
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_base
char		*num_string_base(long long num, int base)
{
	long long	tmp;
	int			len;
	char		*str;

	len = 0;
	tmp = num;
	if ((tmp + 1) * -1 == 9223372036854775807)
		return ((str = ft_strdup("9223372036854775808")));
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
imulq $-0x1, %rax, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0xcc42
leaq 0x77fa(%rip), %rdi      # 0x1442a
callq 0xc1d0
movq %rax, -0x30(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xccfa
cmpq $0x0, -0x20(%rbp)
jne 0xcc62
leaq 0x7115(%rip), %rdi      # 0x13d65
callq 0xc1d0
movq %rax, -0x30(%rbp)
movq %rax, -0x8(%rbp)
jmp 0xccfa
jmp 0xcc64
cmpq $0x0, -0x20(%rbp)
jle 0xcc87
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
jmp 0xcc64
movslq -0x24(%rbp), %rdi
callq 0xc020
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xcca4
movq $0x0, -0x8(%rbp)
jmp 0xccfa
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0xccf2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
leaq 0x7778(%rip), %rax      # 0x14440
movb (%rax,%rdx), %dl
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xccad
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/get_mods.c
// Function: get_mods
t_mods			get_mods(char **str, va_list ap)
{
	t_mods 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 0xcdb0
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 0xce30
movq -0x30(%rbp), %rdi
movl %eax, 0x14(%rdi)
cmpl $0x0, 0x14(%rdi)
jge 0xcd7a
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 0xcf70
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0xd080
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_printf/get_mods.c
// Function: get_flags
static t_flag	get_flags(char **str)
{
	t_flag	flags;

	flags.space = 0;
	flags.pound = 0;
	flags.fplus = 0;
	flags.minus = 0;
	flags.fzero = 0;
	while (is_flag(**str))
	{
		set_flags(&flags, **str);
		(*str)++;
	}
	return (flags);
}

// 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 0xce20
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
callq 0xca80
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xcde9
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/get_mods.c
// Function: get_width
static int		get_width(char **str, va_list ap)
{
	int		width;

	width = 0;
	if (**str == '*')
	{
		width = va_arg(ap, int);
		(*str)++;
	}
	if (ft_isdigit(**str))
	{
		width = ft_atoi(*str);
		while (ft_isdigit(**str))
			(*str)++;
	}
	if (**str == '*')
	{
		width = va_arg(ap, int);
		(*str)++;
	}
	return (width);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0xceaf
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x28, %eax
ja 0xce81
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xce98
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, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0xcef8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa0a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0xcef6
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xced2
jmp 0xcef8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0xcf60
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x28, %eax
ja 0xcf32
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0xcf49
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/get_mods.c
// Function: get_precision
static int		get_precision(char **str, va_list ap)
{
	int		precision;

	precision = -1;
	if (**str == '.')
	{
		precision = 0;
		(*str)++;
		if (ft_isdigit(**str))
		{
			precision = ft_atoi(*str);
			while (ft_isdigit(**str))
				(*str)++;
		}
		else if (**str == '*')
		{
			precision = va_arg(ap, int);
			(*str)++;
		}
		if (precision < 0)
			precision = -1;
	}
	return (precision);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xd071
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0xcff8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa0a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0xcff6
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xcfd2
jmp 0xd062
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0xd060
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x28, %eax
ja 0xd032
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0xd049
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, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xd062
cmpl $0x0, -0x14(%rbp)
jge 0xd06f
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0xd071
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/get_mods.c
// Function: get_length
static int		get_length(char **str)
{
	int		length;

	length = 0;
	if (**str == 'L')
		length = (int)'L';
	else if (**str == 'h' && *(*str + 1) != 'h')
		length = (int)'h';
	else if (**str == 'h' && *(*str + 1) == 'h')
		length = (int)('h' + 'h');
	else if (**str == 'l' && *(*str + 1) != 'l')
		length = (int)'l';
	else if (**str == 'l' && *(*str + 1) == 'l')
		length = (int)('l' + 'l');
	else if (get_undef_length(**str))
		length = (int)('z');
	if (length > 0)
	{
		if (length >= 'h' + 'h')
			(*str) += 2;
		else
			(*str) += 1;
	}
	while (length && get_undef_length(**str))
		(*str) += 1;
	return (length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0xd0ae
movl $0x4c, -0xc(%rbp)
jmp 0xd176
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
jne 0xd0d9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x68, %eax
je 0xd0d9
movl $0x68, -0xc(%rbp)
jmp 0xd174
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
jne 0xd101
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x68, %eax
jne 0xd101
movl $0xd0, -0xc(%rbp)
jmp 0xd172
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0xd129
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6c, %eax
je 0xd129
movl $0x6c, -0xc(%rbp)
jmp 0xd170
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0xd151
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6c, %eax
jne 0xd151
movl $0xd8, -0xc(%rbp)
jmp 0xd16e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xc8f0
cmpl $0x0, %eax
je 0xd16c
movl $0x7a, -0xc(%rbp)
jmp 0xd16e
jmp 0xd170
jmp 0xd172
jmp 0xd174
jmp 0xd176
cmpl $0x0, -0xc(%rbp)
jle 0xd1a5
cmpl $0xd0, -0xc(%rbp)
jl 0xd195
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0xd1a3
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xd1a5
jmp 0xd1a7
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
je 0xd1ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xc8f0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0xd1d3
jmp 0xd1e3
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xd1a7
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_b.c
// Function: convert_b
int				convert_b(t_mods modifiers, va_list ap, int i)
{
	uint64_t	num;
	int			nbyte;
	char		*str;

	nbyte = 0;
	num = convert_length(modifiers.length, ap);
	if (modifiers.length == 'l' || modifiers.length / 2 == 'l' ||
		modifiers.length == 'z')
		str = num_string_u_base(num, 2);
	else
		str = ft_uitoa_base(num, 2);
	num == 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 0x1c(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xd330
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x6c, 0x1c(%rax)
je 0xd249
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x6c, %eax
je 0xd249
movq -0x30(%rbp), %rax
cmpl $0x7a, 0x1c(%rax)
jne 0xd25d
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0xcb10
movq %rax, -0x28(%rbp)
jmp 0xd271
movq -0x18(%rbp), %rax
movl %eax, %edi
movl $0x2, %esi
callq 0x122b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd28b
movq -0x30(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xd28b
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
jmp 0xd28d
jmp 0xd28d
movq -0x30(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xd2d4
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 0xd550
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xd30f
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 0xd650
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd31f
movq -0x28(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_b.c
// Function: left_justify
static	int		left_justify(t_mods mod, char *num, int nbyte, int capital)
{
	int		len;

	len = ft_strlen(num);
	if (mod.fl.pound && num[0] != '\0')
	{
		if (capital == 20)
			nbyte += (int)write(1, "0B", 2);
		else
			nbyte += (int)write(1, "0b", 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 0xd5d1
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd5d1
cmpl $0x14, -0x10(%rbp)
jne 0xd5b3
movl $0x1, %edi
leaq 0x6eb0(%rip), %rsi      # 0x14451
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd5cf
movl $0x1, %edi
leaq 0x6e95(%rip), %rsi      # 0x14454
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd5d1
jmp 0xd5d3
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x14(%rbp), %eax
jle 0xd605
movl $0x1, %edi
leaq 0x6772(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd5d3
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 0xd647
movl $0x1, %edi
leaq 0x6cad(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd61d
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_b.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')
	{
		if (mod.fl.fzero && mod.prcsn == -1)
			nbyte += (int)write(1, capital == 10 ? "0b" : "0B", 2);
		nbyte = pad_width(mod, len, nbyte, num);
		if (!mod.fl.fzero || mod.prcsn > -1)
			nbyte += (int)write(1, capital == 10 ? "0b" : "0B", 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 0xd755
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xd755
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xd6d8
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xd6d8
movl -0x10(%rbp), %ecx
leaq 0x6d9c(%rip), %rsi      # 0x14451
leaq 0x6d98(%rip), %rax      # 0x14454
cmpl $0xa, %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 0xd7f0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0xc(%rbp)
cmpl $0x0, 0x10(%rax)
je 0xd726
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jle 0xd753
movl -0x10(%rbp), %ecx
leaq 0x6d21(%rip), %rsi      # 0x14451
leaq 0x6d1d(%rip), %rax      # 0x14454
cmpl $0xa, %ecx
cmoveq %rax, %rsi
movl $0x1, %edi
movl $0x2, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd78d
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 0xd7f0
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0xd7d2
jmp 0xd79b
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 0xd7d0
movl $0x1, %edi
leaq 0x65a7(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd79b
jmp 0xd7d2
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_b.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, char *num)
{
	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 (mod.fl.space && mod.fl.fzero && !nbyte)
				nbyte += write(1, " ", 1);
			if (mod.fl.pound && !nbyte && num[0] != '0')
				len += 2;
			while (mod.width - len > nbyte)
				nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
	{
		if (mod.fl.pound && !nbyte && num[0] == '\0')
			;
		else if (mod.fl.pound && !nbyte)
			mod.prcsn += 2;
		while (mod.width - mod.prcsn > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	}
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x6ad1(%rip), %rax      # 0x142e2
movq %rax, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xd820
jmp 0xd8fe
movq -0x20(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x18(%rcx), %eax
jg 0xd83a
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xd8fe
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x4(%rbp), %eax
jle 0xd8fc
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xd86b
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xd86b
leaq 0x6500(%rip), %rax      # 0x13d65
movq %rax, -0x18(%rbp)
jmp 0xd86d
jmp 0xd86d
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xd8a9
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xd8a9
cmpl $0x0, -0x8(%rbp)
jne 0xd8a9
movl $0x1, %edi
leaq 0x6a50(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
movq %rax, %rcx
movslq -0x8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xd8ce
cmpl $0x0, -0x8(%rbp)
jne 0xd8ce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xd8ce
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0xd8d0
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xd8fa
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xd8d0
jmp 0xd8fc
jmp 0xd969
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xd91c
cmpl $0x0, -0x8(%rbp)
jne 0xd91c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xd91c
jmp 0xd93b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xd939
cmpl $0x0, -0x8(%rbp)
jne 0xd939
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x18(%rax)
jmp 0xd93b
jmp 0xd93d
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
subl 0x18(%rcx), %eax
cmpl -0x8(%rbp), %eax
jle 0xd967
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xd93d
jmp 0xd969
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_c.c
// Function: convert_c
int				convert_c(t_mods modifiers, va_list ap)
{
	unsigned char	c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x28, %eax
ja 0xd9bf
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0xd9d6
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movb %cl, -0x11(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0xd9fe
movq -0x28(%rbp), %rax
movl 0x14(%rax), %edi
movzbl -0x11(%rbp), %esi
callq 0xda40
movl %eax, -0x4(%rbp)
jmp 0xda36
movq -0x28(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jle 0xda20
movq -0x28(%rbp), %rax
movl 0x14(%rax), %edi
movl 0x10(%rax), %esi
movzbl -0x11(%rbp), %edx
callq 0xdab0
movl %eax, -0x4(%rbp)
jmp 0xda36
movl $0x1, %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1050
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_c.c
// Function: left_justify
static int		left_justify(int width, unsigned char c)
{
	int		n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl $0x1, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x1050
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xda99
jmp 0xda71
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xda97
movl $0x1, %edi
leaq 0x685d(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xda71
jmp 0xda99
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_c.c
// Function: right_justify
static int		right_justify(int width, int fzero, unsigned char c)
{
	int		n;

	n = 0;
	if (fzero)
	{
		while (width-- > 1)
			n += (int)write(1, "0", 1);
	}
	else
	{
		while (width-- > 1)
			n += (int)write(1, " ", 1);
	}
	n += (int)write(1, &c, 1);
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xdb02
jmp 0xdad2
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x1, %eax
jle 0xdb00
movl $0x1, %edi
leaq 0x6277(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xdad2
jmp 0xdb34
jmp 0xdb04
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x1, %eax
jle 0xdb32
movl $0x1, %edi
leaq 0x67c2(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xdb04
jmp 0xdb34
movl $0x1, %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x1050
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_i.c
// Function: convert_i
int				convert_i(t_mods modifiers, va_list ap)
{
	int64_t	num;
	int		nbyte;
	int		neg;
	char	*str;

	nbyte = 0;
	num = convert_length(modifiers.length, ap);
	neg = (num < 0) ? 1 : 0;
	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)
		nbyte += left_justify(modifiers, str, nbyte, neg);
	else
		nbyte += right_justify(modifiers, str, nbyte, neg);
	return ((ft_pipewrench("-s", &str) + nbyte) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl 0x1c(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0xdca0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovll %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0xdbc1
imulq $-0x1, -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xdbc3
jmp 0xdbc3
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0xcbf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xdbf4
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xdbf4
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0xdbf6
jmp 0xdbf6
movq -0x28(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xdc3d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%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 0xdec0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xdc78
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%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 0xdff0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq 0x60d3(%rip), %rdi      # 0x13d52
leaq -0x20(%rbp), %rsi
movb $0x0, %al
callq 0xa8d0
addl -0x14(%rbp), %eax
subl $0x1, %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_i.c
// Function: left_justify
static	int		left_justify(t_mods mod, char *num, int nbyte, int neg)
{
	int		len;

	len = (int)ft_strlen(num);
	if (neg == 1)
		nbyte += (int)write(1, "-", 1);
	else if (neg == 0)
	{
		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, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf10
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x10(%rbp)
jne 0xdf0a
movl $0x1, %edi
leaq 0x655f(%rip), %rsi      # 0x14457
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xdf63
cmpl $0x0, -0x10(%rbp)
jne 0xdf61
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0xdf38
movl $0x1, %edi
leaq 0x6533(%rip), %rsi      # 0x14459
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xdf5f
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xdf5d
movl $0x1, %edi
leaq 0x6395(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xdf5f
jmp 0xdf61
jmp 0xdf63
jmp 0xdf65
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x18(%rcx)
cmpl -0x14(%rbp), %eax
jle 0xdf97
movl $0x1, %edi
leaq 0x5de0(%rip), %rsi      # 0x13d65
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xdf65
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 0xdfd9
movl $0x1, %edi
leaq 0x631b(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xdfaf
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_i.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)
			{
				if (mod.fl.space && mod.fl.fzero)
					nbyte += write(1, " ", 1);
				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 0x6082(%rip), %rax      # 0x142e2
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x18(%rcx), %eax
jg 0xe27a
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xe34c
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x4(%rbp), %eax
jle 0xe34a
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xe2ab
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x18(%rax)
jne 0xe2ab
leaq 0x5ac0(%rip), %rax      # 0x13d65
movq %rax, -0x18(%rbp)
jmp 0xe2ad
jmp 0xe2ad
cmpl $0x0, -0x8(%rbp)
jne 0xe31a
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe2e9
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xe2e9
movl $0x1, %edi
leaq 0x6010(%rip), %rsi      # 0x142e2
movl $0x1, %edx
callq 0x1050
movq %rax, %rcx
movslq -0x8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x8(%rbp)
jmp 0xe2eb
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x4(%rbp), %eax
subl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xe318
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xe2eb
jmp 0xe348
jmp 0xe31c
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
subl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xe346
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xe31c
jmp 0xe348
jmp 0xe34a
jmp 0xe37d
jmp 0xe34e
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %eax
subl 0x18(%rcx), %eax
subl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0xe37b
movq -0x18(%rbp), %rsi
movl $0x1, %edi
movl $0x1, %edx
callq 0x1050
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0xe34e
jmp 0xe37d
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)