LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/historic_search.c
// Function: history_swap_line_in_term_struct
int		history_swap_line_in_term_struct(t_control *control, int up)
{
	t_dlist	*new_link;
	char	*old_str;

	if (up == 1)
		new_link = control->term->current_history_link->next;
	else
		new_link = control->term->current_history_link->previous;
	if (!new_link)
		return (0);
	old_str = control->term->line;
	if (!(control->term->line = ft_strdup((char *)(new_link->content))))
	{
		control->quit = 1;
		return (0);
	}
	ft_free((void **)&old_str);
	control->term->current_history_link = new_link;
	control->term->line_len = ft_strlen((char*)(new_link->content));
	control->term->inline_position = control->term->line_len - 1;
	return (1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %ecx, %ecx
cmpl $0x1, %esi
setne %cl
movq 0x18(%rdi), %rax
movq 0x58(%rax), %rdx
movq 0x8(%rdx,%rcx,8), %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x5c58
movq %rdi, %rbx
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
callq 0xa3e4
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
je 0x5c55
leaq 0x8(%rsp), %rdi
callq 0xa9c0
movq 0x18(%rbx), %rax
movq %r14, 0x58(%rax)
movq (%r14), %rdi
callq 0xa4f8
movq 0x18(%rbx), %rcx
movl %eax, 0x8(%rcx)
decl %eax
movl %eax, 0xc(%rcx)
movl $0x1, %ebp
jmp 0x5c58
orb $0x1, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/control_structure.c
// Function: control_init_struct
int		control_init_struct(t_control *control)
{
	extern char **environ;

	ft_bzero(control, sizeof(*control));
	control->parent_pid = getpid();
	if (!(control->history = history_init_struct()) ||
		!(control->term = terminfo_init_database()) ||
		!(control->env = env_build_linked_list(environ)))
		return (0);
	if (!control_load_start_prompts(&control->env, \
				"\033[93m⚡\033[5;92m mli_&_charmstr \033[0;93m⚡\033[m ", \
				"🍝 > "))
		return (0);
	if (!env_shlvl_update(&control->env, control))
		return (0);
	if (!(control->cwd = getcwd(NULL, 0)))
		return (0);
	if ((control->truefd[STDIN_FILENO] = dup(STDIN_FILENO)) == -1 ||
		(control->truefd[STDOUT_FILENO] = dup(STDOUT_FILENO)) == -1 ||
		(control->truefd[STDERR_FILENO] = dup(STDERR_FILENO)) == -1)
		return (0);
	if (tcgetattr(STDIN_FILENO, &control->termios_default) == -1)
		return (0);
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x80, %esi
callq 0x9b68
callq 0x2070
movl %eax, 0x8(%rbx)
callq 0x59b7
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x5d51
callq 0x4240
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x5d51
movq 0xc33c(%rip), %rax      # 0x11fe8
movq (%rax), %rdi
callq 0x3288
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x5d51
leaq 0x20(%rbx), %r15
leaq 0x56ac(%rip), %rsi      # 0xb378
leaq 0x56d3(%rip), %rdx      # 0xb3a6
movq %r15, %rdi
callq 0x5d5a
testl %eax, %eax
je 0x5d51
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3482
testl %eax, %eax
je 0x5d51
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
callq 0x2100
movq %rax, 0x78(%rbx)
testq %rax, %rax
je 0x5d51
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x20d0
movl %eax, 0x30(%rbx)
cmpl $-0x1, %eax
je 0x5d51
movl $0x1, %edi
callq 0x20d0
movl %eax, 0x34(%rbx)
cmpl $-0x1, %eax
je 0x5d51
movl $0x2, %edi
callq 0x20d0
movl %eax, 0x38(%rbx)
cmpl $-0x1, %eax
je 0x5d51
addq $0x3c, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x21d0
xorl %r14d, %r14d
cmpl $-0x1, %eax
setne %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/control_structure.c
// Function: control_load_start_prompts
int	control_load_start_prompts(t_list **env, char *ps1, char *ps2)
{
	unset_in_env_list(env, "PS1");
	unset_in_env_list(env, "PS2");
	 if (!export_builtin_new_env("PS1", ps1, env))
			return (0);
	 if (!export_builtin_new_env("PS2", ps2, env))
			return (0);
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5518(%rip), %r12      # 0xb28a
movq %r12, %rsi
callq 0x35d0
leaq 0x5505(%rip), %rsi      # 0xb286
movq %r14, %rdi
callq 0x35d0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x381c
testl %eax, %eax
je 0x5db8
leaq 0x54e4(%rip), %rdi      # 0xb286
movq %rbx, %rsi
movq %r14, %rdx
callq 0x381c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x5dba
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/control_structure.c
// Function: control_free_struct
void	control_free_struct(t_control *control)
{
	terminfo_free_struct(control->term);
	ft_dlstclear(&(control->history->head), history_del_content);
	ft_free((void **)&control->history);
	ft_free((void **)&control->cwd);
	ft_lstclear(&control->env, env_del_struct);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x434e
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %rdi
addq $0x8, %rdi
leaq -0x40b(%rip), %rsi      # 0x59de
callq 0xabc8
movq %r14, %rdi
callq 0xa9c0
leaq 0x78(%rbx), %rdi
callq 0xa9c0
addq $0x20, %rbx
leaq -0x2a7e(%rip), %rsi     # 0x338c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa748
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: ast_add
void		ast_add(t_btree **ast, t_btree *add)
{
	if (add == NULL)
		return ;
	if (*ast == NULL)
		*ast = add;
	else if ((*ast)->left == NULL)
		(*ast)->left = add;
	else if ((*ast)->item == NULL)
	{
		(*ast)->item = add->item;
		ft_free((void **)&add);
	}
	else if ((*ast)->right == NULL)
		(*ast)->right = add;
	else
	{
		add->left = *ast;
		*ast = add;
	}
}

// Assembly:
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x5e6c
movq (%rdi), %rax
testq %rax, %rax
je 0x5e4c
cmpq $0x0, (%rax)
je 0x5e51
cmpq $0x0, 0x10(%rax)
je 0x5e56
cmpq $0x0, 0x8(%rax)
je 0x5e68
movq %rax, (%rsi)
movq %rsi, (%rdi)
jmp 0x5e6c
movq %rsi, (%rax)
jmp 0x5e6c
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movq %rsp, %rdi
callq 0xa9c0
jmp 0x5e6c
movq %rsi, 0x8(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_be_subshell
int			parser_be_subshell(t_btree **new)
{
	t_btree *tmp;
	t_token *token;

	tmp = NULL;
	if (!(token = ft_memalloc(sizeof(t_token))))
		return (-1);
	token->id = SUBSHELL;
	if ((*new)->item != NULL)
	{
		if (!(tmp = btree_new(token)))
		{
			ft_free((void **)&token);
			return (-1);
		}
		tmp->left = *new;
		*new = tmp;
	}
	else
		(*new)->item = token;
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0xa944
movq %rax, (%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x5ed2
movl $0xe, 0x8(%rax)
movq (%r14), %rcx
cmpq $0x0, 0x10(%rcx)
je 0x5ebf
movq %rax, %rdi
callq 0xade0
testq %rax, %rax
je 0x5eca
movq (%r14), %rcx
movq %rcx, (%rax)
movq %rax, (%r14)
jmp 0x5ec3
movq %rax, 0x10(%rcx)
movl $0x1, %ebx
jmp 0x5ed2
movq %rsp, %rdi
callq 0xa9c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_next_child
int			parser_next_child(t_dlist **dlst, t_list **tklst, t_btree **new)
{
//	printf("ENTER WITH : [%d]\t'%s'\n",
//		token_id((*tklst)->content), ((t_token *)(*tklst)->content)->str);
	if (parser_is_cmd_start(tklst_id(*tklst)))
		return (parser_cmd(tklst, new));
	if (parser_do_subtree(token_id((*tklst)->content)))
	{
		*tklst = (*tklst)->next;
		if (!*tklst)
			return (0);
		if (!((*dlst)->next = ft_dlstnew(NULL)))
			return (-1);
		(*dlst)->next->previous = *dlst;
		if (!(*new = parser_create_ast((*dlst)->next, tklst)))
			return (-1);
		if (parser_be_subshell(new) == -1)
			return (-1);
		ft_free((void **)&((*dlst)->next));
//	printf("\nNEW CONTAINS\n");
//		btree_debug(*new, parser_disp);
	}
	else
	{
		if (!(*new = btree_new((*tklst)->content)))
			return (-1);
	}
	if (*tklst)
		*tklst = (*tklst)->next;
//	if ((*new)->item)
//		printf("New is : [%d]\t'%s'\n", token_id((*new)->item), ((t_token *)(*new)->item)->str);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x63db
movl %eax, %edi
callq 0x62af
testl %eax, %eax
je 0x5f14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6358
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x63cc
movq (%rbx), %rcx
cmpl $0x6, %eax
jne 0x5f81
movq 0x8(%rcx), %rax
movq %rax, (%rbx)
testq %rax, %rax
je 0x5fa7
xorl %edi, %edi
callq 0xab80
movq (%r15), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x5fb0
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq %rax, 0x10(%rdi)
movq %rbx, %rsi
callq 0x5fbd
movq %rax, (%r14)
testq %rax, %rax
je 0x5fb0
movq %r14, %rdi
callq 0x5e77
cmpl $-0x1, %eax
je 0x5fb0
movq (%r15), %rdi
addq $0x8, %rdi
callq 0xa9c0
jmp 0x5f91
movq (%rcx), %rdi
callq 0xade0
movq %rax, (%r14)
testq %rax, %rax
je 0x5fab
movq (%rbx), %rax
movl $0x1, %ebp
testq %rax, %rax
je 0x5fb0
movq 0x8(%rax), %rax
movq %rax, (%rbx)
jmp 0x5fb0
xorl %ebp, %ebp
jmp 0x5fb0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_create_ast
t_btree		*parser_create_ast(t_dlist *dlst, t_list **tklst)
{
	t_btree		*new;
	int			state;

	if (!(dlst->content = btree_new(NULL)))
		return (NULL);
	while (*tklst && token_id((*tklst)->content) != RBRACE)
	{
//		printf("%d\n", token_id(tklst->content));
		if ((state = parser_next_child(&dlst, tklst, &new)) == 1)
			ast_add((t_btree **)&dlst->content, new);
		else if (state == -1)
			return (NULL);
		else if (parser_handle_semi(&dlst, tklst) == -1)
			return (NULL);
	}
	return (dlst->content);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rdi, 0x8(%rsp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0xade0
movq %rax, (%r14)
testq %rax, %rax
je 0x604b
movq (%r15), %rcx
testq %rcx, %rcx
je 0x6048
leaq 0x8(%rsp), %r12
movq %rsp, %r13
xorl %ebx, %ebx
movq (%rcx), %rdi
callq 0x63cc
cmpl $0x7, %eax
je 0x6043
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5edc
cmpl $0x1, %eax
je 0x602f
cmpl $-0x1, %eax
je 0x604b
movq %r12, %rdi
movq %r15, %rsi
callq 0x605c
cmpl $-0x1, %eax
jne 0x603b
jmp 0x604b
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x5e23
movq (%r15), %rcx
testq %rcx, %rcx
jne 0x5ff8
movq (%r14), %rbx
jmp 0x604b
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_handle_semi
int			parser_handle_semi(t_dlist **dlst, t_list **tklst)
{
	t_btree		*new;

	if (!(*tklst && token_id((*tklst)->content) == SEMI &&
		(tklst_id((*tklst)->next) != RBRACE) && (*tklst = (*tklst)->next)))
		return (0);
	if (!((*dlst)->next = ft_dlstnew(NULL)))
		return (-1);
	(*dlst)->next->previous = *dlst;
	if (!(new = parser_create_ast((*dlst)->next, tklst)))
		return (-1);
	ft_free((void **)&((*dlst)->next));
	ast_add((t_btree **)&(*dlst)->content, new);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x60f0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rax), %rdi
callq 0x63cc
cmpl $0x1, %eax
jne 0x60f0
movq (%r14), %rax
movq 0x8(%rax), %rdi
callq 0x63db
cmpl $0x7, %eax
je 0x60f0
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x60f0
xorl %edi, %edi
callq 0xab80
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x60f0
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq %rax, 0x10(%rdi)
movq %r14, %rsi
callq 0x5fbd
testq %rax, %rax
je 0x60f0
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0xa9c0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x5e23
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_btree_reverse_pipe
void		parser_btree_reverse_pipe(t_btree **ast)
{
	int		id;
	t_btree	*lchild;

	lchild = (*ast)->left;
	while (btree_id(lchild) == PIPE)
		lchild = lchild->left;
	if ((id = btree_id(lchild)) == -1)
		return ;
	if (id == LIST || id == SUBSHELL)
		return ;
	(*ast)->left = lchild->right;
	lchild->right = *ast;
	*ast = lchild;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %r14
movq %r14, %rdi
callq 0x63f1
cmpl $0x2, %eax
je 0x6116
movq %r14, %rdi
callq 0x63f1
incl %eax
cmpl $0x10, %eax
ja 0x613f
movl $0x18001, %ecx          # imm = 0x18001
btl %eax, %ecx
jb 0x6153
movq 0x8(%r14), %rax
movq (%rbx), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_pipe_priority
void		parser_pipe_priority(t_btree **ast)
{
	if (!ast || !*ast)
		return ;
	parser_pipe_priority(&(*ast)->left);
	parser_pipe_priority(&(*ast)->right);
	if (btree_id(*ast) == PIPE)
		parser_btree_reverse_pipe(ast);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6193
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x6193
callq 0x615b
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x615b
movq (%rbx), %rdi
callq 0x63f1
cmpl $0x2, %eax
jne 0x6193
movq %rbx, %rdi
popq %rbx
jmp 0x610c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_root.c
// Function: parser_root
t_btree		*parser_root(t_list *tklst, t_control *control)
{
	t_dlist		*dlst;
	t_btree		*ast;
	t_list		*tkcpy;

	ast = NULL;
	if (!(tkcpy = tklst))
		return (NULL);
//	debug_tokens_list(tklst);
	if ((dlst = ft_memalloc(sizeof(*dlst))) &&
		(ast = parser_create_ast(dlst, &tkcpy)))
	{
//		btree_debug(ast, parser_disp);
		ft_lstremove_if(&tklst, NULL, tkcmp_braces, del_token);
		ft_lstclear(&tklst, NULL);
		ft_dlstclear(&dlst, NULL);
		parser_pipe_priority(&ast);
//		btree_debug(ast, parser_disp);
	}
	else
	{
		printf("AST FAILED\n");
		control->quit = 1;
		ft_lstclear(&tklst, del_token);
		ft_dlstclearback_addr(&dlst, (void (*)(void **))&del_ast);
	}
//	parser_LIST_to_CMD_root(ast, control);
	return (ast);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x624c
movq %rsi, %rbx
movl $0x18, %edi
callq 0xa944
movq %rax, (%rsp)
testq %rax, %rax
je 0x621d
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x5fbd
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x621d
leaq -0xea(%rip), %rdx       # 0x60f7
leaq -0x3a5a(%rip), %rcx     # 0x278e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xad18
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa748
movq %rsp, %rdi
xorl %esi, %esi
callq 0xabc8
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x615b
movq (%rbx), %rax
jmp 0x624e
leaq 0x518a(%rip), %rdi      # 0xb3ae
callq 0x2050
orb $0x1, (%rbx)
leaq -0x3aa5(%rip), %rsi     # 0x278e
leaq 0x8(%rsp), %rdi
callq 0xa748
leaq -0x428(%rip), %rsi      # 0x5e1c
movq %rsp, %rdi
callq 0xacc0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_cmd.c
// Function: parser_cmd_state
int		parser_cmd_state(t_btree *new, t_list **tklst)
{
	if (tklst_id(*tklst) == AND)
	{
		if (!(new->right = btree_new((*tklst)->content)))
			return (0);
		(*tklst) = (*tklst)->next;
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
callq 0x63db
movl $0x1, %ebx
cmpl $0x4, %eax
jne 0x6293
movq (%r14), %rax
movq (%rax), %rdi
callq 0xade0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x6291
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
jmp 0x6293
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_cmd.c
// Function: parser_cmdlst
int		parser_cmdlst(t_list **args, t_list **tklst)
{
	t_list *tmp;

	if (!(tmp = ft_lstnew((*tklst)->content)))
		return (0);
	ft_lstadd_back(args, tmp);
	while (((*tklst) = (*tklst)->next) && parser_is_cmd_param(tklst_id(*tklst))
			&& (tmp = ft_lstnew((*tklst)->content)))
		ft_lstadd_back(args, tmp);
	if (!tmp)
	{
		ft_lstclear(args, NULL);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rdi
callq 0xa7bc
testq %rax, %rax
je 0x633d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa70c
movq (%r14), %rax
movq 0x8(%rax), %rdi
movq %rdi, (%r14)
movl $0x1, %r15d
testq %rdi, %rdi
je 0x634f
callq 0x63db
leal -0x8(%rax), %ecx
cmpl $0x6, %ecx
jae 0x6332
movq (%r14), %rax
movq (%rax), %rdi
callq 0xa7bc
testq %rax, %rax
je 0x6342
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa70c
movq (%r14), %rax
movq 0x8(%rax), %rdi
movq %rdi, (%r14)
jmp 0x62f9
cmpl $0x4, %eax
je 0x630b
testl %eax, %eax
je 0x630b
jmp 0x634f
xorl %r15d, %r15d
jmp 0x634f
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa748
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_cmd.c
// Function: parser_cmd
int		parser_cmd(t_list **tklst, t_btree **new)
{
	if (!(*new = btree_new(NULL)))
		return (-1);
	if (!((*new)->item = lexer_init_token()))
	{
		ft_free((void **)new);
		return (-1);
	}
	((t_token *)((*new)->item))->id = LIST;
	if (!parser_cmdlst((t_list **)&((t_token *)((*new)->item))->str, tklst))
	{
		ft_free((void **)&(*new)->item);
		ft_free((void **)new);
		return (-1);
	}
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0xade0
movq %rax, %rcx
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x63c4
callq 0x27ea
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x63b7
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movl $0xf, 0x8(%rdi)
movq %r14, %rsi
callq 0x62c3
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x63c4
movq (%rbx), %rdi
addq $0x10, %rdi
callq 0xa9c0
movq %rbx, %rdi
callq 0xa9c0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/parser_utils.c
// Function: parser_disp
void		parser_disp(t_token *node, t_btree *parent)
{
	int		i;
	int		fd;
	char	*str;

	fd = 1;
	if (token_id(node) == LIST)
		str = (char	[5]){'l', 's', 't', 47 \
			+ ft_lstsize((t_list *)node->str), '\0'};
	else if (token_id(node) == SUBSHELL)
		str = "shell";
	else
		str = (node ? node->str : "null");
	i = -1;
	ft_putstr_fd("[", fd);
	while (++i < SIZE_LEAF - 2 && str[i])
		ft_putchar_fd(str[i], fd);
	while (i++ < SIZE_LEAF - 2)
		ft_putchar_fd(' ', fd);
	ft_putstr_fd("]", fd);
	(void)parent;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x643f
movl 0x8(%rdi), %eax
cmpl $0xe, %eax
je 0x6448
cmpl $0xf, %eax
jne 0x6451
leaq 0x3(%rsp), %rbx
movw $0x736c, (%rbx)         # imm = 0x736C
movb $0x74, 0x2(%rbx)
movq (%rdi), %rdi
callq 0xa7dc
addb $0x2f, %al
movb %al, 0x3(%rbx)
movb $0x0, 0x4(%rbx)
jmp 0x6454
leaq 0x4fb4(%rip), %rbx      # 0xb3fa
jmp 0x6454
leaq 0x4fa5(%rip), %rbx      # 0xb3f4
jmp 0x6454
movq (%rdi), %rbx
leaq 0x4fa4(%rip), %rdi      # 0xb3ff
movl $0x1, %esi
callq 0x9e70
xorl %r14d, %r14d
movb (%rbx,%r14), %al
testb %al, %al
je 0x6488
movsbl %al, %edi
movl $0x1, %esi
callq 0x9db0
incq %r14
cmpq $0x4, %r14
jne 0x6468
jmp 0x64a9
cmpq $0x3, %r14
ja 0x64a9
movl $0x4, %ebx
subq %r14, %rbx
movl $0x20, %edi
movl $0x1, %esi
callq 0x9db0
decl %ebx
jne 0x6496
leaq 0x508b(%rip), %rdi      # 0xb53b
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9e70
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_root.c
// Function: exe_root
void	exe_root(t_btree *ast, t_control *control)
{
	int i;
	int current_id;

//	printf("\033[36mENTERING THE EXE_ROOT FUNC\033[0m\n");
	if (!ast || control->quit)
		return ;
	i = 0;
	current_id = btree_id(ast);
	while (g_exec[i].fct != NULL && g_exec[i].id != current_id)
		i++;
	if (g_exec[i].fct)
		g_exec[i].fct(ast, control);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6523
movq %rsi, %rbx
testb $0x1, (%rsi)
jne 0x6523
movq %rdi, %r14
callq 0x63f1
movq 0xbc4c(%rip), %rcx      # 0x12130
cmpq $0x0, 0x8(%rcx)
je 0x6504
xorl %edx, %edx
movq %rcx, %rsi
cmpl %eax, (%rsi)
je 0x6506
incq %rdx
cmpq $0x0, 0x18(%rsi)
leaq 0x10(%rsi), %rsi
jne 0x64f0
jmp 0x6506
xorl %edx, %edx
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rax
testq %rax, %rax
je 0x6523
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_ope.c
// Function: exe_and
int		exe_and(t_btree *ast, t_control *control)
{
	exe_root(ast->left, control);
	if (control->exit_status == 0)
		exe_root(ast->right, control);
	return (control->exit_status);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x64c4
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x6574
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x64c4
movl 0x4(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_ope.c
// Function: exe_or
int		exe_or(t_btree *ast, t_control *control)
{
	exe_root(ast->left, control);
	if (control->exit_status != 0)
		exe_root(ast->right, control);
	return (control->exit_status);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x64c4
cmpl $0x0, 0x4(%rbx)
je 0x65a5
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x64c4
movl 0x4(%rbx), %eax
jmp 0x65a7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_ope.c
// Function: exe_subshell
int		exe_subshell(t_btree *ast, t_control *control)
{
	pid_t	pid;
	int		status;

	ft_fork(&pid);
	if (pid == 0)
	{
		ft_signalhandler_disable();
		exe_root(ast->left, control);
		exit(control->exit_status);
	}
	else
	{
		waitpid(pid, &status, 0);
		control->exit_status = WIFEXITED(status) ? WEXITSTATUS(status) : g_sig;
	}
	return (control->exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdi
callq 0x24b3
movl (%r15), %edi
testl %edi, %edi
je 0x6641
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x21c0
movl (%r14), %eax
testb $0x7f, %al
je 0x6631
leaq 0xbb0f(%rip), %rax      # 0x1213c
movl (%rax), %eax
jmp 0x6634
movzbl %ah, %eax
movl %eax, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x8e45
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x64c4
movl 0x4(%rbx), %edi
callq 0x2210
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_pipe.c
// Function: exe_pipe_child
void	exe_pipe_child(t_btree *ast, t_control *control)
{
	t_pipe pipe;

	ft_fork_pipe(&pipe);
	if (pipe.pid == 0)
	{
		close(pipe.fildes[0]);
		if (dup2(pipe.fildes[1], STDOUT_FILENO) == -1)
			ft_exit("dup2", NULL, strerror(errno), EXIT_FAILURE);
		exe_root(ast->left, control);
		close(pipe.fildes[1]);
	}
	else
	{
		close(pipe.fildes[1]);
		if (dup2(pipe.fildes[0], STDIN_FILENO) == -1)
			ft_exit("dup2", NULL, strerror(errno), EXIT_FAILURE);
		exe_root(ast->right, control);
		close(pipe.fildes[0]);
		waitpid(pipe.pid, &pipe.status, 0);
	}
	exit(control->exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x24fb
cmpl $0x0, (%r15)
jne 0x66d0
movl 0x4(%rsp), %edi
callq 0x2110
movl 0x8(%rsp), %edi
movl $0x1, %esi
callq 0x20b0
cmpl $-0x1, %eax
jne 0x66ba
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x4d56(%rip), %rdi      # 0xb401
xorl %esi, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x24a4
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x64c4
movl 0x8(%rsp), %edi
callq 0x2110
jmp 0x6733
movl 0x8(%rsp), %edi
callq 0x2110
movl 0x4(%rsp), %edi
xorl %esi, %esi
callq 0x20b0
cmpl $-0x1, %eax
jne 0x670b
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x4d05(%rip), %rdi      # 0xb401
xorl %esi, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x24a4
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x64c4
leaq 0xc(%rsp), %r14
movl -0x8(%r14), %edi
callq 0x2110
movl -0xc(%r14), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21c0
movl 0x4(%rbx), %edi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_pipe.c
// Function: exe_pipe
int		exe_pipe(t_btree *ast, t_control *control)
{
	pid_t	pid;
	int		status;

	ft_fork(&pid);
	if (pid == 0)
		exe_pipe_child(ast, control);
	else
	{
		waitpid(pid, &status, 0);
		control->exit_status = WIFEXITED(status) ? WEXITSTATUS(status) : g_sig;
	}
	return (control->exit_status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rdi
callq 0x24b3
movl (%r15), %edi
testl %edi, %edi
je 0x678f
leaq 0x8(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x21c0
movl (%r14), %eax
testb $0x7f, %al
je 0x677f
leaq 0xb9c1(%rip), %rax      # 0x1213c
movl (%rax), %eax
jmp 0x6782
movzbl %ah, %eax
movl %eax, 0x4(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x665c
nop
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_simple_cmd_root.c
// Function: exe_simple_cmd_root
int	exe_simple_cmd_root(t_token *token, t_control *control)
{
	int builtin;
	int res;

	res = exe_prepare_simple_cmd(token, control);
	if (res == 1)
		return (1);
	//check the exit status is working the same way as the last Return here.
	else if (res == 2)
		return (0);
	//need to make sure the control->quit is raised inside this function..
	if (!exe_perform_arrow((t_simple_cmd *)token->str, control))
	{
		exe_cancel_arrows(control);
		return (0);
	}
	//HERE function that does all the redirections.
	//need to operate the redirections list just before executing the simple
	//command. note: the stdin and stdout, should be saved then restored.
	if (!((t_simple_cmd *)token->str)->argv[0])
		;
	else if ((builtin = exe_is_builtin(((t_simple_cmd *)token->str)->argv[0])))
	{
//		printf("\033[35mthis is a builtin\033[0m\n");
		//check the returned value here;
		exe_call_builtin(((t_simple_cmd *)token->str), builtin, control);
	}
	else
		exe_binary((t_simple_cmd *)token->str, control);
	//try execute the non builtin commands here.
	//always make sure we set the exit status.
	//always restore the stdion and stdout, to original value.
	exe_cancel_arrows(control);
	return (!!control->exit_status);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6818
cmpl $0x1, %eax
je 0x6810
cmpl $0x2, %eax
je 0x67f3
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x699c
testl %eax, %eax
je 0x67eb
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x67ff
callq 0x6860
movq (%r14), %rdi
testl %eax, %eax
je 0x67f7
movl %eax, %esi
movq %rbx, %rdx
callq 0x6926
jmp 0x67ff
movq %rbx, %rdi
callq 0x6b70
xorl %eax, %eax
jmp 0x6810
movq %rbx, %rsi
callq 0x6ed4
movq %rbx, %rdi
callq 0x6b70
xorl %eax, %eax
cmpl $0x0, 0x4(%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_simple_cmd_root.c
// Function: exe_prepare_simple_cmd
int	exe_prepare_simple_cmd(t_token *token, t_control *control)
{
	int res;

//	printf("\033[34mBEFORE WORD EXPAND:\033[0m\n");
//	debug_tokens_list((t_list *)token->str);
	res = word_expand_root(((t_list **)&token->str), control);
	if (res)
	{
		control->exit_status = 1;
		if (res == 2)
			control->quit = 1;
		return (res);
	}
//	printf("\033[34mAFTER WORD EXPAND:\033[0m\n");
//	debug_tokens_list((t_list *)token->str);
	if (!list_to_cmd_root(token))
	{
		control->exit_status = 1;
		control->quit = 1;
		return (2);
	}
//	debug_simple_cmd(((t_simple_cmd *)token->str));
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6fb4
testl %eax, %eax
je 0x6839
movl $0x1, 0x4(%rbx)
cmpl $0x2, %eax
je 0x6850
jmp 0x6858
movq %r14, %rdi
callq 0x8a74
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x6858
movl $0x1, 0x4(%rbx)
orb $0x1, (%rbx)
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_simple_cmd_root.c
// Function: exe_is_builtin
int	exe_is_builtin(char *argv0) //OK
{
	if (!argv0)
		return (0);
	if (!ft_strcmp(argv0, "echo"))
		return (B_ECHO);
	else if (!ft_strcmp(argv0, "cd"))
		return (B_CD);
	else if (!ft_strcmp(argv0, "pwd"))
		return (B_PWD);
	else if (!ft_strcmp(argv0, "export"))
		return (B_EXPORT);
	else if (!ft_strcmp(argv0, "unset"))
		return (B_UNSET);
	else if (!ft_strcmp(argv0, "env"))
		return (B_ENV);
	else if (!ft_strcmp(argv0, "exit"))
		return (B_EXIT);
	else
		return (0);
}

// Assembly:
testq %rdi, %rdi
je 0x68f9
pushq %rbx
movq %rdi, %rbx
leaq 0x4bb0(%rip), %rsi      # 0xb424
callq 0xa994
testl %eax, %eax
je 0x68fc
leaq 0x4905(%rip), %rsi      # 0xb189
movq %rbx, %rdi
callq 0xa994
testl %eax, %eax
je 0x6903
leaq 0x4b92(%rip), %rsi      # 0xb429
movq %rbx, %rdi
callq 0xa994
testl %eax, %eax
je 0x690a
leaq 0x488c(%rip), %rsi      # 0xb136
movq %rbx, %rdi
callq 0xa994
testl %eax, %eax
je 0x6911
leaq 0x4887(%rip), %rsi      # 0xb144
movq %rbx, %rdi
callq 0xa994
testl %eax, %eax
je 0x6918
leaq 0x4b5d(%rip), %rsi      # 0xb42d
movq %rbx, %rdi
callq 0xa994
testl %eax, %eax
je 0x691f
leaq 0x48f9(%rip), %rsi      # 0xb1dc
movq %rbx, %rdi
callq 0xa994
xorl %ecx, %ecx
testl %eax, %eax
movl $0x7, %eax
cmovnel %ecx, %eax
jmp 0x6924
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0x6924
movl $0x2, %eax
jmp 0x6924
movl $0x3, %eax
jmp 0x6924
movl $0x4, %eax
jmp 0x6924
movl $0x5, %eax
jmp 0x6924
movl $0x6, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_simple_cmd_root.c
// Function: exe_call_builtin
int	exe_call_builtin(t_simple_cmd *cmd, int id, t_control *control)
{
	if (id == B_ECHO)
		return (echo_builtin(cmd->argv, control));
	else if (id == B_ENV)
		return (env_builtin(control->env, control));
	else if (id == B_EXPORT)
		return (export_builtin(&control->env, cmd->argv, control));
	else if (id == B_UNSET)
		return (unset_builtin(&control->env, cmd->argv, control));
	else if (id == B_CD)
		return (cd_builtin(control->env, cmd->argv, control));
	else if (id == B_EXIT)
		return (exit_builtin(cmd->argv, control));
	else if (id == B_PWD)
		return (pwd_builtin(control));
	return (0);
}

// Assembly:
decl %esi
cmpl $0x6, %esi
ja 0x6971
leaq 0x4ad4(%rip), %rax      # 0xb408
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x3638
leaq 0x20(%rdx), %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
jmp 0x3528
movq %rdx, %rdi
jmp 0x3d04
leaq 0x20(%rdx), %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
jmp 0x36e4
xorl %eax, %eax
retq
movq 0x20(%rdx), %rax
movq 0x8(%rdi), %rsi
movq %rax, %rdi
jmp 0x39a0
movq 0x20(%rdx), %rdi
movq %rdx, %rsi
jmp 0x3228
movq 0x8(%rdi), %rdi
movq %rdx, %rsi
jmp 0x3d24
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_perform_arrow.c
// Function: exe_perform_arrow
int	exe_perform_arrow(t_simple_cmd *cmd, t_control *control)
{
	t_list const	*arrows = cmd->arrows;
	t_arrow			*arrow;

	while (arrows && (arrow = arrows->content))
	{
		if ((arrow->id != LESS && !exe_perform_redirections(arrow, control)) ||
			(arrow->id == LESS && !exe_perform_indirections(arrow, control)))
		{
			control->exit_status = 1;
			return (0);
		}
		arrows = arrows->next;
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movl $0x1, %ebx
testq %r12, %r12
je 0x69ff
movq %rsi, %r14
movq (%r12), %r15
testq %r15, %r15
je 0x69ff
cmpl $0xa, 0x10(%r15)
je 0x69da
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a0d
testl %eax, %eax
je 0x69f5
cmpl $0xa, 0x10(%r15)
jne 0x69e9
movq %r15, %rdi
movq %r14, %rsi
callq 0x6acb
testl %eax, %eax
je 0x69f5
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x69b4
jmp 0x69ff
movl $0x1, 0x4(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_perform_arrow.c
// Function: exe_perform_redirections
int	exe_perform_redirections(t_arrow *arrow, t_control *control)
{
	int			fd;
	int			src;
	int			options;
	const int	signals = S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR;

	src = ft_isdigit(arrow->src[0]) ? ft_atoi(arrow->src) : 1;
	options = (arrow->id == GREAT ? O_TRUNC : O_APPEND);
	if ((fd = open(arrow->dest, O_WRONLY | O_CREAT | options, signals)) < 0)
	{
		ft_perror("open", arrow->dest, strerror(errno));
		return (0);
	}
	if (dup2(fd, src) == -1)
	{
		ft_perror("dup2", NULL, NULL);
		control->quit = 1;
		close(fd);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
movsbl (%rax), %edi
callq 0x9bb0
testl %eax, %eax
je 0x6a36
movq (%r15), %rdi
callq 0x9afc
movl %eax, %ebp
jmp 0x6a3b
movl $0x1, %ebp
xorl %esi, %esi
cmpl $0xc, 0x10(%r15)
setne %sil
movq 0x8(%r15), %rdi
shll $0x9, %esi
addl $0x241, %esi            # imm = 0x241
xorl %r14d, %r14d
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2200
testl %eax, %eax
js 0x6a9d
movl %eax, %r12d
movl %eax, %edi
movl %ebp, %esi
callq 0x20b0
movl $0x1, %r14d
cmpl $-0x1, %eax
jne 0x6abf
leaq 0x497d(%rip), %rdi      # 0xb401
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2511
orb $0x1, (%rbx)
movl %r12d, %edi
callq 0x2110
jmp 0x6abf
movq 0x8(%r15), %rbx
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x497d(%rip), %rdi      # 0xb431
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2511
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_perform_arrow.c
// Function: exe_perform_indirections
int	exe_perform_indirections(t_arrow *arrow, t_control *control)
{
	int		fd;
	int		src;

	src = ft_isdigit(arrow->src[0]) ? ft_atoi(arrow->src) : 0;
	if ((fd = open(arrow->dest, O_RDONLY)) < 0)
	{
		ft_perror("open", arrow->dest, strerror(errno));
		return (0);
	}
	if (dup2(fd, src) == -1)
	{
		ft_perror("dup2", NULL, NULL);
		control->quit = 1;
		close(fd);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
movsbl (%rax), %edi
callq 0x9bb0
testl %eax, %eax
je 0x6af5
movq (%r15), %rdi
callq 0x9afc
movl %eax, %r12d
jmp 0x6af8
xorl %r12d, %r12d
movq 0x8(%r15), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x2200
testl %eax, %eax
js 0x6b42
movl %eax, %ebp
movl %eax, %edi
movl %r12d, %esi
callq 0x20b0
movl $0x1, %r14d
cmpl $-0x1, %eax
jne 0x6b64
leaq 0x48d7(%rip), %rdi      # 0xb401
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2511
orb $0x1, (%rbx)
movl %ebp, %edi
callq 0x2110
jmp 0x6b64
movq 0x8(%r15), %rbx
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x48d8(%rip), %rdi      # 0xb431
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2511
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_perform_arrow.c
// Function: exe_cancel_arrows
int	exe_cancel_arrows(t_control *control)
{
	if ((dup2(control->truefd[STDIN_FILENO], STDIN_FILENO)) == -1 ||
		(dup2(control->truefd[STDOUT_FILENO], STDOUT_FILENO)) == -1 ||
		(dup2(control->truefd[STDERR_FILENO], STDERR_FILENO)) == -1)
	{
		control->quit = 1;
		control->exit_status = 1;
		ft_perror("dup2", NULL, strerror(errno));
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %edi
xorl %esi, %esi
callq 0x20b0
cmpl $-0x1, %eax
je 0x6bae
movl 0x34(%rbx), %edi
movl $0x1, %ebp
movl $0x1, %esi
callq 0x20b0
cmpl $-0x1, %eax
je 0x6bae
movl 0x38(%rbx), %edi
movl $0x2, %esi
callq 0x20b0
cmpl $-0x1, %eax
jne 0x6bd7
orb $0x1, (%rbx)
movl $0x1, 0x4(%rbx)
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x4836(%rip), %rdi      # 0xb401
xorl %esi, %esi
movq %rax, %rdx
callq 0x2511
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_binary.c
// Function: build_env2d
char	**build_env2d(t_list *env, t_control *control)
{
	int			i;
	const int	lstsize = ft_lstsize(env);
	char		**res;
	t_env		*tmp;

	if (!(res = (char **)ft_memalloc(sizeof(char *) * (lstsize + 1))))
	{
		control->quit = 1;
		return (NULL);
	}
	i = -1;
	while (env)
	{
		tmp = env->content;
		if (!(res[++i] = ft_strjoin_free(tmp->label, (char	[2]){'=', '\0'}, 0))
		|| !(res[i] = ft_strjoin_free(res[i], tmp->value, 1)))
		{
			control->quit = 1;
			ft_array_free(res, lstsize);
			return (NULL);
		}
		env = env->next;
	}
	return (res);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0xa7dc
movl %eax, %ebp
cltq
leaq 0x8(,%rax,8), %rdi
callq 0xa944
testq %rax, %rax
je 0x6c6d
movq %rax, %rbx
testq %r15, %r15
je 0x6c87
movq %r14, 0x10(%rsp)
leaq 0xe(%rsp), %r12
movq %rbx, %r13
movq (%r15), %r14
movq (%r14), %rdi
movw $0x3d, 0xe(%rsp)
movq %r12, %rsi
xorl %edx, %edx
callq 0xa4b4
movq %rax, (%r13)
testq %rax, %rax
je 0x6c73
movq 0x8(%r14), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0xa4b4
movq %rax, (%r13)
testq %rax, %rax
je 0x6c73
movq 0x8(%r15), %r15
addq $0x8, %r13
testq %r15, %r15
jne 0x6c24
jmp 0x6c87
orb $0x1, (%r14)
jmp 0x6c85
movq 0x10(%rsp), %rax
orb $0x1, (%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xa84c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_binary.c
// Function: exe_binary_fork
int		exe_binary_fork(char *prog, char **argv, t_control *control)
{
	char	**env;
	pid_t	pid;
	int		status;

	ft_fork(&pid);
	if (pid == 0)
	{
		if (!(env = build_env2d(control->env, control)) && control->quit)
			ft_exit("malloc", NULL, strerror(errno), 1);
		if (execve(prog, argv, env) == -1)
			ft_perror(prog, NULL, strerror(errno));
		ft_array_free(env, ft_array_len(env));
		ft_errno_exit();
	}
	else
	{
		waitpid(pid, &status, 0);
		control->exit_status = WIFEXITED(status) ? WEXITSTATUS(status) : g_sig;
//		printf("Exit status of the child was %d\n", control->exit_status);
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movq %r14, %rdi
callq 0x24b3
movl (%r14), %edi
testl %edi, %edi
je 0x6ce0
movq %rsp, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21c0
movl (%rbx), %eax
testb $0x7f, %al
je 0x6d63
movl 0xb461(%rip), %eax      # 0x1213c
jmp 0x6d66
movq 0x20(%r12), %rdi
movq %r12, %rsi
callq 0x6be0
movq %rax, %r14
testq %rax, %rax
jne 0x6d1e
testb $0x1, (%r12)
je 0x6d1e
callq 0x2040
movl (%rax), %edi
callq 0x2220
leaq 0x4727(%rip), %rdi      # 0xb436
xorl %esi, %esi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x24a4
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2150
cmpl $-0x1, %eax
jne 0x6d4a
callq 0x2040
movl (%rax), %edi
callq 0x2220
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2511
movq %r14, %rdi
callq 0xa8e0
movq %r14, %rdi
movl %eax, %esi
callq 0xa84c
callq 0x652b
jmp 0x6d6b
movzbl %ah, %eax
movl %eax, 0x4(%r12)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_binary.c
// Function: exe_given_path
int		exe_given_path(char **argv0, t_control *control, char **path_to_binary)
{
	char *new;

	if (!(new = ft_strrchr(*argv0, '/')))
		return (0);
	if (!(new = ft_strdup(new + 1)))
	{
		control->quit = 1;
		return (-1);
	}
	*path_to_binary = *argv0;
	*argv0 = new;
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x2f, %esi
callq 0xa574
testq %rax, %rax
je 0x6dbc
incq %rax
movq %rax, %rdi
callq 0xa3e4
testq %rax, %rax
je 0x6dc0
movq (%r14), %rcx
movq %rcx, (%rbx)
movq %rax, (%r14)
movl $0x1, %eax
jmp 0x6dc9
xorl %eax, %eax
jmp 0x6dc9
orb $0x1, (%r15)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_binary.c
// Function: exe_search_path
int		exe_search_path(char *argv0, t_control *control, char **path_to_binary)
{
	int			i;
	int			ret;
	char		*path;
	char		**split;
	struct stat	buf;

	if (!(split = ft_split(env_get("PATH", 4, control->env), ':')))
		return (errno ? -1 : 0);
	i = -1;
	ret = 0;
	while (ret == 0 && split[++i])
	{
		if (!(path = ft_strjoin(split[i], argv0)))
			ret = -1;
		else if (!stat(path, &buf) && S_ISREG(buf.st_mode))
		{
			*path_to_binary = path;
			ret = 1;
		}
		else
			ft_free((void **)&path);
	}
	errno = 0;
	ft_array_free(split, ft_array_len(split));
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rdi, %r12
movq 0x20(%rsi), %rdx
leaq 0x464c(%rip), %rdi      # 0xb43d
movl $0x4, %esi
callq 0x33b4
movq %rax, %rdi
movl $0x3a, %esi
callq 0x9e98
testq %rax, %rax
je 0x6e7d
movq %rax, %r15
movq (%rax), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6ea3
movq %r14, 0x10(%rsp)
movq %r15, %r14
addq $0x8, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r12, %rsi
callq 0xa428
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x6e8a
movq %rax, %rdi
movq %r13, %rsi
callq 0x2170
testl %eax, %eax
jne 0x6e67
movl 0x30(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpl $0x8000, %eax           # imm = 0x8000
je 0x6e91
movq %rbp, %rdi
callq 0xa9c0
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x6e34
jmp 0x6ea3
callq 0x2040
xorl %ebx, %ebx
cmpl (%rax), %ebx
sbbl %ebx, %ebx
jmp 0x6ec0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x6ea3
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movl $0x1, %ebx
callq 0x2040
movl $0x0, (%rax)
movq %r15, %rdi
callq 0xa8e0
movq %r15, %rdi
movl %eax, %esi
callq 0xa84c
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/exe_binary.c
// Function: exe_binary
int		exe_binary(t_simple_cmd *cmd, t_control *control)
{
	int		ret;
	char	*argv0;
	char	*path_to_binary;

	g_sig = 1;
//	printf("\e[95mThis is a binary !\e[0m\n");
	path_to_binary = NULL;
	if ((ret = exe_given_path(&cmd->argv[0], control, &path_to_binary)) == -1)
		return (ret);
	else if (ret == 0)
	{
		if (!(argv0 = ft_strjoin((char	[]){'/', '\0'}, cmd->argv[0])) ||
			((ret = exe_search_path(argv0, control, &path_to_binary)) == -1))
			control->quit = 1;
		else if (ret == 0 && (control->exit_status = 127))
			ft_perror(cmd->argv[0], NULL, "Command not found");
		free(argv0);
		if (ret != 1)
			return (ret);
	}
	ret = exe_binary_fork(path_to_binary, cmd->argv, control);
	free(path_to_binary);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x1, 0xb24d(%rip)      # 0x1213c
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
movq 0x8(%rdi), %rdi
callq 0x6d7c
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x6fa2
testl %r12d, %r12d
jne 0x6f57
leaq 0xe(%rsp), %rdi
movw $0x2f, (%rdi)
movq 0x8(%r15), %rax
movq (%rax), %rsi
callq 0xa428
movq %rax, %r14
testq %rax, %rax
je 0x6f73
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6dcf
testl %eax, %eax
je 0x6f7b
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x6f76
movq %r14, %rdi
callq 0x2240
movq 0x10(%rsp), %r14
movq 0x8(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6c99
movl $0x1, %r12d
jmp 0x6f9a
xorl %r12d, %r12d
orb $0x1, (%rbx)
jmp 0x6f9a
movl $0x7f, 0x4(%rbx)
movq 0x8(%r15), %rax
movq (%rax), %rdi
leaq 0x44b2(%rip), %rdx      # 0xb442
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x2511
movq %r14, %rdi
callq 0x2240
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/word_expand_root_v2.c
// Function: word_expand_root
int		word_expand_root(t_list **tokens, t_control *control)
{
	int id;
	int res;

	while (*tokens)
	{
		id = tklst_id(*tokens);
		if (id == GREAT || id == DGREAT || id == LESS)
		{
			tokens = &(*tokens)->next;
			((t_token*)(*tokens)->content)->is_filename = 1;
		}
		res = word_expand_and_replace(&tokens, control);
		if (res == 1 || res == 2)
			return (res);
		if (res == 3)
			;
		else
			tokens = &(*tokens)->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
movq %rdi, 0x8(%rsp)
movq (%rdi), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7040
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movl $0x3400, %ebp           # imm = 0x3400
callq 0x63db
cmpl $0xd, %eax
ja 0x7009
btl %eax, %ebp
jae 0x7009
movq (%r12), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq (%rax), %rax
movl $0x1, 0xc(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x704f
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x703e
movq 0x8(%rsp), %r12
cmpl $0x3, %eax
je 0x7033
movq (%r12), %r12
addq $0x8, %r12
movq %r12, 0x8(%rsp)
movq (%r12), %rdi
testq %rdi, %rdi
jne 0x6fdf
jmp 0x7040
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/word_expand_root_v2.c
// Function: word_expand_and_replace
int		word_expand_and_replace(t_list ***tokens, t_control *control)
{
	t_list	*expanded_word;
	int		res;
	t_list 	*del_me;

	if (!(expanded_word = dup_token((**tokens)->content)))
		return (2);
	if ((res = word_expand_stage1(&expanded_word, control)))
	{
		if (res == 1)
			ft_ambiguous_redirect(((t_token *)(**tokens)->content)->str, 2);
		if (res < 3)
			ft_lstclear(&expanded_word, del_token);
		if (res == 3)
		{
			del_me = **tokens;
			**tokens = (**tokens)->next;
			del_token(del_me->content);
			ft_free((void **)&del_me);
		}
		return (res);
	}
	word_expand_replace(tokens, expanded_word);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x710d
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x70a4
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x7165
testl %eax, %eax
je 0x70ab
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x70bc
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x25f5
jmp 0x70c1
movl $0x2, %ebx
jmp 0x70d2
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x71e3
xorl %ebx, %ebx
jmp 0x70d2
cmpl $0x2, %ebx
jg 0x70dc
leaq -0x493a(%rip), %rsi     # 0x278e
leaq 0x8(%rsp), %rdi
callq 0xa748
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
cmpl $0x3, %ebx
jne 0x70d2
movq (%r14), %rax
movq (%rax), %rcx
leaq 0x10(%rsp), %rbx
movq %rcx, (%rbx)
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq (%rcx), %rdi
callq 0x278e
movq %rbx, %rdi
callq 0xa9c0
movl $0x3, %ebx
jmp 0x70d2
// File: /workspace/github_c_makefile_star2_O3/charMstr[P]minishell/sources/word_expand_root_v2.c
// Function: dup_token
t_list	*dup_token(const t_token *token)
{
	t_list	*new_list;
	t_token	*new_token;

	if (!(new_token = malloc(sizeof(t_token))))
		return (NULL);
	ft_memcpy(new_token, token, sizeof(t_token));
	if (!(new_token->str = ft_strdup(token->str)))
	{
		del_token(new_token);
		return (NULL);
	}
	if (!(new_list = ft_lstnew(new_token)))
	{
		del_token(new_token);
		return (NULL);
	}
	return (new_list);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x2190
testq %rax, %rax
je 0x715b
movq %rax, %rbx
movl $0x20, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9d3c
movq (%r14), %rdi
callq 0xa3e4
movq %rax, (%rbx)
testq %rax, %rax
je 0x7153
movq %rbx, %rdi
callq 0xa7bc
testq %rax, %rax
jne 0x715d
movq %rbx, %rdi
callq 0x278e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq