LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t			i;
	size_t			max;
	unsigned char	*str1;
	unsigned char	*str2;

	i = 0;
	max = 0;
	str1 = (unsigned char *)s1;
	str2 = (unsigned char *)s2;
	while (str1[max] && str2[max])
		max++;
	while (i < n && i <= max)
	{
		if (str1[i] != str2[i])
			return ((int)(str1[i] - str2[i]));
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0xfbbb
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xfbc4
jmp 0xfbd2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xfb90
jmp 0xfbd4
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0xfbf1
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
setbe %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0xfbfa
jmp 0xfc43
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xfc35
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xfc4a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xfbd4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strrchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t			i;
	size_t			s_len;
	char			*to_return;
	unsigned char	searched;

	to_return = NULL;
	s_len = ft_strlen(s);
	searched = (unsigned char)c;
	i = 0;
	while (i <= s_len)
	{
		if (s[i] == searched)
			to_return = (char *)(&(s[i]));
		i++;
	}
	return (to_return);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfb10
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x29(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0xfcba
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
jne 0xfcac
movq -0x8(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xfc82
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strtrim.c
// Function: ft_strtrim
char		*ft_strtrim(char const *s1, char const *set)
{
	int		i;
	int		j;
	int		size;
	char	*result;

	i = 0;
	j = 0;
	size = 0;
	if (!s1 || !set)
		return (NULL);
	while (s1[i] && is_to_trim(s1[i], set))
		i++;
	if (s1[i])
		size = ft_size(&s1[i], set);
	if (!(result = (char *)ft_calloc(size + 1, sizeof(char))))
		return (NULL);
	while (s1[i] && j < size)
		result[j++] = s1[i++];
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfd03
cmpq $0x0, -0x18(%rbp)
jne 0xfd10
movq $0x0, -0x8(%rbp)
jmp 0xfe09
jmp 0xfd12
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xfd48
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x18(%rbp), %rsi
movsbl %al, %edi
callq 0xfe20
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xfd51
jmp 0xfd5c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfd12
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xfd81
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xfe80
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x10f20
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xfda8
movq $0x0, -0x8(%rbp)
jmp 0xfe09
jmp 0xfdaa
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
je 0xfdcc
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0xfdd5
jmp 0xfe01
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xfdaa
movq -0x30(%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/charMstr[P]minishell/libft/ft_strtrim.c
// Function: is_to_trim
static int	is_to_trim(char to_test, char const *set)
{
	int i;

	i = -1;
	while (set[++i])
		if (set[i] == to_test)
			return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%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 0xfe6a
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0xfe68
movl $0x1, -0x4(%rbp)
jmp 0xfe71
jmp 0xfe35
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strtrim.c
// Function: ft_size
static int	ft_size(char const *s1, char const *set)
{
	int	i;
	int	max;

	i = 0;
	max = (int)ft_strlen(s1) - 1;
	while (s1[max] && is_to_trim(s1[max], set))
		max--;
	while (i <= max)
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfb10
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xfedc
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rsi
movsbl %al, %edi
callq 0xfe20
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xfee5
jmp 0xfef0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfea6
jmp 0xfef2
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xff05
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfef2
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*newcpy;
	size_t	i;
	size_t	s_len;

	i = 0;
	if (s == NULL)
		return (NULL);
	s_len = ft_strlen(s);
	if ((newcpy = (char *)ft_calloc(len + 1, sizeof(*newcpy))) == NULL)
		return (NULL);
	if (start < s_len)
		while (i < len && s[start])
			newcpy[i++] = s[start++];
	return (newcpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xff3f
movq $0x0, -0x8(%rbp)
jmp 0xffdf
movq -0x10(%rbp), %rdi
callq 0xfb10
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x10f20
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xff72
movq $0x0, -0x8(%rbp)
jmp 0xffdf
movl -0x14(%rbp), %eax
cmpq -0x38(%rbp), %rax
jae 0xffd7
jmp 0xff7d
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x39(%rbp)
jae 0xffa0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xffa9
jmp 0xffd5
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 0xff7d
jmp 0xffd7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstadd_back.c
// Function: ft_lstadd_back
void	ft_lstadd_back(t_list **alst, t_list *new)
{
	t_list *tmp;

	if (!alst || !new)
		return ;
	if (!(*alst))
	{
		*alst = new;
		return ;
	}
	tmp = *alst;
	while (tmp->next)
		tmp = tmp->next;
	tmp->next = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1000a
cmpq $0x0, -0x10(%rbp)
jne 0x1000c
jmp 0x10053
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10023
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x10053
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10047
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1002e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstclear.c
// Function: ft_lstclear
void	ft_lstclear(t_list **lst, void (*del)(void *))
{
	t_list	*current;
	t_list	*then;

	if (!lst || !*lst)
		return ;
	current = *lst;
	while (current)
	{
		then = current->next;
		ft_lstdelone(current, del);
		current = then;
	}
	*lst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x100b1
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x100b3
jmp 0x100f3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x100e8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10100
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x100be
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstdelone.c
// Function: ft_lstdelone
void	ft_lstdelone(t_list *lst, void (*del)(void *))
{
	if (lst)
	{
		if (del)
			del(lst->content);
		free(lst);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10134
cmpq $0x0, -0x10(%rbp)
je 0x1012b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2230
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void *content)
{
	t_list *new;

	if (!(new = (t_list *)malloc(sizeof(*new))))
		return (NULL);
	new->content = content;
	new->next = NULL;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x101aa
movq $0x0, -0x8(%rbp)
jmp 0x101c9
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstsize.c
// Function: ft_lstsize
int		ft_lstsize(t_list *lst)
{
	int i;

	i = 0;
	while (lst)
	{
		lst = lst->next;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1020d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x101ef
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strichr.c
// Function: ft_strichr
int	ft_strichr(const char *str, char c)
{
	int index;

	index = 0;
	if (!str)
		return (-1);
	while (str[index])
	{
		if (str[index] == c)
			return (index);
		index++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x102a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x102e3
jmp 0x102a7
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x102dc
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x102d1
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x102e3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x102a7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_array_free.c
// Function: ft_array_free
void	*ft_array_free(char **ptr, int k)
{
	if (!ptr)
		return (NULL);
	while (--k >= 0)
	{
		free(ptr[k]);
		ptr[k] = NULL;
	}
	free(ptr);
	ptr = NULL;
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10310
movq $0x0, -0x8(%rbp)
jmp 0x1035c
jmp 0x10312
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x10343
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2230
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x10312
movq -0x10(%rbp), %rdi
callq 0x2230
movq $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_stristr.c
// Function: ft_stristr
int	ft_stristr(const char *str, char *stack)
{
	int i;
	int j;

	if (!str || !stack)
		return (-1);
	i = 0;
	j = 0;
	while (str[i])
	{
		j = 0;
		while (stack[j])
		{
			if (str[i] == stack[j])
				return (i);
			j++;
		}
		i++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1038a
cmpq $0x0, -0x18(%rbp)
jne 0x10393
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10405
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x103fe
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x103f3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x103e8
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10405
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x103b6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x103a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_array_len.c
// Function: ft_array_len
int	ft_array_len(char **array)
{
	int i;

	i = 0;
	if (!array)
		return (-1);
	while (array[i])
	{
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1042f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10451
jmp 0x10431
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1044b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10431
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strappend.c
// Function: ft_strappend
int	ft_strappend(char **str, char c)
{
	char *char_str;

	char_str = (char	[2]){c, '\0'};
	if (!*str)
	{
		if (!(*str = ft_strdup(char_str)))
			return (0);
	}
	else if (!(*str = ft_strjoin_free(*str, char_str, 1)))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x22(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x104af
movq -0x20(%rbp), %rdi
callq 0xf950
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x104ad
movl $0x0, -0x4(%rbp)
jmp 0x104e3
jmp 0x104dc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xfab0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x104da
movl $0x0, -0x4(%rbp)
jmp 0x104e3
jmp 0x104dc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_memalloc.c
// Function: ft_memalloc
void	*ft_memalloc(size_t size)
{
	void *result;

	if (!(result = malloc(size)))
		return (NULL);
	ft_memset(result, 0, size);
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x10519
movq $0x0, -0x8(%rbp)
jmp 0x10530
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0xeec0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
int	ft_strcmp(const char *s1, const char *s2)
{
	int i;

	i = 0;
	while (s1[i] == s2[i])
	{
		if (s1[i] == '\0')
			return (0);
		i++;
	}
	return ((unsigned)s1[i] - (unsigned)s2[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x105d4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x105c9
movl $0x0, -0x4(%rbp)
jmp 0x105f1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10593
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strcadd.c
// Function: ft_strcadd
int	ft_strcadd(char **str, char c, size_t index)
{
	size_t	tt_len;
	char	*new;
	size_t	j;

	tt_len = ft_strlen(*str) + 1;
	j = 0;
	if (!(new = (char*)malloc(sizeof(char) * (tt_len + 1))))
	{
		ft_free((void **)str);
		return (0);
	}
	new[tt_len] = '\0';
	while (j < index && j < (tt_len - 1))
	{
		new[j] = str[0][j];
		j++;
	}
	new[j] = c;
	while (++j < tt_len)
		new[j] = str[0][j - 1];
	ft_free((void**)str);
	*str = new;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfb10
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2180
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x10692
movq -0x10(%rbp), %rdi
callq 0x10600
movl $0x0, -0x4(%rbp)
jmp 0x1074c
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x39(%rbp)
jae 0x106c2
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x106cb
jmp 0x106f2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1069e
movb -0x11(%rbp), %dl
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq -0x28(%rbp), %rax
jae 0x10731
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x10700
movq -0x10(%rbp), %rdi
callq 0x10600
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strcdel.c
// Function: ft_strcdel
void	ft_strcdel(char *str, size_t i)
{
	size_t	len;

	if (!str || !ft_strlen(str))
		return ;
	len = ft_strlen(str);
	if (i >= len)
		return ;
	ft_memmove(str + i, str + i + 1, len - i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10786
movq -0x8(%rbp), %rdi
callq 0xfb10
cmpq $0x0, %rax
jne 0x10788
jmp 0x107c2
movq -0x8(%rbp), %rdi
callq 0xfb10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x107a1
jmp 0x107c2
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
callq 0xee10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strstradd.c
// Function: ft_strstradd
int			ft_strstradd(char **dst, int start, char *src)
{
	int len;

	if (!dst || !src)
	{
		ft_free((void**)dst);
		return (0);
	}
	len = ft_strlen(*dst);
	if (start > len)
		start = len;
	if (!(*dst))
	{
		if (!(*dst = ft_strdup(src)))
			return (0);
	}
	else if (!ft_strstradd_assist(dst, start, src))
	{
		ft_free((void**)dst);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x107f1
cmpq $0x0, -0x20(%rbp)
jne 0x10803
movq -0x10(%rbp), %rdi
callq 0x10600
movl $0x0, -0x4(%rbp)
jmp 0x1087b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xfb10
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x10820
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1084b
movq -0x20(%rbp), %rdi
callq 0xf950
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x10849
movl $0x0, -0x4(%rbp)
jmp 0x1087b
jmp 0x10874
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x10890
cmpl $0x0, %eax
jne 0x10872
movq -0x10(%rbp), %rdi
callq 0x10600
movl $0x0, -0x4(%rbp)
jmp 0x1087b
jmp 0x10874
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strstradd.c
// Function: ft_strstradd_assist
static int	ft_strstradd_assist(char **dst, int start, char *src)
{
	char *new;

	if (!(new = ft_substr(*dst, 0, start)))
		return (0);
	if (!(new = ft_strjoin_free(new, src, 1)))
		return (0);
	if (!(new = ft_strjoin_free(new, *dst + start, 1)))
		return (0);
	ft_free((void**)dst);
	*dst = new;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0xff10
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x108c8
movl $0x0, -0x4(%rbp)
jmp 0x10937
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xfab0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x108ed
movl $0x0, -0x4(%rbp)
jmp 0x10937
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movl $0x1, %edx
callq 0xfab0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1091c
movl $0x0, -0x4(%rbp)
jmp 0x10937
movq -0x10(%rbp), %rdi
callq 0x10600
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstnew.c
// Function: ft_dlstnew
t_dlist	*ft_dlstnew(void *content)
{
	t_dlist *new;

	if (!(new = (t_dlist *)malloc(sizeof(*new))))
		return (NULL);
	new->content = content;
	new->next = NULL;
	new->previous = NULL;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1096a
movq $0x0, -0x8(%rbp)
jmp 0x10995
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstadd_front.c
// Function: ft_dlstadd_front
void	ft_dlstadd_front(t_dlist **alst, t_dlist *new)
{
	if (!alst || !new)
		return ;
	if (*alst)
	{
		(*alst)->previous = new;
		new->next = *alst;
	}
	*alst = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x109ba
cmpq $0x0, -0x10(%rbp)
jne 0x109bc
jmp 0x109ef
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x109e4
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstclear.c
// Function: ft_dlstclear
void	ft_dlstclear(t_dlist **lst, void (*del)(void *))
{
	t_dlist	*current;
	t_dlist	*then;

	if (!lst || !*lst)
		return ;
	if (*lst)
	{
		current = (*lst)->next;
		while (current)
		{
			then = current->next;
			ft_dlstdelone(current, del);
			current = then;
		}
	}
	current = *lst;
	while (current)
	{
		then = current->previous;
		ft_dlstdelone(current, del);
		current = then;
	}
	*lst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10a21
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10a26
jmp 0x10aab
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10a6b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10a69
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10ac0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x10a3f
jmp 0x10a6b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10aa0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10ac0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x10a76
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstdelone.c
// Function: ft_dlstdelone
void	ft_dlstdelone(t_dlist *lst, void (*del)(void *))
{
	if (lst)
	{
		if (del)
			del(lst->content);
		free(lst);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10af4
cmpq $0x0, -0x10(%rbp)
je 0x10aeb
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2230
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstpop_front.c
// Function: ft_dlstpop_front
void	ft_dlstpop_front(t_dlist **head, void (*del)(void*))
{
	t_dlist *new_head;

	if (!head || !del || !*head)
		return ;
	new_head = (*head)->next;
	ft_dlstdelone(*head, del);
	*head = NULL;
	*head = new_head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10b28
cmpq $0x0, -0x10(%rbp)
je 0x10b28
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10b2a
jmp 0x10b5f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10ac0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstpop_back.c
// Function: ft_dlstpop_back
void	ft_dlstpop_back(t_dlist **head, void (*del)(void*))
{
	t_dlist **current;
	t_dlist *then;

	if (!head || !del || !*head)
		return ;
	current = head;
	while (*current)
	{
		then = (*current)->next;
		if (!then)
		{
			ft_dlstdelone(*current, del);
			*current = NULL;
			return ;
		}
		current = &(*current)->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10b98
cmpq $0x0, -0x10(%rbp)
je 0x10b98
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10b9a
jmp 0x10bf0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10bf0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10bdf
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10ac0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x10bf0
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x10ba2
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_dlstclearback_addr.c
// Function: ft_dlstclearback_addr
void	ft_dlstclearback_addr(t_dlist **lst, void (*del)(void **))
{
	t_dlist	*then;

	if (!lst || !*lst)
		return ;
	while ((*lst)->next)
		(*lst) = (*lst)->next;
	while (*lst)
	{
		then = (*lst)->previous;
		if (del)
			del(&(*lst)->content);
		ft_free((void **)lst);
		(*lst) = then;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10c21
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10c23
jmp 0x10c8c
jmp 0x10c25
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x10c47
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x10c25
jmp 0x10c49
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10c8c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10c76
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x10600
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x10c49
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_lstremove_if.c
// Function: ft_lstremove_if
void	ft_lstremove_if(t_list **begin_list, void *data_ref, int (*cmp)(),
		void (*free_fct)(void *))
{
	t_list	*current;
	t_list	*to_delete;

	while (*begin_list && !((*cmp)((*begin_list)->content, data_ref)))
	{
		to_delete = *begin_list;
		*begin_list = to_delete->next;
		ft_lstdelone(to_delete, free_fct);
	}
	current = *begin_list;
	while (current != NULL)
	{
		if (current->next && !((*cmp)(current->next->content, data_ref)))
		{
			to_delete = current->next;
			current->next = current->next->next;
			ft_lstdelone(to_delete, free_fct);
		}
		else
			current = current->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x10ce8
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq *%rcx
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x10cf1
jmp 0x10d1a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10100
jmp 0x10cb8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10d90
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10d82
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq *%rcx
cmpl $0x0, %eax
jne 0x10d82
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10100
jmp 0x10d8e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x10d25
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/btree_depth.c
// Function: btree_depth
int		btree_depth(t_btree *root)
{
	int	max[3];

	if (!root)
		return (0);
	max[0] = btree_depth(root->left);
	max[1] = btree_depth(root->right);
	max[2] = (max[0] > max[1] ? max[0] : max[1]);
	return (max[2] + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10dbc
movl $0x0, -0x4(%rbp)
jmp 0x10e00
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10da0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10da0
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x10deb
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x10df1
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/btree_new.c
// Function: btree_new
t_btree	*btree_new(void *item)
{
	t_btree *new;

	if (!(new = malloc(sizeof(t_btree))))
		return (NULL);
	new->left = NULL;
	new->right = NULL;
	new->item = item;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x10e3a
movq $0x0, -0x8(%rbp)
jmp 0x10e65
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/btree_clear.c
// Function: btree_clear
void	btree_clear(t_btree **node, void (*del)(void *))
{
	if (!*node)
		return ;
	btree_clear(&(*node)->left, del);
	btree_clear(&(*node)->right, del);
	btree_delone(node, del);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10e8c
jmp 0x10ebd
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10e70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x10e70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10ed0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/btree_delone.c
// Function: btree_delone
void	btree_delone(t_btree **node, void (*del)(void *))
{
	if (!*node)
		return ;
	if (del)
		del((*node)->item);
	ft_free((void **)node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10eec
jmp 0x10f0d
cmpq $0x0, -0x10(%rbp)
je 0x10f04
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x10600
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_calloc.c
// Function: ft_calloc
void	*ft_calloc(size_t count, size_t size)
{
	size_t			total_len;
	unsigned char	*result;

	total_len = count * size;
	if (!(result = (unsigned char *)malloc(sizeof(*result) * total_len)))
		return (NULL);
	ft_bzero(result, total_len);
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
callq 0x2180
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x10f5e
movq $0x0, -0x8(%rbp)
jmp 0x10f73
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe940
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256Init
int sha256Init(SHA256Context *ctx)
{
    /*
     * For SHA-256, the initial hash value, H(0), consists of the following
     * eight 32-bit words, in hex. These words were obtained by taking the
     * first thirty-two bits of the fractional parts of the square roots of
     * the first eight prime numbers.
     */
    if(NULL == ctx) 
        return SHA_NULL;
    ctx->hl = ctx->ll = 0;
    ctx->msg_block_idx = 0;

    ctx->h[0] = 0x6a09e667;
    ctx->h[1] = 0xbb67ae85;
    ctx->h[2] = 0x3c6ef372;
    ctx->h[3] = 0xa54ff53a;
    ctx->h[4] = 0x510e527f;
    ctx->h[5] = 0x9b05688c;
    ctx->h[6] = 0x1f83d9ab;
    ctx->h[7] = 0x5be0cd19;
    ctx->Computed = 0;
    ctx->Corrupted = SHA_SUCCESS;
    
    return SHA_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x11cc
movl $0x1, -0x4(%rbp)
jmp 0x1260
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x6a09e667, (%rax)     # imm = 0x6A09E667
movq -0x10(%rbp), %rax
movl $0xbb67ae85, 0x4(%rax)  # imm = 0xBB67AE85
movq -0x10(%rbp), %rax
movl $0x3c6ef372, 0x8(%rax)  # imm = 0x3C6EF372
movq -0x10(%rbp), %rax
movl $0xa54ff53a, 0xc(%rax)  # imm = 0xA54FF53A
movq -0x10(%rbp), %rax
movl $0x510e527f, 0x10(%rax) # imm = 0x510E527F
movq -0x10(%rbp), %rax
movl $0x9b05688c, 0x14(%rax) # imm = 0x9B05688C
movq -0x10(%rbp), %rax
movl $0x1f83d9ab, 0x18(%rax) # imm = 0x1F83D9AB
movq -0x10(%rbp), %rax
movl $0x5be0cd19, 0x1c(%rax) # imm = 0x5BE0CD19
movq -0x10(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x70(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256Input
int sha256Input(SHA256Context *ctx, const uint8_t *msg, unsigned int len)
{
    if(!ctx)
        return SHA_NULL;
    if(!len)
        return SHA_SUCCESS;
    if(!msg)
        return SHA_NULL;

    if(ctx->Computed) return ctx->Corrupted = SHA_ERR;
    if(ctx->Corrupted) return ctx->Corrupted;

    while(len--){
        ctx->msg_block[ctx->msg_block_idx++] = *msg;
        if((SHA256_add_len(ctx, 8) == SHA_SUCCESS) && (ctx->msg_block_idx == SHA256_Message_Block_Size))
            sha256Process(ctx);
        ++msg;
    }
    return SHA_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1296
movl $0x1, -0x4(%rbp)
jmp 0x13c3
cmpl $0x0, -0x1c(%rbp)
jne 0x12a8
movl $0x0, -0x4(%rbp)
jmp 0x13c3
cmpq $0x0, -0x18(%rbp)
jne 0x12bb
movl $0x1, -0x4(%rbp)
jmp 0x13c3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0x12dc
movq -0x10(%rbp), %rax
movl $0x3, 0x70(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x13c3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x12f5
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x13c3
jmp 0x12f7
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x13bc
movq -0x18(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movw 0x28(%rsi), %cx
movw %cx, %di
addw $0x1, %di
movw %di, 0x28(%rsi)
movswq %cx, %rcx
movb %dl, 0x2a(%rax,%rcx)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movb %al, 0x2d3c(%rip)       # 0x4079
movl -0x1c(%rbp), %eax
movzbl 0x2d32(%rip), %ecx      # 0x4079
cmpl %ecx, %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
addl 0x24(%rcx), %eax
movl %eax, 0x24(%rcx)
cmpl $0x0, %eax
je 0x137c
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x20(%rcx)
cmpl $0x0, %eax
jne 0x137c
movl $0x2, %eax
movl %eax, -0x20(%rbp)
jmp 0x1386
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movl %eax, 0x70(%rcx)
cmpl $0x0, %eax
jne 0x13ab
movq -0x10(%rbp), %rax
movswl 0x28(%rax), %eax
cmpl $0x40, %eax
jne 0x13ab
movq -0x10(%rbp), %rdi
callq 0x13d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12f7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256FinalizeBits
int sha256FinalizeBits(SHA256Context *ctx, uint8_t msg_bits, unsigned int len)
{
    static uint8_t mask[8] = {
        /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
        /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
        /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
        /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
    };
    static uint8_t markbit[8] = {
        /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
        /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
        /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
        /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
    };

    if(!ctx) return SHA_NULL;
    if(!len) return SHA_SUCCESS;
    if(ctx->Corrupted) return ctx->Corrupted;
    if(ctx->Computed) return SHA_ERR;
    if(len >= 8) return ctx->Corrupted = SHA_BAD_PARAM;

    SHA256_add_len(ctx, len);
    sha256Finalize(ctx, (uint8_t)((msg_bits & mask[len])| markbit[len]));

    return ctx->Corrupted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1848
movl $0x1, -0x4(%rbp)
jmp 0x1944
cmpl $0x0, -0x18(%rbp)
jne 0x185a
movl $0x0, -0x4(%rbp)
jmp 0x1944
movq -0x10(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x1873
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1944
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0x1889
movl $0x3, -0x4(%rbp)
jmp 0x1944
cmpl $0x8, -0x18(%rbp)
jb 0x18a6
movq -0x10(%rbp), %rax
movl $0x4, 0x70(%rax)
movl $0x4, -0x4(%rbp)
jmp 0x1944
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movb %al, 0x27c6(%rip)       # 0x4079
movl -0x18(%rbp), %eax
movzbl 0x27bc(%rip), %ecx      # 0x4079
cmpl %ecx, %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
addl 0x24(%rcx), %eax
movl %eax, 0x24(%rcx)
cmpl $0x0, %eax
je 0x18f2
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x20(%rcx)
cmpl $0x0, %eax
jne 0x18f2
movl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18fc
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x70(%rax)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
leaq 0x274e(%rip), %rcx      # 0x4068
movzbl (%rcx,%rdx), %ecx
andl %ecx, %eax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
leaq 0x2744(%rip), %rcx      # 0x4070
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movzbl %al, %esi
callq 0x1950
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256Finalize
static void sha256Finalize(SHA256Context *ctx, uint8_t pad_byte)
{
    sha256PadMsg(ctx, pad_byte);
    for(int i=0; i< SHA256_Message_Block_Size; ++i){
        ctx->msg_block[i] = 0;
    }
    ctx->ll = ctx->hl = 0;
    ctx->Computed = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0x1a80
movl $0x0, -0x10(%rbp)
cmpl $0x40, -0x10(%rbp)
jge 0x1994
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x2a(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1976
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x6c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256Result
extern int sha256Result(SHA256Context *ctx, uint8_t msgDigest[SHA256_Hash_Size])
{
    if(!ctx) return SHA_NULL;
    if(!msgDigest) return SHA_NULL;
    if(ctx->Corrupted) return ctx->Corrupted;
    if(!ctx->Computed)
        sha256Finalize(ctx, 0x80);

    for(int i = 0; i < SHA256_Hash_Size; ++i)
        msgDigest[i] = (uint8_t) (ctx->h[i>>2]>> 8*(3-(i&0x03)));

    return SHA_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x19e3
movl $0x1, -0x4(%rbp)
jmp 0x1a6f
cmpq $0x0, -0x18(%rbp)
jne 0x19f3
movl $0x1, -0x4(%rbp)
jmp 0x1a6f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x70(%rax)
je 0x1a09
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a6f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
jne 0x1a21
movq -0x10(%rbp), %rdi
movl $0x80, %esi
callq 0x1950
movl $0x0, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x1a68
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1a28
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)