LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/embrace_expansion.c
// Function: embrace_expansion
char			*embrace_expansion(char *str)
{
	char	*buff;
	char	*tmp;

	tmp = set_opening_braces(str);
	buff = set_closing_braces(tmp);
	free(tmp);
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ed0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4060
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion.c
// Function: expand_var
char			*expand_var(char *env, t_shell *shell)
{
	int		i;
	int		len;
	char	*delimiter;

	i = 0;
	delimiter = NULL;
	if (*env == '{')
	{
		env++;
		delimiter = ft_strchr(env, '}');
		len = ft_strlen(env) - (delimiter ? ft_strlen(delimiter) : 0);
	}
	else
		len = ft_strlen(env);
	if (delimiter && *(delimiter - 1) == ' ')
		len--;
	while (shell->env[i])
	{
		if (!ft_strncmp(shell->env[i], env, len)
			&& shell->env[i][len] == '=')
			break ;
		else
			i++;
	}
	return (get_env_value(shell, delimiter, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x4474
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x7d, %esi
callq 0x8110
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8550
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x445c
movq -0x20(%rbp), %rdi
callq 0x8550
movq %rax, -0x30(%rbp)
jmp 0x4464
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4464
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
jmp 0x4480
movq -0x8(%rbp), %rdi
callq 0x8550
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x449d
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x449d
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x449f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x44fe
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x85c0
cmpl $0x0, %eax
jne 0x44f3
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x44f3
jmp 0x44fe
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x449f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4520
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion.c
// Function: get_env_value
static	char	*get_env_value(t_shell *shell, char *delimiter, int i)
{
	char	*ret;
	char	*value;

	if (shell->env[i])
		value = ft_strdup(ft_strchr(shell->env[i], '=') + 1);
	else
		value = ft_strdup("");
	escape_char_safe(&value, '\\');
	if (delimiter && *(delimiter - 1) == ' ')
		escape_char_safe(&value, ' ');
	if (delimiter && *delimiter)
	{
		delimiter++;
		ret = ft_strjoin(value, delimiter);
	}
	else
		ret = ft_strdup(value);
	free(value);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4572
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3d, %esi
callq 0x8110
movq %rax, %rdi
addq $0x1, %rdi
callq 0x8190
movq %rax, -0x28(%rbp)
jmp 0x4582
leaq 0x4aa5(%rip), %rdi      # 0x901e
callq 0x8190
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x5c, %esi
callq 0x4b00
cmpq $0x0, -0x10(%rbp)
je 0x45b2
movq -0x10(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x45b2
leaq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0x4b00
cmpq $0x0, -0x10(%rbp)
je 0x45e4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x45e4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8210
movq %rax, -0x20(%rbp)
jmp 0x45f1
movq -0x28(%rbp), %rdi
callq 0x8190
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion.c
// Function: expansion
char			*expansion(t_shell *shell, char *str)
{
	char	**env_split;

	str = escape_char(str, '$');
	env_split = ft_split_non_escaped(str, '$');
	if (env_split[0])
	{
		if (env_split[1] || (*env_split[0] != *str))
		{
			free(str);
			str = parse_expansion(shell, env_split, (short)(*str == '$'));
		}
	}
	clean_matrix(env_split);
	free(env_split);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x4900
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x24, %esi
callq 0x5520
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x469f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x466e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x469d
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movswl %ax, %edx
callq 0x46c0
movq %rax, -0x10(%rbp)
jmp 0x469f
movq -0x18(%rbp), %rdi
callq 0x6f80
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion.c
// Function: parse_expansion
static	char	*parse_expansion(t_shell *shell, char **env_split,
								short first_is_env)
{
	int		len;
	char	*buff;
	char	*tmp;

	len = 0;
	buff = ft_strdup("");
	while (env_split[len])
		len++;
	while (--len >= 0)
	{
		if (env_split[len][1] == '?' && !env_split[len][3])
			env_split[len] = last_proc_status(shell, env_split[len]);
		else if (len || first_is_env)
		{
			tmp = ft_strdup(env_split[len]);
			free(env_split[len]);
			env_split[len] = expand_var(tmp, shell);
			free(tmp);
		}
		tmp = ft_strdup(buff);
		free(buff);
		buff = append_expanded(tmp, env_split[len]);
		free(tmp);
	}
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
leaq 0x4939(%rip), %rdi      # 0x901e
callq 0x8190
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4708
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x46ee
jmp 0x470a
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x4802
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3f, %eax
jne 0x4769
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0x3(%rax)
jne 0x4769
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4810
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x47c5
cmpl $0x0, -0x18(%rbp)
jne 0x4778
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
je 0x47c3
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8190
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x43f0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x47c5
movq -0x20(%rbp), %rdi
callq 0x8190
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4aa0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x470a
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion_utils.c
// Function: count_keys_to_scape
int		count_keys_to_scape(char *str, char key)
{
	int		backslashes;
	int		i;

	i = 0;
	backslashes = 0;
	while (str[i])
	{
		if ((key == ' ' && str[i] == ' ') ||
			(key == '$' && str[i] == '$' &&
			((!str[i + 1] || str[i + 1] == ' ') ||
			str[i + 1] == '%')))
			backslashes++;
		i++;
	}
	return (backslashes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x48f8
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jne 0x4888
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x48e1
movsbl -0x9(%rbp), %eax
cmpl $0x24, %eax
jne 0x48ea
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0x48ea
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x48e1
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x48e1
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x48ea
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x485c
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion_utils.c
// Function: escape_char
char	*escape_char(char *str, char key)
{
	char	*buff;
	int		j;
	int		i;

	i = -1;
	j = -1;
	if (!(buff = malloc((ft_strlen(str) + count_keys_to_scape(str, key))
					* sizeof(char *))))
		return (NULL);
	while (str[++i])
	{
		if (str[i] == '$' && str[i - 1] != '\\')
		{
			if (!str[i + 1] ||
				str[i + 1] == ' ' ||
				str[i + 1] == '\\' ||
				str[i + 1] == '%')
				buff[++j] = '\\';
		}
		else if (key != '$' && str[i] == key)
			buff[++j] = '\\';
		buff[++j] = str[i];
	}
	buff[++j] = '\0';
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x4840
movq -0x30(%rbp), %rdi
cltq
addq %rax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4963
movq $0x0, -0x8(%rbp)
jmp 0x4a87
jmp 0x4965
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4a6b
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0x4a15
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x4a15
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x49ff
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x49ff
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x49ff
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
jne 0x4a13
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x5c, (%rax,%rcx)
jmp 0x4a48
movsbl -0x11(%rbp), %eax
cmpl $0x24, %eax
je 0x4a46
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4a46
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x5c, (%rax,%rcx)
jmp 0x4a48
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x4965
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/expansion/expansion_utils.c
// Function: append_expanded
char	*append_expanded(char *buff, char *env)
{
	char	*tmp;

	if (*env == '\\' && !(*(env + 1)))
		return (buff);
	tmp = ft_strjoin(env, buff);
	return (tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4ad0
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x4ad0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4ae9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8210
movq %rax, -0x20(%rbp)
movq -0x20(%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/vdedios[P]minishell/srcs/parsing/expansion/expansion_utils.c
// Function: escape_char_safe
void	escape_char_safe(char **value, char c)
{
	char	*tmp;

	tmp = ft_strdup(*value);
	free(*value);
	*value = escape_char(tmp, c);
	free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8190
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4900
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/parser.c
// Function: get_args
char			**get_args(char *input)
{
	char **args;

	if (!input)
		return (NULL);
	args = ft_split_non_escaped(input, ' ');
	delete_residual_backslash(args);
	if (!args)
		return (NULL);
	return (args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4b7d
movq $0x0, -0x8(%rbp)
jmp 0x4bb1
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x5520
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4bc0
cmpq $0x0, -0x18(%rbp)
jne 0x4ba9
movq $0x0, -0x8(%rbp)
jmp 0x4bb1
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/vdedios[P]minishell/srcs/parsing/parser.c
// Function: delete_residual_backslash
static void		delete_residual_backslash(char **args)
{
	char	*tmp;
	size_t	it;

	it = -1;
	while (args[++it])
	{
		tmp = parse_backslash(args[it], 1);
		free(args[it]);
		args[it] = ft_strdup(tmp);
		free(tmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x4c3d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x3b70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x8190
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x4bd4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/parser.c
// Function: parse_input
char			*parse_input(char *input)
{
	char *tmp;
	char *buff;

	tmp = parse_quotes(input);
	if (tmp)
	{
		buff = parse_backslash(tmp, 0);
		free(tmp);
	}
	else
		buff = NULL;
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ca0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4c8a
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3b70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x4c92
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/quotes/quotes.c
// Function: parse_quotes
char		*parse_quotes(char *str)
{
	char	*str_in_quotes;
	char	*buff;
	char	*tmp;
	int		opening;
	int		closing;

	buff = ft_strdup("");
	while (*str)
	{
		if (!(str_in_quotes = remove_quotes(str, &opening, &closing)))
		{
			free(buff);
			return (NULL);
		}
		tmp = join_parsed_str(str, str_in_quotes, buff, opening);
		free(buff);
		buff = tmp;
		if (str_in_quotes != str)
			free(str_in_quotes);
		if (opening != -1)
			str += (closing + 1);
		else
			break ;
	}
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x436b(%rip), %rdi      # 0x901e
callq 0x8190
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4d56
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4d70
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4cf7
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x4d5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x4e40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x4d33
movq -0x18(%rbp), %rdi
callq 0x1030
cmpl $-0x1, -0x2c(%rbp)
je 0x4d4f
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x4d51
jmp 0x4d56
jmp 0x4cbc
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/vdedios[P]minishell/srcs/parsing/quotes/quotes.c
// Function: remove_quotes
static char	*remove_quotes(char *str, int *opening, int *closing)
{
	char	quote;

	*opening = 0;
	while (str[*opening])
	{
		if ((str[*opening] == '\'' || str[*opening] == '\"')
			&& check_prev_backslashes(str, *opening))
		{
			quote = str[*opening];
			return (find_closing_quote(str, quote, *opening, closing));
		}
		*opening += 1;
	}
	*opening = -1;
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4e1c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0x4dc7
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0x4e0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x4fc0
cwtl
cmpl $0x0, %eax
je 0x4e0c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x5400
movq %rax, -0x8(%rbp)
jmp 0x4e2e
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4d8e
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%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/vdedios[P]minishell/srcs/parsing/quotes/quotes.c
// Function: join_parsed_str
static char	*join_parsed_str(char *str, char *str_in_quotes,
								char *buff, int opening)
{
	char	*tmp_in_quotes;
	char	*tmp;

	tmp_in_quotes = embrace_expansion(str_in_quotes);
	if (opening != -1)
	{
		tmp = mantain_expansion_spaces(tmp_in_quotes);
		free(tmp_in_quotes);
		tmp_in_quotes = ft_strdup(tmp);
		free(tmp);
	}
	if (opening && opening != -1)
		tmp = join_prev_in_quotes(str, buff,
									tmp_in_quotes, opening);
	else
	{
		if (ft_strcmp(buff, ""))
			tmp = ft_strdup(tmp_in_quotes);
		else
			tmp = ft_strjoin(buff, tmp_in_quotes);
	}
	free(tmp_in_quotes);
	return (tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43b0
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x4e96
movq -0x28(%rbp), %rdi
callq 0x4240
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x8190
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1030
cmpl $0x0, -0x1c(%rbp)
je 0x4ebc
cmpl $-0x1, -0x1c(%rbp)
je 0x4ebc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x4f10
movq %rax, -0x30(%rbp)
jmp 0x4ef4
movq -0x18(%rbp), %rdi
leaq 0x4157(%rip), %rsi      # 0x901e
callq 0x8690
cmpq $0x0, %rax
je 0x4ee1
movq -0x28(%rbp), %rdi
callq 0x8190
movq %rax, -0x30(%rbp)
jmp 0x4ef2
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8210
movq %rax, -0x30(%rbp)
jmp 0x4ef4
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/quotes/quotes.c
// Function: join_prev_in_quotes
static char	*join_prev_in_quotes(char *str, char *buff,
									char *tmp_in_quotes, int opening)
{
	char	*str_pre_quotes;
	char	*tmp_pre_quotes;
	char	*tmp;
	char	*tmp2;

	if (!(str_pre_quotes = malloc((opening + 1) * sizeof(char))))
		return (NULL);
	ft_strlcpy(str_pre_quotes, str, opening + 1);
	tmp_pre_quotes = embrace_expansion(str_pre_quotes);
	tmp = ft_strjoin(buff, tmp_pre_quotes);
	tmp2 = ft_strjoin(tmp, tmp_in_quotes);
	free(tmp_pre_quotes);
	free(str_pre_quotes);
	free(tmp);
	return (tmp2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4f4d
movq $0x0, -0x8(%rbp)
jmp 0x4fb5
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x8470
movq -0x30(%rbp), %rdi
callq 0x43b0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8210
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8210
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x40(%rbp), %rdi
callq 0x1030
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/quotes/quotes_utils.c
// Function: check_prev_backslashes
short	check_prev_backslashes(char *str, int i)
{
	int n;

	n = 0;
	while (i && str[--i] == '\\')
		n++;
	return ((n + 1) % 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x4ffa
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5003
jmp 0x500e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4fd2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %dx, %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/quotes/quotes_utils.c
// Function: n_special_chars
int		n_special_chars(char *str, int opening, int closing, char quote)
{
	int	i;
	int	n;

	i = opening + 1;
	n = 0;
	while (i < closing)
	{
		if (quote != '\'' && is_special_char(str[i]))
			n++;
		else if (is_space(str[i]))
			n++;
		i++;
	}
	return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5187
movsbl -0x11(%rbp), %eax
cmpl $0x27, %eax
je 0x515a
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5080
cwtl
cmpl $0x0, %eax
je 0x515a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x517c
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x50d0
cmpw $0x0, %ax
je 0x517a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x517c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5127
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/quotes/quotes_utils_2.c
// Function: alloc_in_quotes
char	*alloc_in_quotes(char *str, char quote, int opening, int closing)
{
	char *buff;

	if (!(buff = malloc((closing - opening
		+ n_special_chars(str, opening, closing, quote) + 1)
		* sizeof(char))))
		return (NULL);
	return (buff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movsbl -0x11(%rbp), %ecx
callq 0x5100
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x51ee
movq $0x0, -0x8(%rbp)
jmp 0x51f6
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/vdedios[P]minishell/srcs/parsing/quotes/quotes_utils_2.c
// Function: find_closing_quote
char	*find_closing_quote(char *str, char quote
								, int opening, int *closing)
{
	int	i;

	i = opening + 1;
	*closing = 0;
	if (str[i] == quote && i >= 2 && str[i - 2] == ' ')
	{
		*closing += opening + 1;
		return (ft_strdup("\"\" "));
	}
	while (str[i])
	{
		if (str[i] == quote
			&& (quote == '\'' || check_prev_backslashes(str, i)))
		{
			*closing += opening + 1;
			return (get_string_between_quotes(str, opening
						, *closing, quote));
		}
		*closing += 1;
		i++;
	}
	handle_quote_error(quote);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x547f
cmpl $0x2, -0x24(%rbp)
jl 0x547f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x547f
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
leaq 0x3cfa(%rip), %rdi      # 0x916b
callq 0x8190
movq %rax, -0x8(%rbp)
jmp 0x550f
jmp 0x5481
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x54fe
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x54e8
movsbl -0x11(%rbp), %eax
cmpl $0x27, %eax
je 0x54be
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x4fc0
cwtl
cmpl $0x0, %eax
je 0x54e8
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movsbl -0x11(%rbp), %ecx
callq 0x5200
movq %rax, -0x8(%rbp)
jmp 0x550f
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5481
movsbl -0x11(%rbp), %edi
callq 0x53b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped.c
// Function: ft_split_non_escaped
char			**ft_split_non_escaped(char *input, char delimiter)
{
	char	**args;
	int		len;

	if (!(args = malloc((count_args(input, delimiter) + 2) * sizeof(char *))))
		return (NULL);
	len = ft_strlen(input);
	input = set_split_delimiter(input, delimiter);
	divide_arguments(args, input, len);
	return (args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x58c0
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5562
movq $0x0, -0x8(%rbp)
jmp 0x5597
movq -0x10(%rbp), %rdi
callq 0x8550
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x55b0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x5670
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped.c
// Function: set_split_delimiter
static char		*set_split_delimiter(char *input, char delimiter)
{
	int	i;

	i = 0;
	while (*input == ' ')
		input++;
	while (*input == delimiter)
		input++;
	while (input[i])
	{
		if (is_delimiter(input[i], delimiter) && not_escaped(input, i))
			input[i] = '\0';
		i++;
	}
	return (input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x55e3
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x55c9
jmp 0x55e5
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5602
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x55e5
jmp 0x5604
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5658
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movsbl %al, %edi
movsbl -0x9(%rbp), %esi
callq 0x5860
cwtl
cmpl $0x0, %eax
je 0x564d
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x57a0
cwtl
cmpl $0x0, %eax
je 0x564d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5604
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped.c
// Function: divide_arguments
static	void	divide_arguments(char **args, char *input, int len)
{
	int		i;
	int		j;
	char	*tmp;

	i = 0;
	j = 0;
	while (i < len)
	{
		args[j] = ft_strdup(&input[i]);
		if (!ft_strncmp(args[j], "\"\"", 3))
		{
			tmp = ft_strdup("");
			free(args[j]);
			args[j] = tmp;
			i += 2;
		}
		else
			i += ft_strlen(args[j]);
		j++;
		while (i < len && !input[i])
			i++;
		if (i >= len)
			break ;
	}
	args[j] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5785
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
callq 0x8190
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3aa0(%rip), %rsi      # 0x916f
movl $0x3, %edx
callq 0x85c0
cmpl $0x0, %eax
jne 0x571a
leaq 0x3939(%rip), %rdi      # 0x901e
callq 0x8190
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x5738
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8550
movq %rax, %rcx
movslq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x5762
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x576b
jmp 0x5776
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5741
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x5780
jmp 0x5785
jmp 0x5691
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped.c
// Function: not_escaped
static	short	not_escaped(char *str, int i)
{
	int		backslash;

	i--;
	backslash = 0;
	while (i >= 0 && str[i] == '\\')
	{
		i--;
		backslash++;
	}
	if (backslash > 1 && str[i] == ' ')
		backslash = 1;
	return ((backslash + 1) % 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0x57db
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x57e4
jmp 0x57f8
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x57bb
cmpl $0x1, -0x10(%rbp)
jle 0x5816
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x5816
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %dx, %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped_utils.c
// Function: is_delimiter
short	is_delimiter(char input, char delimiter)
{
	if (delimiter == ' ' && is_whitespace(input))
		return (1);
	else if (input == delimiter)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movsbl -0x4(%rbp), %eax
cmpl $0x20, %eax
jne 0x5894
movsbl -0x3(%rbp), %edi
callq 0x5830
cwtl
cmpl $0x0, %eax
je 0x5894
movw $0x1, -0x2(%rbp)
jmp 0x58b0
movsbl -0x3(%rbp), %eax
movsbl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x58a8
movw $0x1, -0x2(%rbp)
jmp 0x58b0
jmp 0x58aa
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/parsing/utils/split_non_escaped_utils.c
// Function: count_args
int		count_args(char *input, char delimiter)
{
	int		i;
	int		l;

	l = 0;
	i = 0;
	while (input[i])
	{
		if (is_delimiter(input[i], delimiter) && input[i - 1] != '\\')
		{
			l++;
			while (input[i] && !is_delimiter(input[i], delimiter))
				i++;
		}
		i++;
	}
	return (l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x598b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movsbl %al, %edi
movsbl -0x9(%rbp), %esi
callq 0x5860
cwtl
cmpl $0x0, %eax
je 0x597d
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0x597d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x5967
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
movsbl %al, %edi
movsbl -0x9(%rbp), %esi
callq 0x5860
cmpw $0x0, %ax
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5970
jmp 0x597b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x592e
jmp 0x597d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x58e0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator.c
// Function: validate_input
int				validate_input(t_shell *shell, char *line)
{
	int it;

	it = -1;
	while (line[++it])
	{
		if (line[it] == '|' ||
			line[it] == '<' ||
			line[it] == '>' ||
			line[it] == ';')
		{
			if (validator(shell, line, line[it], it))
				return (0);
		}
	}
	return (1);
	if (line[it + 1] == '<' || line[it + 1] == '>')
		it++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5a44
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
je 0x5a11
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
je 0x5a11
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
je 0x5a11
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x5a3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x1c(%rbp), %ecx
movsbl %al, %edx
callq 0x5a60
cmpl $0x0, %eax
je 0x5a3d
movl $0x0, -0x4(%rbp)
jmp 0x5a4b
jmp 0x5a3f
jmp 0x59b7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator.c
// Function: validator
static int		validator(t_shell *shell, char *line, char separator, int it)
{
	char	*key;

	if (prior_to_token(line, it - 1, line[it]))
	{
		if (get_validator_err(shell, line, separator, it))
			return (1);
		return (0);
	}
	else if (separator == '|' && nothing_after_pipe(&line[it + 1], it))
	{
		print_errors(shell,
				"line 1: syntax error: unexpected end of file", NULL);
		shell->stat_loc = 2;
		return (1);
	}
	else if ((key = post_to_token(shell, line, it, line[it])))
	{
		safe_print_err(shell, key);
		shell->stat_loc = 1;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
subl $0x1, %esi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0x5c80
cmpw $0x0, %ax
je 0x5acc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
movl -0x20(%rbp), %ecx
movsbl %al, %edx
callq 0x5e40
cmpl $0x0, %eax
je 0x5ac0
movl $0x1, -0x4(%rbp)
jmp 0x5b6c
movl $0x0, -0x4(%rbp)
jmp 0x5b6c
movsbl -0x19(%rbp), %eax
cmpl $0x7c, %eax
jne 0x5b1a
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x5db0
cwtl
cmpl $0x0, %eax
je 0x5b1a
movq -0x10(%rbp), %rdi
leaq 0x3675(%rip), %rsi      # 0x9172
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
movq -0x10(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5b6c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
callq 0x5b80
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5b61
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5f70
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5b6c
jmp 0x5b63
jmp 0x5b65
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator_utils.c
// Function: post_to_token
char		*post_to_token(t_shell *shell, char *line, int it, char token)
{
	char	*key;
	char	*value;
	char	*tmp;

	if (token == '>')
		while (line[it++])
			if (line[it] == '}' && line[it - 1] != ' ')
			{
				key = get_var_key(line, it);
				value = expand_var(key, shell);
				if (contain_spaces(value))
				{
					free(value);
					tmp = ft_strjoin("$", key);
					free(key);
					return (tmp);
				}
				free(key);
				free(value);
			}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
cmpl $0x3e, %eax
jne 0x5c67
jmp 0x5ba7
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5c65
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7d, %eax
jne 0x5c60
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x5c60
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1e40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1f20
cmpw $0x0, %ax
je 0x5c4e
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rsi
leaq 0x356d(%rip), %rdi      # 0x919f
callq 0x8210
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c6f
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
jmp 0x5ba7
jmp 0x5c67
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator_utils.c
// Function: prior_to_token
short		prior_to_token(char *line, int it, char token)
{
	int aux_it;

	aux_it = it;
	while (aux_it > 0 && line[aux_it] == ' ')
		aux_it--;
	if (token == '>' || token == '<')
		return (aux_it > 0 && aux_it != it &&
				(line[aux_it] == '>' ||
				line[aux_it] == '<'));
	else
	{
		return (aux_it < 1 ||
				line[aux_it] == ';' ||
				line[aux_it] == '>' ||
				line[aux_it] == '<' ||
				line[aux_it] == '|');
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jle 0x5cb6
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x5cbf
jmp 0x5cca
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5c96
movsbl -0x15(%rbp), %eax
cmpl $0x3e, %eax
je 0x5cdc
movsbl -0x15(%rbp), %eax
cmpl $0x3c, %eax
jne 0x5d33
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1e(%rbp)
jle 0x5d25
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x1e(%rbp)
je 0x5d25
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x1f(%rbp)
je 0x5d1f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
sete %al
movb %al, -0x1f(%rbp)
movb -0x1f(%rbp), %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
jmp 0x5da1
movb $0x1, %al
cmpl $0x1, -0x1c(%rbp)
movb %al, -0x20(%rbp)
jl 0x5d95
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x3b, %ecx
movb %al, -0x20(%rbp)
je 0x5d95
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x20(%rbp)
je 0x5d95
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, -0x20(%rbp)
je 0x5d95
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
sete %al
movb %al, -0x20(%rbp)
movb -0x20(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator_utils.c
// Function: nothing_after_pipe
short		nothing_after_pipe(char *line, int it)
{
	if ((it - 2) >= 0 && *(line - 2) == '\\')
		return (0);
	while (*line && *line == ' ')
		line++;
	if (!*line)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
cmpl $0x0, %eax
jl 0x5ddb
movq -0x10(%rbp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x5c, %eax
jne 0x5ddb
movw $0x0, -0x2(%rbp)
jmp 0x5e2c
jmp 0x5ddd
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x5dfe
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x5e07
jmp 0x5e15
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5ddd
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x5e26
movw $0x1, -0x2(%rbp)
jmp 0x5e2c
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/validator/validator_utils.c
// Function: get_validator_err
int			get_validator_err(t_shell *shell,
		char *line, char separator, int it)
{
	if (separator == ';')
		print_errors(shell, "syntax error near unexpected token `;'", NULL);
	else if (separator == '|')
		print_errors(shell, "syntax error near unexpected token `|'", NULL);
	else if (separator == '>' && line[it + 1] == '>')
		print_errors(shell, "syntax error near unexpected token `>>'", NULL);
	else if (separator == '>')
		print_errors(shell, "syntax error near unexpected token `>'", NULL);
	else if (separator == '<' && line[it + 1] == '<')
		print_errors(shell, "syntax error near unexpected token `<<'", NULL);
	else if (separator == '<')
		print_errors(shell, "syntax error near unexpected token `<'", NULL);
	shell->stat_loc = 2;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3b, %eax
jne 0x5e7a
movq -0x8(%rbp), %rdi
leaq 0x3335(%rip), %rsi      # 0x91a1
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f4c
movsbl -0x11(%rbp), %eax
cmpl $0x7c, %eax
jne 0x5e9c
movq -0x8(%rbp), %rdi
leaq 0x333a(%rip), %rsi      # 0x91c8
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f4a
movsbl -0x11(%rbp), %eax
cmpl $0x3e, %eax
jne 0x5ed1
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
jne 0x5ed1
movq -0x8(%rbp), %rdi
leaq 0x3329(%rip), %rsi      # 0x91ef
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f48
movsbl -0x11(%rbp), %eax
cmpl $0x3e, %eax
jne 0x5ef0
movq -0x8(%rbp), %rdi
leaq 0x3332(%rip), %rsi      # 0x9217
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f46
movsbl -0x11(%rbp), %eax
cmpl $0x3c, %eax
jne 0x5f25
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x5f25
movq -0x8(%rbp), %rdi
leaq 0x3324(%rip), %rsi      # 0x923e
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f44
movsbl -0x11(%rbp), %eax
cmpl $0x3c, %eax
jne 0x5f42
movq -0x8(%rbp), %rdi
leaq 0x332d(%rip), %rsi      # 0x9266
xorl %eax, %eax
movl %eax, %edx
callq 0x6f10
jmp 0x5f44
jmp 0x5f46
jmp 0x5f48
jmp 0x5f4a
jmp 0x5f4c
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)