LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9507
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x950c
jmp 0x95a7
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9370
movl %eax, -0x18(%rbp)
movq 0xdc02(%rip), %rcx      # 0x17128
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
je 0x955a
movq 0xdbe4(%rip), %rax      # 0x17128
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9563
jmp 0x956e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x951f
movq 0xdbb3(%rip), %rax      # 0x17128
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x95a7
movq 0xdb9a(%rip), %rax      # 0x17128
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x961b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x966b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2590
cmpl $0x0, -0x14(%rbp)
jne 0x9740
callq 0xd6e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2200
movl -0x14(%rbp), %edi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x21b0
movl -0x18(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x9769
movl -0x18(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9775
leaq 0xd9c4(%rip), %rax      # 0x17134
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x25f0
cmpl $0x0, -0x20(%rbp)
jne 0x9807
movl -0x1c(%rbp), %edi
callq 0x20f0
movl -0x18(%rbp), %edi
movl $0x1, %esi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x97ed
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, %rdx
leaq 0x7b60(%rip), %rdi      # 0x1133f
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0x2560
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movl -0x18(%rbp), %edi
callq 0x20f0
jmp 0x986d
movl -0x18(%rbp), %edi
callq 0x20f0
movl -0x1c(%rbp), %edi
xorl %esi, %esi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x9842
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, %rdx
leaq 0x7b0b(%rip), %rdi      # 0x1133f
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0x2560
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x94e0
movl -0x1c(%rbp), %edi
callq 0x20f0
movl -0x20(%rbp), %edi
leaq -0x20(%rbp), %rsi
addq $0xc, %rsi
xorl %edx, %edx
callq 0x21b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x2200
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x2590
cmpl $0x0, -0x14(%rbp)
jne 0x98ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9790
jmp 0x98ed
movl -0x14(%rbp), %edi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x21b0
movl -0x18(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x98d7
movl -0x18(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x98e3
leaq 0xd856(%rip), %rax      # 0x17134
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x99f0
movl %eax, -0x20(%rbp)
cmpl $0x1, -0x20(%rbp)
jne 0x9932
movl $0x1, -0x4(%rbp)
jmp 0x99e2
cmpl $0x2, -0x20(%rbp)
jne 0x9944
movl $0x0, -0x4(%rbp)
jmp 0x99e2
jmp 0x9946
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9ca0
cmpl $0x0, %eax
jne 0x996d
movq -0x18(%rbp), %rdi
callq 0x9f60
movl $0x0, -0x4(%rbp)
jmp 0x99e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
jne 0x9980
jmp 0x99c2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x9a80
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x99b0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x9b90
jmp 0x99c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xa430
jmp 0x99c2
movq -0x18(%rbp), %rdi
callq 0x9f60
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa560
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9a3d
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
cmpl $0x2, -0x1c(%rbp)
jne 0x9a35
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a74
movq -0x10(%rbp), %rdi
callq 0xd0f0
cmpl $0x0, %eax
jne 0x9a6d
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x9a74
movl $0x0, -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/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9a9f
movl $0x0, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x789a(%rip), %rsi      # 0x11344
callq 0x10580
cmpl $0x0, %eax
jne 0x9ac0
movl $0x1, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x76a2(%rip), %rsi      # 0x1116d
callq 0x10580
cmpl $0x0, %eax
jne 0x9ae1
movl $0x2, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x785d(%rip), %rsi      # 0x11349
callq 0x10580
cmpl $0x0, %eax
jne 0x9aff
movl $0x3, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x7610(%rip), %rsi      # 0x1111a
callq 0x10580
cmpl $0x0, %eax
jne 0x9b1d
movl $0x4, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x7600(%rip), %rsi      # 0x11128
callq 0x10580
cmpl $0x0, %eax
jne 0x9b3b
movl $0x5, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x7807(%rip), %rsi      # 0x1134d
callq 0x10580
cmpl $0x0, %eax
jne 0x9b59
movl $0x6, -0x4(%rbp)
jmp 0x9b7e
movq -0x10(%rbp), %rdi
leaq 0x765c(%rip), %rsi      # 0x111c0
callq 0x10580
cmpl $0x0, %eax
jne 0x9b77
movl $0x7, -0x4(%rbp)
jmp 0x9b7e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x9bc2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4140
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x6, -0x14(%rbp)
jne 0x9be1
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3b20
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x4, -0x14(%rbp)
jne 0x9c08
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x4250
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x5, -0x14(%rbp)
jne 0x9c2c
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3fb0
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x2, -0x14(%rbp)
jne 0x9c50
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x4740
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x7, -0x14(%rbp)
jne 0x9c6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4bb0
movl %eax, -0x4(%rbp)
jmp 0x9c93
cmpl $0x3, -0x14(%rbp)
jne 0x9c80
movq -0x20(%rbp), %rdi
callq 0x4b70
movl %eax, -0x4(%rbp)
jmp 0x9c93
jmp 0x9c82
jmp 0x9c84
jmp 0x9c86
jmp 0x9c88
jmp 0x9c8a
jmp 0x9c8c
movl $0x0, -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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x9cdc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9ce5
jmp 0x9d42
movq -0x28(%rbp), %rax
cmpl $0xa, 0x10(%rax)
je 0x9d01
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9d60
cmpl $0x0, %eax
je 0x9d1d
movq -0x28(%rbp), %rax
cmpl $0xa, 0x10(%rax)
jne 0x9d31
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e70
cmpl $0x0, %eax
jne 0x9d31
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x9d49
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9cbb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1a4, -0x28(%rbp)     # imm = 0x1A4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xe9f0
cmpl $0x0, %eax
je 0x9d9c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe7e0
movl %eax, -0x2c(%rbp)
jmp 0x9da6
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9da6
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x400, %eax            # imm = 0x400
movl $0x200, %ecx            # imm = 0x200
cmpl $0xc, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
orl $0x41, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x21f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x9e1c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x7543(%rip), %rdi      # 0x11351
callq 0x2620
movl $0x0, -0x4(%rbp)
jmp 0x9e65
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x9e5e
leaq 0x750c(%rip), %rdi      # 0x1133f
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2620
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %edi
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x9e65
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/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0xe9f0
cmpl $0x0, %eax
je 0x9ea5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xe7e0
movl %eax, -0x24(%rbp)
jmp 0x9eac
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x9eac
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x21f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x9eff
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x7460(%rip), %rdi      # 0x11351
callq 0x2620
movl $0x0, -0x4(%rbp)
jmp 0x9f48
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x9f41
leaq 0x7429(%rip), %rdi      # 0x1133f
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x2620
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl -0x1c(%rbp), %edi
callq 0x20f0
movl $0x0, -0x4(%rbp)
jmp 0x9f48
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
xorl %esi, %esi
callq 0x20a0
cmpl $-0x1, %eax
je 0x9fab
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edi
movl $0x1, %esi
callq 0x20a0
cmpl $-0x1, %eax
je 0x9fab
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x2, %esi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x9fec
movq -0x10(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, %rdx
leaq 0x7365(%rip), %rdi      # 0x1133f
xorl %eax, %eax
movl %eax, %esi
callq 0x2620
movl $0x0, -0x4(%rbp)
jmp 0x9ff3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x101e0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x104f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xa053
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0xa111
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0xa109
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movb $0x3d, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
leaq -0x32(%rbp), %rsi
xorl %edx, %edx
callq 0xfab0
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %edx, %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
je 0xa0d4
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0xfab0
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xa0f8
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x102f0
movq $0x0, -0x8(%rbp)
jmp 0xa111
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa05a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x2590
cmpl $0x0, -0x24(%rbp)
jne 0xa1f3
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xa000
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa196
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xa196
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq %rax, %rdx
leaq 0x71ce(%rip), %rdi      # 0x11356
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %ecx
callq 0x2560
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2130
cmpl $-0x1, %eax
jne 0xa1d0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq -0x30(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2620
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10410
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x102f0
callq 0x95b0
jmp 0xa22f
movl -0x24(%rbp), %edi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x21b0
movl -0x28(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xa21c
movl -0x28(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x3c(%rbp)
jmp 0xa225
movl 0xcf12(%rip), %eax      # 0x17134
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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
movl $0x2f, %esi
callq 0xfc50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xa278
movl $0x0, -0x4(%rbp)
jmp 0xa2c6
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0xf950
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xa2a6
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa2c6
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x7067(%rip), %rdi      # 0x1135d
movl $0x4, %esi
callq 0x3dc0
movq %rax, %rdi
movl $0x3a, %esi
callq 0xf070
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xa333
callq 0x2040
movl (%rax), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xa41f
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x28(%rbp)
movb %al, -0xc9(%rbp)
jne 0xa36d
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0xa379
jmp 0xa3ec
movq -0x38(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xf9b0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xa3a1
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3e7
movq -0x30(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x2150
cmpl $0x0, %eax
jne 0xa3dc
movl -0xb0(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0xa3dc
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x28(%rbp)
jmp 0xa3e5
leaq -0x30(%rbp), %rdi
callq 0x10600
jmp 0xa3e7
jmp 0xa341
callq 0x2040
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10410
movq -0xd8(%rbp), %rdi
movl %eax, %esi
callq 0x102f0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, 0xccea(%rip)      # 0x17134
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa240
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0xa47a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa54b
cmpl $0x0, -0x1c(%rbp)
jne 0xa522
movb $0x2f, -0x32(%rbp)
movb $0x0, -0x31(%rbp)
leaq -0x32(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0xf9b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xa4c3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xa2d0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0xa4d3
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
jmp 0xa509
cmpl $0x0, -0x1c(%rbp)
jne 0xa507
movq -0x18(%rbp), %rax
movl $0x7f, 0x4(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0xa4ec
jmp 0xa507
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x6e60(%rip), %rdx      # 0x11362
callq 0x2620
jmp 0xa509
movq -0x28(%rbp), %rdi
callq 0x2230
cmpl $0x1, -0x1c(%rbp)
je 0xa520
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa54b
jmp 0xa522
jmp 0xa524
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xa120
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2230
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa5ff
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9330
movl %eax, -0x1c(%rbp)
cmpl $0xc, -0x1c(%rbp)
je 0xa59f
cmpl $0xd, -0x1c(%rbp)
je 0xa59f
cmpl $0xa, -0x1c(%rbp)
jne 0xa5bf
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl $0x1, 0xc(%rax)
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xa610
movl %eax, -0x20(%rbp)
cmpl $0x1, -0x20(%rbp)
je 0xa5db
cmpl $0x2, -0x20(%rbp)
jne 0xa5e3
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa606
cmpl $0x3, -0x20(%rbp)
jne 0xa5eb
jmp 0xa5fa
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xa570
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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xa700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa648
movl $0x2, -0x4(%rbp)
jmp 0xa6f0
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xa7a0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0xa6dc
cmpl $0x1, -0x24(%rbp)
jne 0xa67d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x2720
cmpl $0x3, -0x24(%rbp)
jge 0xa693
leaq -0x20(%rbp), %rdi
leaq -0x7d4e(%rip), %rsi     # 0x2940
callq 0x10090
cmpl $0x3, -0x24(%rbp)
jne 0xa6d4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
leaq -0x30(%rbp), %rdi
callq 0x10600
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa6f0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa870
movl $0x0, -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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xa72a
movq $0x0, -0x8(%rbp)
jmp 0xa796
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0xedb0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xf950
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa768
movq -0x20(%rbp), %rdi
callq 0x2940
movq $0x0, -0x8(%rbp)
jmp 0xa796
movq -0x20(%rbp), %rdi
callq 0x10180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xa78e
movq -0x20(%rbp), %rdi
callq 0x2940
movq $0x0, -0x8(%rbp)
jmp 0xa796
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/word_expand_root_v2.c
// Function: word_expand_stage1
int		word_expand_stage1(t_list **tokens, t_control *control)
{
	int res;
	int is_filename;

	//printf("word_exp_stage1: BEFORE: token list is:\n");
	//debug_tokens_list(*tokens);
	if (!tild_expansion_root(control->env, \
				&((t_token*)(*tokens)->content)->str))
		return (2);
	is_filename = ((t_token *)((*tokens)->content))->is_filename;
	if ((res = parameter_expansion_root(*tokens, control, is_filename)))
		return (res);
	skim_empty_tokens(tokens);
	if (!*tokens)
		return (3);
	if (is_filename && ft_strlen(((t_token*)(*tokens)->content)->str) == 0)
		return (1);
	res = pathname_expansion_root(tokens, is_filename);
	//printf("word_exp_stage1: AFTER: token list is:\n");
	//debug_tokens_list(*tokens);
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0xb750
cmpl $0x0, %eax
jne 0xa7d8
movl $0x2, -0x4(%rbp)
jmp 0xa863
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0xa970
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xa80b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa863
movq -0x10(%rbp), %rdi
callq 0xa8f0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa827
movl $0x3, -0x4(%rbp)
jmp 0xa863
cmpl $0x0, -0x20(%rbp)
je 0xa84e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfb10
cmpq $0x0, %rax
jne 0xa84e
movl $0x1, -0x4(%rbp)
jmp 0xa863
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xb490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/word_expand_root_v2.c
// Function: word_expand_replace
void	word_expand_replace(t_list ***tokens, t_list *expanded)
{
	t_list *last;
	t_list *del_me;

	last = ft_lstlast(expanded);
	last->next = (**tokens)->next;
	del_me = **tokens;
	**tokens = expanded;
	*tokens = &last;
	del_token(del_me->content);
	free(del_me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10140
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
movq -0x20(%rbp), %rdi
callq 0x2230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/word_expand_assist.c
// Function: skim_empty_tokens
void	skim_empty_tokens(t_list **tokens)
{
	t_list	*del_me;

	while (*tokens)
	{
		if (!ft_strlen(((t_token *)((*tokens)->content))->str))
		{
			del_me = *tokens;
			*tokens = (*tokens)->next;
			del_token((t_token *)(del_me->content));
			free(del_me);
		}
		else
			tokens = &(*tokens)->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa963
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfb10
cmpq $0x0, %rax
jne 0xa952
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2940
movq -0x10(%rbp), %rdi
callq 0x2230
jmp 0xa961
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xa8fc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion_root.c
// Function: reset_t_expansion
void	reset_t_expansion(t_expansion *exp, int is_filename, \
		t_control *control)
{
	exp->start = 0;
	exp->end = 0;
	exp->quoted = 0;
	exp->is_filename = is_filename;
	exp->ifs = env_get("IFS", 3, control->env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x695b(%rip), %rdi      # 0x11374
movl $0x3, %esi
callq 0x3dc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion_root.c
// Function: parameter_exp
int		parameter_exp(t_list *token, t_control *ctrl, t_expansion exp, int res)
{
	char *insert;
	char *str;

	while ((exp.start = param_exp_find_start(token, exp.start, &exp.quoted)) \
			!= -1)
	{
		str = ((t_token *)token->content)->str;
		if ((exp.end = param_exp_find_end(token, exp.start)) == exp.start)
		{
			exp.start++;
			continue;
		}
		if (!(insert = param_exp_get_env(ctrl, str + exp.start + 1, \
				exp.end - exp.start)))
			return (2);
		//printf("expanded variable = [%s]\n", insert);
		ft_memmove(str + exp.start, str + exp.end + 1, \
				ft_strlen(str + exp.end));
		if ((res = parameter_expansion2(&token, &insert, &exp)))
		{
			free(insert);
			return (res);
		}
		free(insert);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rdi
movl (%rdx), %esi
addq $0x8, %rdx
callq 0xab80
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
je 0xab65
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl (%rax), %esi
callq 0xacb0
movq -0x38(%rbp), %rcx
movl %eax, 0x4(%rcx)
cmpl (%rcx), %eax
jne 0xaab2
movq -0x38(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xaa5b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq (%rax), %rcx
addq %rcx, %rsi
addq $0x1, %rsi
movl 0x4(%rax), %edx
subl (%rax), %edx
callq 0xad50
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xaae8
movl $0x2, -0x4(%rbp)
jmp 0xab6c
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq (%rax), %rdx
addq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movslq 0x4(%rax), %rdx
addq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movslq 0x4(%rax), %rax
addq %rax, %rdi
callq 0xfb10
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0xee10
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xadf0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xab57
movq -0x28(%rbp), %rdi
callq 0x2230
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xab6c
movq -0x28(%rbp), %rdi
callq 0x2230
jmp 0xaa5b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion_root.c
// Function: param_exp_find_start
int		param_exp_find_start(t_list *token, int start, char *quot)
{
	int		esc_next;
	char	*str;

	str = ((t_token*)token->content)->str;
	*quot = 0;
	esc_next = 0;
	while (str[start])
	{
		if (!esc_next && !*quot && (str[start] == '\'' || str[start] == '\"'))
			*quot = str[start];
		else if (!esc_next && *quot && str[start] == *quot)
			*quot = 0;
		if (!esc_next && str[start] == '\\')
		{
			esc_next = 1;
			start++;
			continue;
		}
		if (!esc_next && *quot != '\'' && str[start] == '$')
			return (start);
		esc_next = 0;
		start++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xac9f
cmpl $0x0, -0x24(%rbp)
jne 0xac01
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xac01
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
je 0xabee
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
jne 0xac01
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0xac33
cmpl $0x0, -0x24(%rbp)
jne 0xac31
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xac31
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xac31
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0xac33
cmpl $0x0, -0x24(%rbp)
jne 0xac5f
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0xac5f
movl $0x1, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xabab
cmpl $0x0, -0x24(%rbp)
jne 0xac8a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0xac8a
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0xac8a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xaca6
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xabab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/parameter_expansion_root.c
// Function: param_exp_find_end
int		param_exp_find_end(t_list *token, int start)
{
	int		end;
	char	*str;

	str = ((t_token*)token->content)->str;
	end = start + 1;
	while (str[end])
	{
		if (str[start + 1] == '?')
			return (start + 1);
		if (!ft_isalnum(str[end]) && str[end] != '_')
			break ;
		end++;
	}
	return (end - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xad39
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3f, %eax
jne 0xad05
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xad42
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xe970
cmpl $0x0, %eax
jne 0xad2e
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
je 0xad2e
jmp 0xad39
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xacd6
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)