LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion_root.c
// Function: param_exp_get_env
char	*param_exp_get_env(t_control *control, char *str, int len)
{
	char *value;
	char **addr_value;

	if (!ft_strncmp(str, "?", len))
		return (ft_itoa(control->exit_status));
	addr_value = env_get_addr(str, len, control->env);
	//printf("str: [%s], len: %d\n", str,  len);
	//printf("value: %s\n", value);
	if (!addr_value)
		value = ft_strdup("");
	else
		value = ft_strdup(*addr_value);
	return (value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
leaq 0x6606(%rip), %rsi      # 0x11378
callq 0xfb60
cmpl $0x0, %eax
jne 0xad8e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0xeb70
movq %rax, -0x8(%rbp)
jmp 0xadd8
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x3e50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xadc0
leaq 0x640a(%rip), %rdi      # 0x111bf
callq 0xf950
movq %rax, -0x28(%rbp)
jmp 0xadd0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xf950
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion2.c
// Function: parameter_expansion2
int	parameter_expansion2(t_list **token, char **var, t_expansion *exp)
{
	int field_split;

	((t_token *)(*token)->content)->unquote_protected = 1;
	((t_token *)(*token)->content)->protect_s = exp->start;
	field_split = need_to_field_split1(var, exp);
	if (field_split == 2 || (field_split == 1 && exp->is_filename))
		return (field_split);
	if (!field_split)
	{
		if (!param_exp_no_fsplit(*token, *var, exp))
			return (2);
	}
	else
	{
		if (!field_splitting_root(token, *var, exp))
			return (2);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl $0x1, 0x14(%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xaec0
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
je 0xae4e
cmpl $0x1, -0x24(%rbp)
jne 0xae56
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0xae56
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaeae
cmpl $0x0, -0x24(%rbp)
jne 0xae83
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xafb0
cmpl $0x0, %eax
jne 0xae81
movl $0x2, -0x4(%rbp)
jmp 0xaeae
jmp 0xaea7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xb0d0
cmpl $0x0, %eax
jne 0xaea5
movl $0x2, -0x4(%rbp)
jmp 0xaeae
jmp 0xaea7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion2.c
// Function: need_to_field_split1
int	need_to_field_split1(char **str, t_expansion *exp)
{
	char *tmp;

	tmp = *str;
	if (exp->quoted || (exp->ifs && !ft_strlen(exp->ifs)))
		return (0);
	if (!exp->ifs)
	{
		if (!(*str = ft_strtrim(*str, " \t\n")))
		{
			free(tmp);
			return (2);
		}
		free(tmp);
		if (-1 != ft_stristr(*str, " \t\n"))
			return (1);
		return (0);
	}
	else
	{
		return (need_to_field_split2(str, exp));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xaf06
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xaf12
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfb10
cmpq $0x0, %rax
jne 0xaf12
movl $0x0, -0x4(%rbp)
jmp 0xaf98
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xaf88
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x644f(%rip), %rsi      # 0x1137a
callq 0xfcd0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaf4f
movq -0x20(%rbp), %rdi
callq 0x2230
movl $0x2, -0x4(%rbp)
jmp 0xaf98
movq -0x20(%rbp), %rdi
callq 0x2230
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x6414(%rip), %rsi      # 0x1137a
callq 0x10370
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0xaf7f
movl $0x1, -0x4(%rbp)
jmp 0xaf98
movl $0x0, -0x4(%rbp)
jmp 0xaf98
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb040
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion2.c
// Function: param_exp_no_fsplit
int	param_exp_no_fsplit(t_list *token, char *var, t_expansion *exp)
{
	char **ptr_str;

	ptr_str = &((t_token*)token->content)->str;
	((t_token *)token->content)->protect_e = ft_strlen(var) + exp->start;
	if (!ft_strstradd(ptr_str, exp->start, var))
		return (0);
	exp->start += ft_strlen(var);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfb10
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x1c(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x107d0
cmpl $0x0, %eax
jne 0xb00f
movl $0x0, -0x4(%rbp)
jmp 0xb02e
movq -0x18(%rbp), %rdi
callq 0xfb10
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion2.c
// Function: need_to_field_split2
int	need_to_field_split2(char **str, t_expansion *exp)
{
	char *tmp;

	tmp = *str;
	if (!(*str = ft_strtrim(*str, exp->ifs)))
	{
		free(tmp);
		return (2);
	}
	free(tmp);
	if (-1 != ft_stristr(*str, exp->ifs))
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xfcd0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb08e
movq -0x20(%rbp), %rdi
callq 0x2230
movl $0x2, -0x4(%rbp)
jmp 0xb0c6
movq -0x20(%rbp), %rdi
callq 0x2230
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10370
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0xb0bf
movl $0x1, -0x4(%rbp)
jmp 0xb0c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/field_splitting_root.c
// Function: field_splitting_root
int	field_splitting_root(t_list **token, char *var, t_expansion *exp)
{
	char *str1;
	char *str2;

	str1 = ((t_token*)(*token)->content)->str;
	if (!(str2 = ft_substr(str1, exp->start, ft_strlen(str1) + exp->start)))
		return (0);
	str1[exp->start] = '\0';
//	printf("before param expansion: (str1) = [%s]\n", str1);
//	printf("after param expansion: (str2)  = [%s]\n", str2);
	if (!field_splitting_root_assist(token, exp, var, str2))
	{
		free(str2);
		return (0);
	}
	free(str2);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfb10
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rax
addq %rax, %rdx
callq 0xff10
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xb13b
movl $0x0, -0x4(%rbp)
jmp 0xb186
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xb190
cmpl $0x0, %eax
jne 0xb176
movq -0x30(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0xb186
movq -0x30(%rbp), %rdi
callq 0x2230
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/field_splitting_root.c
// Function: field_splitting_root_assist
int	field_splitting_root_assist(t_list **token, t_expansion *exp, char *var,\
		char *str2)
{
	char	**array;

	if (!exp->ifs)
	{
		if (!(array = ft_split_whitespaces(var, " \n\t")))
			return (0);
	}
	else if (!(array = ft_split_whitespaces(var, exp->ifs)))
		return (0);
	((t_token *)(*token)->content)->protect_e = exp->start + \
				ft_strlen(array[0]);
	//debug_array(array);
	if (!field_splitting(token, exp, array, str2))
	{
		ft_array_free(array, ft_array_len(array));
		return (0);
	}
	ft_array_free(array, ft_array_len(array));
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb1db
movq -0x20(%rbp), %rdi
leaq 0x61c0(%rip), %rsi      # 0x1137e
callq 0xf4a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xb1d9
movl $0x0, -0x4(%rbp)
jmp 0xb296
jmp 0xb204
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xf4a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xb202
movl $0x0, -0x4(%rbp)
jmp 0xb296
jmp 0xb204
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xfb10
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xb2a0
cmpl $0x0, %eax
jne 0xb273
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10410
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x102f0
movl $0x0, -0x4(%rbp)
jmp 0xb296
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10410
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x102f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/field_splitting_root.c
// Function: field_splitting
int	field_splitting(t_list **tok, t_expansion *exp, char **array, char *str2)
{
	char	**str;
	int		i;

	i = 1;
	str = &((t_token*)(*tok)->content)->str;
	if (array[0] && !(*str = ft_strjoin_free(*str, array[0], 1)))
		return (0);
	while (array[i])
	{
		tok = &(*tok)->next;
		if (!(field_splitting_assist(tok, array[i])))
			return (0);
		i++;
	}
	str = &((t_token*)(*tok)->content)->str;
	exp->start = ft_strlen(*str);
	if (!(*str = ft_strjoin_free(*str, str2, 1)))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb308
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0xfab0
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb308
movl $0x0, -0x4(%rbp)
jmp 0xb3aa
jmp 0xb30a
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb356
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xb3c0
cmpl $0x0, %eax
jne 0xb34b
movl $0x0, -0x4(%rbp)
jmp 0xb3aa
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xb30a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0xfb10
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0xfab0
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb3a3
movl $0x0, -0x4(%rbp)
jmp 0xb3aa
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/field_splitting_root.c
// Function: field_splitting_assist
int	field_splitting_assist(t_list **tok, char *str)
{
	t_list	*new_link;
	t_token	*new_token;

	if (!(new_token = lexer_init_token()))
		return (0);
	if (!(new_token->str = ft_strdup(str)))
	{
		free(new_token);
		return (0);
	}
	new_token->id = TOKEN;
	new_token->unquote_protected = 1;
	new_token->protect_s = 0;
	new_token->protect_e = ft_strlen(new_token->str);
	if (!(new_link = ft_lstnew(new_token)))
	{
		del_token(new_token);
		return (0);
	}
	ft_lstadd_front(tok, new_link);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x29b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xb3eb
movl $0x0, -0x4(%rbp)
jmp 0xb482
movq -0x18(%rbp), %rdi
callq 0xf950
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb413
movq -0x28(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0xb482
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0xfb10
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x28(%rbp), %rdi
callq 0x10180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb46e
movq -0x28(%rbp), %rdi
callq 0x2940
movl $0x0, -0x4(%rbp)
jmp 0xb482
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10060
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/pathname_expansion_root.c
// Function: pathname_expansion_root
int	pathname_expansion_root(t_list **tokens, int is_filename)
{
	int res;

	while (*tokens)
	{
		if (!pathname_is_expandable(((t_token*)(*tokens)->content)->str))
			quote_removal((t_token*)(*tokens)->content);
		else
		{
			if ((res = pathname_expansion(&tokens, is_filename)))
				return (res);
		}
		tokens = &((*tokens)->next);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb500
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xb510
cmpl $0x0, %eax
jne 0xb4d1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd090
jmp 0xb4ef
movl -0x14(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0xb620
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xb4ed
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb507
jmp 0xb4ef
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xb49f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/pathname_expansion_root.c
// Function: pathname_is_expandable
int	pathname_is_expandable(char *str)
{
	int quoted;
	int	escaped;
	int i;

	quoted = 0;
	escaped = 0;
	i = 0;
	while (str[i])
	{
		if (!escaped && str[i] == '\\')
		{
			i++;
			escaped = 1;
			continue;
		}
		if (!escaped && !quoted && (str[i] == '\"' || str[i] == '\''))
			quoted = str[i];
		else if (!escaped && quoted && str[i] == quoted)
			quoted = 0;
		else if (!escaped && !quoted && str[i] == '*')
			return (1);
		escaped = 0;
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb60c
cmpl $0x0, -0x18(%rbp)
jne 0xb568
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xb568
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0xb52d
cmpl $0x0, -0x18(%rbp)
jne 0xb5a7
cmpl $0x0, -0x14(%rbp)
jne 0xb5a7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0xb596
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
jne 0xb5a7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0xb5f7
cmpl $0x0, -0x18(%rbp)
jne 0xb5cd
cmpl $0x0, -0x14(%rbp)
je 0xb5cd
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x14(%rbp), %eax
jne 0xb5cd
movl $0x0, -0x14(%rbp)
jmp 0xb5f5
cmpl $0x0, -0x18(%rbp)
jne 0xb5f3
cmpl $0x0, -0x14(%rbp)
jne 0xb5f3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0xb5f3
movl $0x1, -0x4(%rbp)
jmp 0xb613
jmp 0xb5f5
jmp 0xb5f7
movl $0x0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb52d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/pathname_expansion_root.c
// Function: pathname_expansion
int	pathname_expansion(t_list ***token, int is_filename)
{
	t_list		*path_parts;
	t_path_exp	tool;
	int res;

	if (!(path_parts = split_path_root(((t_token*)((**token)->content))->str)))
		return (2);
	init_path_expansion_struct(path_parts, &tool, is_filename);
	if ((res = pathname_matching_root(&tool, path_parts)))
	{
		ft_lstclear(&(tool.path_parts), delete_path_part_link);
		ft_lstclear(&(tool.matched_paths), del_token);
		return (res);
	}
	//debug_path_parts(tool.path_parts);
	ft_lstclear(&(tool.path_parts), delete_path_part_link);
	if (!tool.matched_paths)
		quote_removal((t_token*)(**token)->content);
	else
	{
		//debug_tokens_list(**token);
		word_expand_replace(token, tool.matched_paths);
		ft_lstclear(&(tool.path_parts), delete_path_part_link);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xbb80
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb65a
movl $0x2, -0x4(%rbp)
jmp 0xb6fa
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0xb710
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc3c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0xb6ab
leaq -0x38(%rbp), %rdi
leaq 0xa26(%rip), %rsi       # 0xc0b0
callq 0x10090
leaq -0x38(%rbp), %rdi
addq $0x10, %rdi
leaq -0x8d5e(%rip), %rsi     # 0x2940
callq 0x10090
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb6fa
leaq -0x38(%rbp), %rdi
leaq 0x9fa(%rip), %rsi       # 0xc0b0
callq 0x10090
cmpq $0x0, -0x28(%rbp)
jne 0xb6d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xd090
jmp 0xb6f3
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa870
leaq -0x38(%rbp), %rdi
leaq 0x9c2(%rip), %rsi       # 0xc0b0
callq 0x10090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/pathname_expansion_root.c
// Function: init_path_expansion_struct
void	init_path_expansion_struct(t_list *path_parts, t_path_exp *tool,\
		int is_filename)
{
	tool->path_parts = path_parts;
	tool->is_filename = is_filename;
	tool->first_match = 0;
	tool->matched_paths = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/tild_expansion_root.c
// Function: tild_expansion_root
int	tild_expansion_root(t_list *env, char **str)
{
	char	*home_env;
	int		start_assignement;
	int		index;

	index = 0;
	if (!(home_env = env_get("HOME", 4, env)))
		return (1);
	start_assignement = index_assignement_sign(*str);
	if (start_assignement == -1)
		return (tild_expand_try(str, home_env, &index));
	else
		return (expand_tild_in_assignement(str, home_env, start_assignement, \
				start_assignement));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x59ef(%rip), %rdi      # 0x11161
movl $0x4, %esi
callq 0x3dc0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xb78f
movl $0x1, -0x4(%rbp)
jmp 0xb7d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xb7e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xb7ba
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xb880
movl %eax, -0x4(%rbp)
jmp 0xb7d0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0xb9b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/tild_expansion_root.c
// Function: index_assignement_sign
int	index_assignement_sign(char *str)
{
	int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb80d
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0xe9b0
cmpl $0x0, %eax
jne 0xb816
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb870
jmp 0xb818
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb869
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0xb83f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb870
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xe9b0
cmpl $0x0, %eax
jne 0xb85e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb870
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb818
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/tild_expansion_root.c
// Function: tild_expand_try
int tild_expand_try(char **str, char *home_env, int *i)
{
	int res;

	if (!is_tild_expandable(*str, *i))
		return (1);
	ft_strcdel(*str, *i);
	res = ft_strstradd(str, *i, home_env);
	if (res)
		*i = *i + ft_strlen(home_env);
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0xb920
cmpl $0x0, %eax
jne 0xb8b4
movl $0x1, -0x4(%rbp)
jmp 0xb90f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x10760
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0x107d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xb909
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfb10
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/tild_expansion_root.c
// Function: is_tild_expandable
int	is_tild_expandable(char *str, int i)
{
	if (!str[i])
		return (0);
	if (str[i] != '~')
		return (0);
	i++;
	if (!str[i] || str[i] == '/' || str[i] == ':')
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0xb942
movl $0x0, -0x4(%rbp)
jmp 0xb9a5
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7e, %eax
je 0xb95c
movl $0x0, -0x4(%rbp)
jmp 0xb9a5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb995
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0xb995
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0xb99e
movl $0x1, -0x4(%rbp)
jmp 0xb9a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/tild_expansion_assist.c
// Function: expand_tild_in_assignement
int	expand_tild_in_assignement(char **str, char *home_env, int i, int start)
{
	int		esc_next;
	char	quoted;

	esc_next = 0;
	quoted = 0;
	while ((*str)[++i])
	{
		if ((i == start + 1) && !tild_expand_try(str, home_env, &i))
			return (0);
		if (!quoted && !esc_next && (*str)[i] == '\\')
		{
			esc_next = 1;
			continue;
		}
		if (!esc_next && ((*str)[i] == '\'' || (*str)[i] == '"'))
			path_set_quoted((*str)[i], &quoted);
		if (!quoted && !esc_next && (*str)[i] == ':')
		{
			if (!tild_expand_try_after_column(str, home_env, &i))
				return (0);
		}
		esc_next = 0;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbad9
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0xba1d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xb880
cmpl $0x0, %eax
jne 0xba1d
movl $0x0, -0x4(%rbp)
jmp 0xbae0
cmpb $0x0, -0x25(%rbp)
jne 0xba46
cmpl $0x0, -0x24(%rbp)
jne 0xba46
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xba46
movl $0x1, -0x24(%rbp)
jmp 0xb9d1
cmpl $0x0, -0x24(%rbp)
jne 0xba8c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0xba74
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0xba8c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
leaq -0x25(%rbp), %rsi
movsbl (%rax,%rcx), %edi
callq 0xbf40
cmpb $0x0, -0x25(%rbp)
jne 0xbacd
cmpl $0x0, -0x24(%rbp)
jne 0xbacd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0xbacd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xbaf0
cmpl $0x0, %eax
jne 0xbacb
movl $0x0, -0x4(%rbp)
jmp 0xbae0
jmp 0xbacd
movl $0x0, -0x24(%rbp)
jmp 0xb9d1
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/sources/tild_expansion_assist.c
// Function: tild_expand_try_after_column
int	tild_expand_try_after_column(char **str, char *home_env, int *i)
{
	if (!(*str)[*i + 1])
		return (1);
	(*i)++;
	if (is_tild_expandable(*str, *i))
		return (tild_expand_try(str, home_env, i));
	(*i)--;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0xbb26
movl $0x1, -0x4(%rbp)
jmp 0xbb70
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0xb920
cmpl $0x0, %eax
je 0xbb5e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb880
movl %eax, -0x4(%rbp)
jmp 0xbb70
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path_root.c
// Function: split_path_root
t_list	*split_path_root(char *path_to_dup_and_split)
{
	t_list *path_parts;
	char *dup_path;

	path_parts = NULL;
	if (!(dup_path = ft_strdup(path_to_dup_and_split)))
		return (NULL);
	//printf("str is: %s\n", dup_path);
	collapse_fwd_slashes(dup_path, 0, -1, 0);
	//printf("str2 is: %s\n", dup_path);
	if (!split_path(dup_path, &path_parts, 0))
	{
		free(dup_path);
		ft_lstclear(&path_parts, delete_path_part_link);
		return (NULL);
	}
	free(dup_path);
	//del me
	//debug_path_parts(path_parts);
	return (path_parts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf950
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xbbb1
movq $0x0, -0x8(%rbp)
jmp 0xbc0b
movq -0x20(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %ecx, %esi
callq 0xbc20
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xbd30
cmpl $0x0, %eax
jne 0xbbfa
movq -0x20(%rbp), %rdi
callq 0x2230
leaq -0x18(%rbp), %rdi
leaq 0x4c5(%rip), %rsi       # 0xc0b0
callq 0x10090
movq $0x0, -0x8(%rbp)
jmp 0xbc0b
movq -0x20(%rbp), %rdi
callq 0x2230
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path_root.c
// Function: collapse_fwd_slashes
void collapse_fwd_slashes(char *str, int esc_next, int i, int k)
{
	while (str[++i])
	{
		if (str[i] == '\\' && esc_next == 0)
		{
			esc_next = 1;
			continue;
		}
		if (esc_next != 1 && str[i] == '/')
		{
			k = i;
			while (str[++k])
			{
				if (str[k] != '/' && str[k] != '"' && str[k] != '\'')
				{
					i = k - 1;
					break;
				}
				if (str[k] == '/')
					ft_strcdel(str, k--);
			}
		}
		esc_next = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbd20
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xbc6f
cmpl $0x0, -0xc(%rbp)
jne 0xbc6f
movl $0x1, -0xc(%rbp)
jmp 0xbc35
cmpl $0x1, -0xc(%rbp)
je 0xbd14
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xbd14
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbd12
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0xbce8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0xbce8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0xbce8
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbd12
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xbd10
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rsi
callq 0x10760
jmp 0xbc94
jmp 0xbd14
movl $0x0, -0xc(%rbp)
jmp 0xbc35
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path_root.c
// Function: split_path
int	split_path(char *str, t_list **paths, int start)
{
	int		end;
	char	*path_part;
	char	quoted;
	char	start_quoted_at_next_path_part;

	quoted = 0;
	while (str[start])
	{
		start_quoted_at_next_path_part = quoted;
		end = find_path_end(str, start, &quoted);
		if (!(path_part = ft_substr(str, start, end - start)))
			return (0);
		//printf("\nend char: [%c]\n", str[end]);
	//	printf("full_path was:	[%s]\n", str);
		//printf("path_part = [%s]\n", path_part);
		if (!add_path_part(path_part, paths, start_quoted_at_next_path_part))
			return (0);
		if (end == (int)ft_strlen(str))
			return (1);
		start = end + 1;
	}
	if (!(path_part = ft_strdup("")))
		return (0);
	return (add_path_part(path_part, paths, start_quoted_at_next_path_part));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbdec
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x29(%rbp), %rdx
callq 0xbe30
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movslq %eax, %rdx
callq 0xff10
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xbd9d
movl $0x0, -0x4(%rbp)
jmp 0xbe1f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x2a(%rbp), %edx
callq 0xbf80
cmpl $0x0, %eax
jne 0xbdbc
movl $0x0, -0x4(%rbp)
jmp 0xbe1f
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfb10
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0xbdde
movl $0x1, -0x4(%rbp)
jmp 0xbe1f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbd47
leaq 0x53cc(%rip), %rdi      # 0x111bf
callq 0xf950
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xbe0b
movl $0x0, -0x4(%rbp)
jmp 0xbe1f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x2a(%rbp), %edx
callq 0xbf80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path_root.c
// Function: find_path_end
int	find_path_end(char *str, int i, char *quoted)
{
	int esc_next;

	esc_next = 0;
	while (str[i])
	{
		if (!esc_next & (str[i] == '"' || str[i] == '\''))
			path_set_quoted(str[i], quoted);
		if (!esc_next && str[i] == '\\')
		{
			esc_next = 1;
			i++;
			continue;
		}
		if (!esc_next && str[i] == '/')
			return (i);
		esc_next = 0;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xbf22
cmpl $0x0, -0x24(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x22, %ecx
movb %al, -0x25(%rbp)
je 0xbe98
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
sete %al
movb %al, -0x25(%rbp)
movl -0x2c(%rbp), %eax
movb -0x25(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xbec2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x20(%rbp), %rsi
movsbl %al, %edi
callq 0xbf40
cmpl $0x0, -0x24(%rbp)
jne 0xbeee
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xbeee
movl $0x1, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbe4a
cmpl $0x0, -0x24(%rbp)
jne 0xbf0d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0xbf0d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbf28
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbe4a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path_root.c
// Function: path_set_quoted
void path_set_quoted(char c, char *quoted)
{
	if (!*quoted)
	{
		*quoted = c;
		return;
	}
	if (c == quoted[0])
		quoted[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xbf62
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xbf78
movsbl -0x1(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xbf78
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path2.c
// Function: add_path_part
int	add_path_part(char *str, t_list **path_parts, char quoted)
{
	t_path_part *path_part;
	t_list *new_link;

	if (!(path_part = init_path_part_link(str, quoted)))
	{
		free(str);
		return (0);
	}
	if (!path_part_unquoting(path_part, path_part->path_part))
	{
		delete_path_part_link(path_part);
		return (0);
	}
	//debug_path_part(path_part);
	if (!(new_link = ft_lstnew(path_part)))
	{
		delete_path_part_link(path_part);
		return (0);
	}
	ft_lstadd_back(path_parts, new_link);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0xc030
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xbfbe
movq -0x10(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0xc01e
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0xc100
cmpl $0x0, %eax
jne 0xbfe5
movq -0x28(%rbp), %rdi
callq 0xc0b0
movl $0x0, -0x4(%rbp)
jmp 0xc01e
movq -0x28(%rbp), %rdi
callq 0x10180
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xc00a
movq -0x28(%rbp), %rdi
callq 0xc0b0
movl $0x0, -0x4(%rbp)
jmp 0xc01e
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfff0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path2.c
// Function: init_path_part_link
t_path_part *init_path_part_link(char *str, char quoted)
{
	t_path_part *new;

	if (!str)
		return (NULL);
	if (!(new = (t_path_part *)malloc(sizeof(t_path_part))))
		return (NULL);
	new->path_part = str;
	new->star_index = NULL;
	new->quoted = quoted;
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc053
movq $0x0, -0x8(%rbp)
jmp 0xc09a
movl $0x18, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc071
movq $0x0, -0x8(%rbp)
jmp 0xc09a
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x10(%rax)
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/charMstr[P]minishell/sources/split_path2.c
// Function: delete_path_part_link
void	delete_path_part_link(void *content)
{
	t_path_part *elem;

	elem = (t_path_part *)content;
	free(elem->path_part);
	ft_lstclear(&(elem->star_index), free);
	ft_free((void **)&elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2230
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq 0xaee9(%rip), %rsi      # 0x16fc8
callq 0x10090
leaq -0x10(%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/sources/split_path3.c
// Function: path_part_unquoting
int	path_part_unquoting(t_path_part *new, char *str)
{
	int i;
	int esc_next;

	i = -1;
	esc_next = 0;
	while (str[++i])
	{
		if (!esc_next && str[i] == '\\')
		{
			esc_next = 1;
			path_part_unquoting_escape_char(str, &i, new->quoted);
			continue;
		}
		if (str[i] == '*' && !esc_next && !new->quoted)
		{
			if (!add_index_valid_kleen_star_to_lst(new, i))
				return (0);
		}
		else if (!esc_next && (str[i] == '\'' || str[i] == '"'))
			path_part_unquoting_assist(str[i], &new->quoted, str, &i);
		esc_next = 0;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xc203
cmpl $0x0, -0x20(%rbp)
jne 0xc16d
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xc16d
movl $0x1, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
leaq -0x1c(%rbp), %rsi
movsbl 0x10(%rax), %edx
callq 0xc220
jmp 0xc11e
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0xc1aa
cmpl $0x0, -0x20(%rbp)
jne 0xc1aa
movq -0x10(%rbp), %rax
cmpb $0x0, 0x10(%rax)
jne 0xc1aa
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xc2b0
cmpl $0x0, %eax
jne 0xc1a8
movl $0x0, -0x4(%rbp)
jmp 0xc20a
jmp 0xc1f7
cmpl $0x0, -0x20(%rbp)
jne 0xc1f5
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0xc1d2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0xc1f5
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
movsbl %al, %edi
callq 0xc330
jmp 0xc1f7
movl $0x0, -0x20(%rbp)
jmp 0xc11e
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/charMstr[P]minishell/sources/split_path3.c
// Function: path_part_unquoting_escape_char
void	path_part_unquoting_escape_char(char *str, int *i, char quoted)
{
	if (quoted)
	{
		if (str[*i + 1] && str[*i + 1] == '\\')
		{
			ft_strcdel(str, *i);
			(*i)--;
		}
		return ;
	}
	ft_strcdel(str, *i);
	(*i)--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpb $0x0, -0x11(%rbp)
je 0xc28a
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xc288
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xc288
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x10760
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xc2a5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x10760
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path3.c
// Function: add_index_valid_kleen_star_to_lst
int	add_index_valid_kleen_star_to_lst(t_path_part *new, int index)
{
	int	*i;
	t_list *new_star_index;

	if (!(i = malloc(sizeof(int))))
		return (0);
	*i = index;
	if (!(new_star_index = ft_lstnew((void*)i)))
	{
		free(i);
		return (0);
	}
	ft_lstadd_back(&(new->star_index), new_star_index);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x4, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xc2dc
movl $0x0, -0x4(%rbp)
jmp 0xc322
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x10180
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xc30a
movq -0x20(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0xc322
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0xfff0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/split_path3.c
// Function: path_part_unquoting_assist
void path_part_unquoting_assist(char c, char *quoted, char *str, int *index)
{
	if (!*quoted)
	{
		*quoted = c;
		ft_strcdel(str, *index);
		(*index)--;
		//eat the char.
		return ;
	}
	else if (c == quoted[0])
	{
		//eat the char.
		ft_strcdel(str, *index);
		(*index)--;
		quoted[0] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xc379
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x10760
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xc3ac
movsbl -0x1(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xc3aa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x10760
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0xc3ac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/pathname_matching_root.c
// Function: pathname_matching_root
int	pathname_matching_root(t_path_exp *tool, t_list *path_parts)
{
	char *first_path_part;

	first_path_part = ((t_path_part *)(path_parts->content))->path_part;
	if (!ft_strlen(first_path_part))
		return (pathname_matching(tool, path_parts->next, "", "/"));
	else if (!ft_strcmp(first_path_part, "."))
		return (pathname_matching(tool, path_parts->next, ".", "./"));
	else if (!ft_strcmp(first_path_part, ".."))
		return (pathname_matching(tool, path_parts->next, "..", "../"));
	else
		return (pathname_matching_relative(tool, path_parts));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfb10
cmpq $0x0, %rax
jne 0xc414
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4dbf(%rip), %rdx      # 0x111bf
leaq 0x4f80(%rip), %rcx      # 0x11387
callq 0xc4a0
movl %eax, -0x4(%rbp)
jmp 0xc496
movq -0x20(%rbp), %rdi
leaq 0x4d1a(%rip), %rsi      # 0x11139
callq 0x10580
cmpl $0x0, %eax
jne 0xc44d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4cfd(%rip), %rdx      # 0x11139
leaq 0x4f43(%rip), %rcx      # 0x11386
callq 0xc4a0
movl %eax, -0x4(%rbp)
jmp 0xc496
movq -0x20(%rbp), %rdi
leaq 0x4f2a(%rip), %rsi      # 0x11382
callq 0x10580
cmpl $0x0, %eax
jne 0xc486
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4f0d(%rip), %rdx      # 0x11382
leaq 0x4f09(%rip), %rcx      # 0x11385
callq 0xc4a0
movl %eax, -0x4(%rbp)
jmp 0xc496
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc580
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop