LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: get_stdin
int				get_stdin(char **line, char *str, int x, int i)
{
	char	buf[PAGESIZE + 1];
	char	*tmp;

	tmp = NULL;
	while (((i = read(0, buf, PAGESIZE))))
	{
		!str ? (str = ft_strdup("")) : 0;
		buf[i] = 0;
		tmp = ft_strjoin(str, buf);
		ft_strdel(&str);
		if (!x && ft_strchr(buf, 10))
		{
			i = ft_strlen(tmp);
			tmp[i - 1] = 0;
			str = ft_strdup(tmp);
			break ;
		}
		str = ft_strdup(tmp);
		ft_strdel(&tmp);
	}
	ft_strdel(&tmp);
	*line = i == 1 ? ft_strjoin(str, "\n") : ft_strdup(str);
	ft_strdel(&str);
	return (x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq $0x0, -0x1028(%rbp)
leaq -0x1020(%rbp), %rsi
xorl %edi, %edi
movl $0x1000, %edx           # imm = 0x1000
callq 0x10a0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x9ffd
cmpq $0x0, -0x10(%rbp)
jne 0x9f5c
leaq 0x9d32(%rip), %rdi      # 0x13c83
callq 0xc1d0
movq %rax, -0x10(%rbp)
jmp 0x9f5e
jmp 0x9f5e
movslq -0x18(%rbp), %rax
movb $0x0, -0x1020(%rbp,%rax)
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0xbc60
movq %rax, -0x1028(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xbc20
cmpl $0x0, -0x14(%rbp)
jne 0x9fdc
leaq -0x1020(%rbp), %rdi
movl $0xa, %esi
callq 0xb6f0
cmpq $0x0, %rax
je 0x9fdc
movq -0x1028(%rbp), %rdi
callq 0xbf10
movl %eax, -0x18(%rbp)
movq -0x1028(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x1028(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x10(%rbp)
jmp 0x9ffd
movq -0x1028(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x10(%rbp)
leaq -0x1028(%rbp), %rdi
callq 0xbc20
jmp 0x9f24
leaq -0x1028(%rbp), %rdi
callq 0xbc20
cmpl $0x1, -0x18(%rbp)
jne 0xa028
movq -0x10(%rbp), %rdi
leaq 0x9c68(%rip), %rsi      # 0x13c82
callq 0xbc60
movq %rax, -0x1030(%rbp)
jmp 0xa038
movq -0x10(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x1030(%rbp)
movq -0x1030(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x10(%rbp), %rdi
callq 0xbc20
movl -0x14(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/srcs/util/utils.c
// Function: free_message
void			free_message(int count, uint64_t **ptr)
{
	int		i;

	i = -1;
	while (++i < count)
	{
		free(ptr[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl -0x4(%rbp), %eax
jge 0xa097
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0xa076
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoi
int					ft_atoi(const char *str)
{
	int		i;
	int		res;
	int		neg;

	res = 0;
	if (!str)
		return (res);
	i = 0;
	neg = 1;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' ||\
			str[i] == '\f' || str[i] == '\n' || str[i] == '\v')
		i++;
	if (str[i] == '-' || str[i] == '+')
	{
		if (str[i] == '-')
			neg = -1;
		i++;
	}
	while (str[i] >= '0' && str[i] <= '9')
	{
		res = (res * 10) + (str[i] - '0');
		i++;
	}
	return (res * neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa0c1
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa20f
movl $0x0, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1d(%rbp)
je 0xa152
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x1d(%rbp)
je 0xa152
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x1d(%rbp)
je 0xa152
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x1d(%rbp)
je 0xa152
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1d(%rbp)
je 0xa152
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xb, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xa15b
jmp 0xa169
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa0cf
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0xa18b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0xa1ac
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0xa1a3
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa1ae
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x1e(%rbp)
jl 0xa1d9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0xa1e2
jmp 0xa205
imull $0xa, -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa1ae
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_atoi.c
// Function: ft_atoull
unsigned long long	ft_atoull(const char *str)
{
	int					i;
	unsigned long long	n;

	n = 0;
	if (!str)
		return (n);
	i = 0;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' ||\
			str[i] == '\f' || str[i] == '\n' || str[i] == '\v')
		i++;
	while (ft_isdigit(str[i]))
	{
		n = (n * 10) + (str[i] - '0');
		i++;
	}
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa248
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa332
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
je 0xa2d2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x21(%rbp)
je 0xa2d2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x21(%rbp)
je 0xa2d2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x21(%rbp)
je 0xa2d2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0xa2d2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xb, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xa2db
jmp 0xa2e9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa24f
jmp 0xa2eb
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa4f0
cmpl $0x0, %eax
je 0xa32a
imulq $0xa, -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa2eb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_islower.c
// Function: ft_strtolower
char	*ft_strtolower(char *str)
{
	int		i;

	if (!str)
		return (NULL);
	i = 0;
	while (str[i])
	{
		str[i] = ft_tolower(str[i]);
		i++;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa3cd
movq $0x0, -0x8(%rbp)
jmp 0xa413
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xa40b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa370
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa3d4
movq -0x10(%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_isupper.c
// Function: ft_strtoupper
char	*ft_strtoupper(char *str)
{
	int		i;

	i = 0;
	while (str[i])
	{
		str[i] = ft_toupper(str[i]);
		i++;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xa4da
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xa450
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa4a3
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memalloc.c
// Function: ft_bzero
void	ft_bzero(void *s, size_t n)
{
	char	*str;
	size_t	i;

	i = 0;
	str = (char *)s;
	while (i < n)
		*(str + i++) = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xa63f
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0xa61c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memalloc.c
// Function: ft_memalloc
void	*ft_memalloc(size_t size)
{
	void	*m;

	if (!(m = malloc(size)))
		return (NULL);
	ft_bzero(m, size);
	return (m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa679
movq $0x0, -0x8(%rbp)
jmp 0xa68e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa600
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	unsigned char	*d;
	unsigned char	*s;
	size_t			i;

	if (!src)
		return (0);
	d = (unsigned char *)dst;
	s = (unsigned char *)src;
	i = -1;
	while (++i < n)
		(d[i] = s[i]);
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa6c1
movq $0x0, -0x8(%rbp)
jmp 0xa70b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $-0x1, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq -0x20(%rbp), %rax
jae 0xa703
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xa6d9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memcpy.c
// Function: ft_memccpy
void	*ft_memccpy(void *dst, const void *src, int c, size_t n)
{
	unsigned char	*d;
	unsigned char	*s;
	unsigned char	asc;
	size_t			i;

	d = (unsigned char *)dst;
	s = (unsigned char *)src;
	i = 0;
	asc = (unsigned char)c;
	while (i < n)
	{
		d[i] = s[i];
		if (asc == s[i])
		{
			i++;
			return (&d[i]);
		}
		i++;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0x39(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xa7ad
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x39(%rbp), %eax
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xa79f
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa7b5
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xa751
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memcpy.c
// Function: ft_memmove
void	*ft_memmove(void *dst, const void *src, size_t len)
{
	size_t	i;

	i = 0;
	if (len == 0)
		return (dst);
	if (src < dst)
	{
		while (i < len)
		{
			len--;
			((char *)dst)[len] = ((char *)src)[len];
		}
	}
	else
	{
		while (i < len)
		{
			((char *)dst)[i] = ((char *)src)[i];
			i++;
		}
	}
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa7e9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa85f
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xa825
jmp 0xa7f5
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xa823
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xa7f5
jmp 0xa857
jmp 0xa827
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xa855
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa827
jmp 0xa857
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_memcpy.c
// Function: ft_memset
void	*ft_memset(void *b, int c, size_t len)
{
	char	*str;
	size_t	i;

	i = 0;
	str = (char *)b;
	while (i < len)
		*(str + i++) = (unsigned char)c;
	i = 0;
	return (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa8b6
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xa88f
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_pipewrench.c
// Function: ft_pipewrench
int				ft_pipewrench(char *str, ...)
{
	int		freed;
	va_list ap;

	freed = 0;
	va_start(ap, str);
	while (*str && freed >= 0)
	{
		if (*str != PIPE_KEY)
		{
			freed = -1;
			break ;
		}
		else
		{
			freed += pipe_cutter(&str, ap);
			if (freed == 0)
			{
				ft_putendl_fd("No valid pointers were freed", 2);
			}
		}
	}
	va_end(ap);
	return (freed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xa908
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xe1(%rbp)
je 0xa97b
cmpl $0x0, -0xc(%rbp)
setge %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xa987
jmp 0xa9ca
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0xa99c
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xa9ca
leaq -0x30(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xa9e0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xa9c6
leaq 0x9a29(%rip), %rdi      # 0x143e5
movl $0x2, %esi
callq 0xb330
jmp 0xa9c8
jmp 0xa95a
movl -0xc(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_pipewrench.c
// Function: pipe_cutter
static int		pipe_cutter(char **str, va_list ap)
{
	int		pointer_depth;
	int		freed;

	pointer_depth = 0;
	while (**str == PIPE_KEY)
	{
		(*str)++;
		pointer_depth += 1;
	}
	freed = 0;
	if (**str)
	{
		if (pointer_depth > 2)
			ft_putendl_fd("Unsupported Input", 2);
		else
			freed += plunger(ap, pointer_depth, **str);
		(*str)++;
	}
	return (freed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xaa1f
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa9f7
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xaa75
cmpl $0x2, -0x14(%rbp)
jle 0xaa4b
leaq 0x99c3(%rip), %rdi      # 0x14402
movl $0x2, %esi
callq 0xb330
jmp 0xaa67
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edx
callq 0xaa80
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
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_pipewrench.c
// Function: plunger
static int		plunger(va_list ap, int depth, char sig)
{
	char	*s;
	int		*i;

	if (sig == 's')
	{
		if (depth == 2)
			return (teflon_tape(ap));
		else
		{
			s = va_arg(ap, char*);
			ft_memdel((void **)s);
		}
	}
	else if (sig == 'i')
	{
		if (depth == 2)
			return (screwdriver(ap));
		else
		{
			i = va_arg(ap, int*);
			ft_memdel((void **)i);
		}
	}
	return (depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x73, %eax
jne 0xab0c
cmpl $0x2, -0x14(%rbp)
jne 0xaab4
movq -0x10(%rbp), %rdi
callq 0xaba0
movl %eax, -0x4(%rbp)
jmp 0xab89
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x28, %eax
ja 0xaadf
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 0xaaf6
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
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbbe0
jmp 0xab83
movsbl -0x15(%rbp), %eax
cmpl $0x69, %eax
jne 0xab81
cmpl $0x2, -0x14(%rbp)
jne 0xab29
movq -0x10(%rbp), %rdi
callq 0xac70
movl %eax, -0x4(%rbp)
jmp 0xab89
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl %eax, -0x44(%rbp)
cmpl $0x28, %eax
ja 0xab54
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x58(%rbp)
jmp 0xab6b
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbbe0
jmp 0xab81
jmp 0xab83
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %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_pipewrench.c
// Function: teflon_tape
static int		teflon_tape(va_list ap)
{
	char	**p_string;
	int		freed;

	freed = 0;
	p_string = va_arg(ap, char **);
	if (!p_string || !*p_string)
		return (freed);
	while (p_string[freed])
		ft_strdel(&(p_string[freed++]));
	ft_memdel((void **)&p_string);
	return (freed + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x28, %eax
ja 0xabde
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0xabf5
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xac11
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xac19
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xac5b
jmp 0xac1b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xac49
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
cltq
shlq $0x3, %rax
addq %rax, %rdi
callq 0xbc20
jmp 0xac1b
leaq -0x18(%rbp), %rdi
callq 0xbbe0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_pipewrench.c
// Function: screwdriver
static int		screwdriver(va_list ap)
{
	int		**p_ints;
	int		i;
	int		freed;

	i = 0;
	freed = 0;
	p_ints = va_arg(ap, int **);
	while (p_ints[i])
		i++;
	while (freed < i && p_ints[freed])
	{
		ft_memdel((void **)&p_ints[freed++]);
	}
	ft_memdel((void **)&p_ints);
	return (i + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0xacb5
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0xaccc
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xacf1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xacd7
jmp 0xacf3
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0xad13
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xad1c
jmp 0xad3b
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
cltq
shlq $0x3, %rax
addq %rax, %rdi
callq 0xbbe0
jmp 0xacf3
leaq -0x10(%rbp), %rdi
callq 0xbbe0
movl -0x14(%rbp), %eax
addl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf.c
// Function: ft_printf
int				ft_printf(char *str, ...)
{
	int		nbyte;
	va_list	ap;

	nbyte = 0;
	va_start(ap, str);
	while (*str)
	{
		if (*str != '%')
		{
			print_one(&str);
			nbyte++;
		}
		else
		{
			nbyte += parse_string(&str, ap);
		}
	}
	va_end(ap);
	if (nbyte < 0)
		nbyte = 0;
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xad88
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xae18
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0xae03
leaq -0x8(%rbp), %rdi
callq 0xc9e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xae16
leaq -0x30(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0xae40
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xadda
leaq -0x30(%rbp), %rax
cmpl $0x0, -0xc(%rbp)
jge 0xae29
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_printf.c
// Function: parse_string
static int		parse_string(char **str, va_list ap)
{
	int		i;
	t_mods	modifier;

	(*str)++;
	if (**str)
		modifier = get_mods(str, ap);
	if (!(i = get_type_specifier(**str)))
	{
		if (**str && (i = 1))
			print_one(str);
		return (i);
	}
	(*str)++;
	return (dispatch(modifier, ap, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0xae9e
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xcd10
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xc940
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0xaee4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xaedc
movl $0x1, -0x1c(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xaed3
jmp 0xaedc
movq -0x10(%rbp), %rdi
callq 0xc9e0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaf27
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x40(%rbp), %rax
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 0xaf40
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf.c
// Function: ft_sprintf
int				ft_sprintf(char *buf, char *str, ...)
{
	int		nbyte;
	int		i;
	va_list	ap;

	nbyte = 0;
	va_start(ap, str);
	while (*str && nbyte < PAGESIZE)
	{
		if (*str != '%')
		{
			add_one_to_buf(&buf, *str, &nbyte);
			str++;
		}
		else
		{
			i = parse_string(buf, &str, ap);
			buf += i;
			nbyte += i;
		}
	}
	if (nbyte < PAGESIZE)
		*buf = '\0';
	va_end(ap);
	return (nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xb408
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xe1(%rbp)
je 0xb47b
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
setl %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xb487
jmp 0xb4e8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0xb4b5
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
leaq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0x10780
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb4e3
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rsi
callq 0xb510
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xb457
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jge 0xb4f8
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl -0x14(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	size_t		i;

	i = -1;
	if (!s)
		return (NULL);
	while (s[++i])
		if (s[i] == (char)c)
			return ((char*)&s[i]);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $-0x1, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb714
movq $0x0, -0x8(%rbp)
jmp 0xb75e
jmp 0xb716
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
je 0xb756
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb754
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb75e
jmp 0xb716
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t	i;

	if (!s)
		return (NULL);
	i = ft_strlen(s) + 1;
	while (i--)
		if (s[i] == (char)c)
			return ((char*)&s[i]);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb790
movq $0x0, -0x8(%rbp)
jmp 0xb7e4
movq -0x10(%rbp), %rdi
callq 0xbf10
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb7dc
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb7da
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb7e4
jmp 0xb7a1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strchr.c
// Function: ft_strchri
int		ft_strchri(const char *s, int c)
{
	size_t		i;
	int			z;

	i = 0;
	z = 0;
	if (!s)
		return (0);
	while (s[i])
		if (s[i++] == (char)c)
			return (--i);
	return (z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb81a
movl $0x0, -0x4(%rbp)
jmp 0xb864
jmp 0xb81c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb85e
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb85c
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl %eax, -0x4(%rbp)
jmp 0xb864
jmp 0xb81c
movl -0x24(%rbp), %eax
movl %eax, -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_strchr.c
// Function: ft_strrchri
int		ft_strrchri(const char *s, int c)
{
	size_t		i;
	int			z;

	i = 0;
	z = 0;
	if (!s)
		return (0);
	while (s[i])
		if (s[i++] == (char)c)
			z = i;
	return (z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb89a
movl $0x0, -0x4(%rbp)
jmp 0xb8da
jmp 0xb89c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb8d4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb8d2
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
jmp 0xb89c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xb929
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xb932
jmp 0xb93d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb8f3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	int		i;

	i = 0;
	while ((s1[i] != '\0') && (s1[i] == s2[i]) && (i < (int)n))
		i++;
	if (i != (int)n)
		return ((unsigned char)s1[i] - (unsigned char)s2[i]);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0xb9bd
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x25(%rbp)
jne 0xb9bd
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xb9c6
jmp 0xb9d1
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb977
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
je 0xb9fb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xba02
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	int		i;

	i = -1;
	while (src[++i])
		dst[i] = src[i];
	dst[i] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbb01
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xbad3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strncpy
char	*ft_strncpy(char *dst, const char *src, size_t len)
{
	size_t	i;

	i = -1;
	while (++i < len)
	{
		if (src[i])
			dst[i] = src[i];
		else
		{
			while (i < len)
				dst[i++] = '\0';
		}
	}
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jae 0xbb99
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbb70
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xbb97
jmp 0xbb72
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xbb95
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0xbb72
jmp 0xbb97
jmp 0xbb38
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_memdel
void	ft_memdel(void **ap)
{
	if (!ap || !*ap)
		return ;
	free(*ap);
	*ap = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbbfd
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbbff
jmp 0xbc16
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strcpy.c
// Function: ft_strdel
void	ft_strdel(char **as)
{
	if (!as || !*as)
		return ;
	free(*as);
	*as = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbc3d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbc3f
jmp 0xbc56
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*new_str;
	size_t	i;
	size_t	j;
	size_t	s1_len;
	size_t	s2_len;

	if (!s1 || !s2)
		return (s1 ? ft_strdup(s1) : ft_strdup(s2));
	s1_len = ft_strlen(s1);
	s2_len = ft_strlen(s2);
	if (!(new_str = ft_strnew(s1_len + s2_len)))
		return (NULL);
	i = -1;
	while (++i < s1_len)
		new_str[i] = s1[i];
	j = -1;
	while (++j < s2_len)
		new_str[i++] = s2[j];
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbc7e
cmpq $0x0, -0x18(%rbp)
jne 0xbcae
cmpq $0x0, -0x10(%rbp)
je 0xbc94
movq -0x10(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x48(%rbp)
jmp 0xbca1
movq -0x18(%rbp), %rdi
callq 0xc1d0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbd60
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf10
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
addq -0x40(%rbp), %rdi
callq 0xc020
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xbce9
movq $0x0, -0x8(%rbp)
jmp 0xbd60
movq $-0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq -0x38(%rbp), %rax
jae 0xbd1b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xbcf1
movq $-0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq -0x40(%rbp), %rax
jae 0xbd58
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xbd23
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: str_3join
char	*str_3join(char const *s1, char const *s2, char const *s3)
{
	char	*new_str;
	size_t	i[3];
	size_t	len[3];

	if (!s1 || !s2 || !s3)
		return (NULL);
	len[0] = ft_strlen(s1);
	len[1] = ft_strlen(s2);
	len[2] = ft_strlen(s3);
	if (!(new_str = ft_strnew(len[0] + len[1] + len[2])))
		return (NULL);
	i[0] = -1;
	i[1] = -1;
	i[2] = -1;
	while (++i[0] < len[0])
		new_str[i[0]] = s1[i[0]];
	while (++i[1] < len[1])
		new_str[i[0]++] = s2[i[1]];
	while (++i[2] < len[2])
		new_str[i[0]++] = s3[i[2]];
	new_str[i[0]] = '\0';
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbd99
cmpq $0x0, -0x18(%rbp)
je 0xbd99
cmpq $0x0, -0x20(%rbp)
jne 0xbda6
movq $0x0, -0x8(%rbp)
jmp 0xbeb9
movq -0x10(%rbp), %rdi
callq 0xbf10
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf10
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbf10
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rdi
addq -0x58(%rbp), %rdi
addq -0x50(%rbp), %rdi
callq 0xc020
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xbdf5
movq $0x0, -0x8(%rbp)
jmp 0xbeb9
movq $-0x1, -0x40(%rbp)
movq $-0x1, -0x38(%rbp)
movq $-0x1, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
cmpq -0x60(%rbp), %rax
jae 0xbe37
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xbe0d
jmp 0xbe39
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq -0x58(%rbp), %rax
jae 0xbe6e
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x40(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xbe39
jmp 0xbe70
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq -0x50(%rbp), %rax
jae 0xbea5
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x40(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xbe70
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_intlen
int		ft_intlen(int num)
{
	int		n;

	n = 1;
	while (num /= 10)
		n++;
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
je 0xbefc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xbede
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *str)
{
	size_t	i;

	i = 0;
	if (str && *str)
		while (str[i])
			i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbf53
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xbf53
jmp 0xbf35
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbf51
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbf35
jmp 0xbf53
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striter
void	ft_striter(char *s, void (*f)(char *))
{
	int		i;

	i = 0;
	if (s && f)
		while (*(s + i))
			f(s + i++);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbfb4
cmpq $0x0, -0x10(%rbp)
je 0xbfb4
jmp 0xbf87
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbfb2
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
addq %rcx, %rdi
callq *%rax
jmp 0xbf87
jmp 0xbfb4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striteri
void	ft_striteri(char *s, void (*f)(unsigned int, char *))
{
	int		i;

	i = -1;
	if (s && f)
		while (*(s + ++i))
			f(i, s + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x8(%rbp)
je 0xc015
cmpq $0x0, -0x10(%rbp)
je 0xc015
jmp 0xbfe7
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xc013
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
jmp 0xbfe7
jmp 0xc015
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strnew
char	*ft_strnew(size_t size)
{
	char	*str;

	if (!(str = (char *)malloc(sizeof(char) * size + 1)))
		return (NULL);
	ft_bzero(str, size + 1);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xc051
movq $0x0, -0x8(%rbp)
jmp 0xc06a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0xa600
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strcnew
char	*ft_strcnew(size_t len, char c)
{
	char	*new;
	size_t	i;

	if (len)
		if (!(new = (char *)malloc(sizeof(char) * len + 1)))
			return (NULL);
	i = -1;
	while (++i < len)
		new[i] = c;
	new[i] = '\0';
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc0c0
movq -0x10(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc0be
movq $0x0, -0x8(%rbp)
jmp 0xc0fe
jmp 0xc0c0
movq $-0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq -0x10(%rbp), %rax
jae 0xc0ea
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xc0c8
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char	*new_str;
	size_t	i;

	if (!s)
		return (NULL);
	if (!(new_str = ft_strnew(len)))
		return (NULL);
	i = 0;
	while (i < len && *s)
		new_str[i++] = s[start++];
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc137
movq $0x0, -0x8(%rbp)
jmp 0xc1b8
movq -0x20(%rbp), %rdi
callq 0xc020
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc154
movq $0x0, -0x8(%rbp)
jmp 0xc1b8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0xc17b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc184
jmp 0xc1b0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xc15c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*dup;
	size_t	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc1ed
movq $0x0, -0x8(%rbp)
jmp 0xc268
movq -0x10(%rbp), %rdi
callq 0xbf10
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xc21b
movq $0x0, -0x8(%rbp)
jmp 0xc268
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, -0x1(%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
jbe 0xc260
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xc233
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)