LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils.c
// Function: add_env
void	add_env(t_minishell_meta *ms, char *var)
{
	int		env_len;
	int		var_len;
	int		i;

	i = -1;
	var_len = ft_strlen(var);
	while (ms->env[++i] != 0)
	{
		env_len = 0;
		while (ms->env[i][env_len] != '=')
			env_len++;
		if (var_len != env_len)
			continue;
		if (ft_strncmp(var, ms->env[i], var_len) != 0)
			continue;
		env_len++;
		while (ms->env[i][env_len] != '\0')
		{
			ms->arg = ft_stradd(ms->arg, ms->env[i][env_len]);
			env_len++;
		}
		break ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x1bd0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x60a2
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
je 0x6011
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5fe9
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x601b
jmp 0x5fc3
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x18(%rbp), %rdx
callq 0x7440
cmpl $0x0, %eax
je 0x603f
jmp 0x5fc3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x60a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x1dc0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6048
jmp 0x60a2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils.c
// Function: command_not_found
void	command_not_found(t_minishell_meta *ms, int i)
{
	if (ms->piped_cmds->files1[i][0] != 0)
		unset_fd(ms);
	write(STDERR_FILENO, "minishell: ", 11);
	write(STDERR_FILENO, ms->piped_cmds->cmds[i],
	ft_strlen(ms->piped_cmds->cmds[i]));
	write(STDERR_FILENO, COMMAND_NOT_FOUND, 20);
	errno = 127;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
je 0x60e2
movq -0x8(%rbp), %rdi
callq 0x5190
movl $0x2, %edi
leaq 0x2042(%rip), %rsi      # 0x8130
movl $0xb, %edx
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1bd0
movq -0x18(%rbp), %rsi
movslq %eax, %rdx
movl $0x2, %edi
callq 0x1050
movl $0x2, %edi
leaq 0x1ff8(%rip), %rsi      # 0x813c
movl $0x14, %edx
callq 0x1050
callq 0x1040
movl $0x7f, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils2.c
// Function: process_cmd
void				process_cmd(t_minishell_meta *ms, char *line, int i)
{
	if (ms->piped_cmds->files1[i][0] != 0)
	{
		handle_fd(ms, i);
	}
	if (ms->process_bit >= 0 && process_builtin(ms, i, line) == 0)
	{
		search_and_execute_path(ms, i);
	}
	if ((ms->piped_cmds->files1[i][0] != 0) && (ms->multiline != -99))
	{
		unset_fd(ms);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
je 0x6219
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3500
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x6244
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5320
cmpl $0x0, %eax
jne 0x6244
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5550
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
je 0x6271
movq -0x8(%rbp), %rax
cmpl $-0x63, 0x44(%rax)
je 0x6271
movq -0x8(%rbp), %rdi
callq 0x5190
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils2.c
// Function: process_piped_cmd
void				process_piped_cmd(t_minishell_meta *ms, char *line,
int i, int *in)
{
	static	pid_t	pid;
	int				stat;

	if (!ms->piped_cmds->pipe[i + 1] || (ms->piped_cmds->pipe[i + 1] != '|'))
	{
		if ((pid = fork()) == 0)
		{
			if (*in != 0)
				dup2(*in, 0);
			process_cmd(ms, line, i);
			exit(errno);
		}
		waitpid(pid, &stat, 0);
		errno = stat / 255;
	}
	else
	{
		pipe(ms->mypipe);
		spawn_proc(ms, line, *in, i);
		close(ms->mypipe[1]);
		*in = ms->mypipe[0];
	}
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0x62d0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7c, %eax
je 0x633d
callq 0x1160
movl %eax, 0x4e05(%rip)      # 0xb0e0
cmpl $0x0, %eax
jne 0x6312
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x62f6
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x61e0
callq 0x1040
movl (%rax), %edi
callq 0x1140
movl 0x4dc8(%rip), %edi      # 0xb0e0
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x1120
movl -0x24(%rbp), %eax
movl $0xff, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
callq 0x1040
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x6374
movq -0x8(%rbp), %rdi
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl -0x14(%rbp), %ecx
callq 0x5200
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x10a0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils2.c
// Function: replace_tabs
char				*replace_tabs(char *line)
{
	int i;

	i = 0;
	while (line && line[i])
	{
		if (ft_isspace(line[i]))
			line[i] = ' ';
		i++;
	}
	return (line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0xd(%rbp)
je 0x63b4
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x63bd
jmp 0x63ea
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6bd0
cmpl $0x0, %eax
je 0x63df
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6393
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils2.c
// Function: check_line
int					check_line(char *line)
{
	int stat;

	stat = 0;
	if (line[0] == ';' && line[1] == ';')
	{
		stat++;
		syntax_error(";;");
		errno = 258;
	}
	else if (line[0] == ';')
	{
		stat++;
		syntax_error(";");
		errno = 258;
	}
	return (stat);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x644e
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3b, %eax
jne 0x644e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq 0x1cc8(%rip), %rdi      # 0x8104
callq 0x6590
callq 0x1040
movl $0x102, (%rax)          # imm = 0x102
jmp 0x647c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x647a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq 0x1c9b(%rip), %rdi      # 0x8105
callq 0x6590
callq 0x1040
movl $0x102, (%rax)          # imm = 0x102
jmp 0x647c
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils3.c
// Function: no_file_or_directory
void			no_file_or_directory(char *cmd, char *name)
{
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	if (cmd)
	{
		ft_putstr_fd(cmd, STDERR_FILENO);
		ft_putstr_fd(": ", STDERR_FILENO);
	}
	if (name)
	{
		ft_putstr_fd(name, STDERR_FILENO);
		ft_putstr_fd(": ", STDERR_FILENO);
	}
	ft_putstr_fd("No such file or directory\n", STDERR_FILENO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1b82(%rip), %rdi      # 0x8029
movl $0x2, %esi
callq 0x6f10
leaq 0x1b7f(%rip), %rdi      # 0x8037
movl $0x2, %esi
callq 0x6f10
cmpq $0x0, -0x8(%rbp)
je 0x64e8
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6f10
leaq 0x1b59(%rip), %rdi      # 0x8037
movl $0x2, %esi
callq 0x6f10
cmpq $0x0, -0x10(%rbp)
je 0x650e
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6f10
leaq 0x1b33(%rip), %rdi      # 0x8037
movl $0x2, %esi
callq 0x6f10
leaq 0x1b54(%rip), %rdi      # 0x8069
movl $0x2, %esi
callq 0x6f10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils3.c
// Function: too_many_args
void			too_many_args(char *cmd)
{
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(": ", STDERR_FILENO);
	ft_putstr_fd(cmd, STDERR_FILENO);
	ft_putstr_fd(": too many arguments\n", STDERR_FILENO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1ae6(%rip), %rdi      # 0x8029
movl $0x2, %esi
callq 0x6f10
leaq 0x1ae3(%rip), %rdi      # 0x8037
movl $0x2, %esi
callq 0x6f10
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6f10
leaq 0x1bde(%rip), %rdi      # 0x8151
movl $0x2, %esi
callq 0x6f10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils3.c
// Function: syntax_error
int				syntax_error(char *token)
{
	ft_putstr_fd(SHELL_NAME, STDERR_FILENO);
	ft_putstr_fd(SYNTAX_ERROR, STDERR_FILENO);
	ft_putstr_fd(token, STDERR_FILENO);
	ft_putstr_fd("'\n", STDERR_FILENO);
	errno = 258;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1a86(%rip), %rdi      # 0x8029
movl $0x2, %esi
callq 0x6f10
leaq 0x1bb3(%rip), %rdi      # 0x8167
movl $0x2, %esi
callq 0x6f10
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6f10
leaq 0x1bbb(%rip), %rdi      # 0x818e
movl $0x2, %esi
callq 0x6f10
callq 0x1040
movl $0x102, (%rax)          # imm = 0x102
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils3.c
// Function: print_invalid
void			print_invalid(char *var, char *cmd)
{
	errno = 1;
	ft_putstr_fd("minishell: ", STDOUT_FILENO);
	ft_putstr_fd(cmd, STDOUT_FILENO);
	ft_putstr_fd(": `", STDOUT_FILENO);
	ft_putstr_fd(var, STDOUT_FILENO);
	ft_putstr_fd("\': not a valid identifier\n", STDOUT_FILENO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1040
movl $0x1, (%rax)
leaq 0x1b0e(%rip), %rdi      # 0x8130
movl $0x1, %esi
callq 0x6f10
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6f10
leaq 0x1b50(%rip), %rdi      # 0x8191
movl $0x1, %esi
callq 0x6f10
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6f10
leaq 0x1b35(%rip), %rdi      # 0x8195
movl $0x1, %esi
callq 0x6f10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils3.c
// Function: get_frequency
int				get_frequency(char *str, char c)
{
	int i;
	int count;

	i = 0;
	count = 0;
	while (str && str[i] != '\0')
	{
		if (str[i] == c)
			count++;
		i++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x15(%rbp)
je 0x66ad
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x66b6
jmp 0x66de
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x66d3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x668c
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils4.c
// Function: set_export
void			set_export(t_minishell_meta *ms)
{
	int i;
	int env_len;

	i = 0;
	env_len = 0;
	while (ms->env[env_len] != 0)
		env_len++;
	ms->export = (char**)malloc(sizeof(char*) * (env_len + 1));
	if (ms->export == NULL)
		exit(1);
	ms->export[i] = 0;
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6728
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x670a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x675a
movl $0x1, %edi
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils4.c
// Function: set_env
void			set_env(t_minishell_meta *ms, char **env)
{
	int i;
	int env_len;

	i = 0;
	env_len = 0;
	while (env[env_len] != 0)
		env_len++;
	ms->env = (char**)malloc(sizeof(char*) * (env_len + 100));
	if (ms->env == NULL)
		exit(0);
	while (i < env_len)
	{
		ms->env[i] = ft_strdup(env[i]);
		i++;
	}
	ms->env[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x67b8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x679e
movl -0x18(%rbp), %eax
addl $0x64, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x67e7
xorl %edi, %edi
callq 0x1140
jmp 0x67e9
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x6820
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1c00
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67e9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils4.c
// Function: set_path
void			set_path(t_minishell_meta *ms)
{
	ms->arg = 0;
	substitute_value("$PATH", 0, ms);
	ms->path = ft_split(ms->arg, ':');
	ft_free(&ms->arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdx
leaq 0x194d(%rip), %rdi      # 0x81b0
xorl %esi, %esi
callq 0x5df0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x3a, %esi
callq 0x6f70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b80
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils4.c
// Function: set_env_export
void			set_env_export(t_minishell_meta *ms, char **env)
{
	set_env(ms, env);
	set_export(ms);
	ms->path = 0;
	write(STDOUT_FILENO, SHELL_BANNER, 15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6780
movq -0x8(%rbp), %rdi
callq 0x66f0
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movl $0x1, %edi
leaq 0x173b(%rip), %rsi      # 0x8019
movl $0xf, %edx
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/src/ms_utils4.c
// Function: add_ms_arg
int				add_ms_arg(t_minishell_meta *ms, int index, int j, int flag)
{
	if (flag == 0)
	{
		if (ms->arg)
		{
			ms->piped_cmds->redir[index][j] = ft_strdup(ms->arg);
			ft_free(&ms->arg);
		}
		else
			ft_free(&ms->arg);
		return (j);
	}
	else if (flag == 1)
	{
		if (ms->arg)
		{
			ms->piped_cmds->files1[index][j++] = ft_strdup(ms->arg);
			ft_free(&ms->arg);
		}
		return (j);
	}
	return (j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6966
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6951
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c00
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b80
jmp 0x695e
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b80
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69ca
cmpl $0x1, -0x1c(%rbp)
jne 0x69c2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x69ba
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c00
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x1b80
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x69ca
jmp 0x69c4
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *s1)
{
	int					neg;
	unsigned long int	val;
	int					i;

	neg = 1;
	val = 0;
	i = 0;
	while ((s1[i] >= 9 && s1[i] <= 13) || s1[i] == 32)
		i++;
	if (s1[i] == '-')
		neg = -1;
	if (s1[i] == '-' || s1[i] == '+')
		i++;
	while ((ft_isdigit(s1[i])) && s1[i] != '\0')
		val = val * 10 + ((const char)s1[i++] - '0');
	return (val * neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jl 0x6a29
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x1d(%rbp)
jle 0x6a3e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x6a47
jmp 0x6a52
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6a02
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x6a6a
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x6a8c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x6a95
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6a97
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x6ba0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
je 0x6ac9
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x6ad2
jmp 0x6afc
imulq $0xa, -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6a97
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_itoa.c
// Function: ft_itoa
char			*ft_itoa(int nbr)
{
	int		length;
	int		sig;
	int		i;
	char	*result;

	i = 0;
	sig = nbr < 0 ? 1 : 0;
	length = ft_nbr_len(nbr);
	if ((nbr == 0) || (nbr == -2147483648))
		return (preturn(nbr));
	if (!(result = (char *)malloc(sizeof(char) * (length + 1 + sig))))
		return (NULL);
	if (sig)
	{
		result[0] = '-';
		nbr = -nbr;
	}
	while (++i <= length)
	{
		result[length + sig - i] = (nbr % 10) + '0';
		nbr = nbr / 10;
	}
	result[length + sig] = '\0';
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
callq 0x6d20
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x6c62
movslq -0xc(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x6c73
movl -0xc(%rbp), %edi
callq 0x6d80
movq %rax, -0x8(%rbp)
jmp 0x6d0b
movl -0x10(%rbp), %eax
addl $0x1, %eax
addl -0x14(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x6c9c
movq $0x0, -0x8(%rbp)
jmp 0x6d0b
cmpl $0x0, -0x14(%rbp)
je 0x6cb1
movq -0x20(%rbp), %rax
movb $0x2d, (%rax)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x6cb3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl -0x10(%rbp), %eax
jg 0x6cf2
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x6cb3
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_itoa.c
// Function: ft_nbr_len
static int		ft_nbr_len(int nbr)
{
	int		i;

	if (nbr == 0)
		return (1);
	i = 0;
	if (nbr < 0)
		nbr = -nbr;
	while (nbr > 0)
	{
		nbr = (nbr / 10);
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x6d36
movl $0x1, -0x4(%rbp)
jmp 0x6d72
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x6d4b
xorl %eax, %eax
subl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x6d4d
cmpl $0x0, -0x8(%rbp)
jle 0x6d6c
movl -0x8(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d4d
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_itoa.c
// Function: preturn
static char		*preturn(int nbr)
{
	int		size;

	if (nbr == 0)
		size = 2;
	else
		size = 12;
	if (size == 12)
		return (ft_strdup("-2147483648"));
	return (ft_strdup("0"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6d9a
movl $0x2, -0x10(%rbp)
jmp 0x6da1
movl $0xc, -0x10(%rbp)
cmpl $0xc, -0x10(%rbp)
jne 0x6db9
leaq 0x1408(%rip), %rdi      # 0x81b6
callq 0x1c00
movq %rax, -0x8(%rbp)
jmp 0x6dc9
leaq 0x1402(%rip), %rdi      # 0x81c2
callq 0x1c00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *b, int c, size_t len)
{
	size_t			i;
	unsigned char	*s;
	unsigned char	ch;

	s = (unsigned char *)b;
	ch = (unsigned char)c;
	i = 0;
	while (i < len)
	{
		s[i] = ch;
		i++;
	}
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x29(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6e2b
movb -0x29(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e05
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char *s, int fd)
{
	int		i;
	char	c;

	i = 0;
	c = '\n';
	if (s == NULL)
		return ;
	while (s[i] != '\0')
		write(fd, &s[i++], 1);
	write(fd, &c, 1);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0xa, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6e93
jmp 0x6eda
jmp 0x6e95
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6ec9
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
cltq
addq %rax, %rsi
movl $0x1, %edx
callq 0x1050
jmp 0x6e95
movl -0xc(%rbp), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_putstr_fd.c
// Function: ft_putstr_fd
void	ft_putstr_fd(char *s, int fd)
{
	int i;

	i = 0;
	if (s == NULL)
		return ;
	while (s[i] != '\0')
		write(fd, &s[i++], 1);
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6f2f
jmp 0x6f67
jmp 0x6f31
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6f65
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
cltq
addq %rax, %rsi
movl $0x1, %edx
callq 0x1050
jmp 0x6f31
jmp 0x6f67
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_split.c
// Function: ft_split
char			**ft_split(const char *s, char c)
{
	char		**result;

	result = NULL;
	if (s == NULL)
		return (NULL);
	if (s[0] == '\0')
		return (ft_return_zero(result));
	result = (char**)malloc(sizeof(char*) + (ft_strlen(s) * sizeof(char*)));
	if (result == NULL)
		return (NULL);
	return (ft_pre_process_split(result, s, c));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6f9b
movq $0x0, -0x8(%rbp)
jmp 0x6ff9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6fb6
movq -0x20(%rbp), %rdi
callq 0x7010
movq %rax, -0x8(%rbp)
jmp 0x6ff9
movq -0x10(%rbp), %rdi
callq 0x1bd0
movslq %eax, %rdi
shlq $0x3, %rdi
addq $0x8, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6fe4
movq $0x0, -0x8(%rbp)
jmp 0x6ff9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x7060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_split.c
// Function: ft_return_zero
static	char	**ft_return_zero(char **result)
{
	result = (char**)malloc(sizeof(char*));
	if (result == NULL)
		return (NULL);
	result[0] = NULL;
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl $0x8, %edi
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x703b
movq $0x0, -0x8(%rbp)
jmp 0x704e
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_split.c
// Function: ft_pre_process_split
static	char	**ft_pre_process_split(char **result, const char *s, char c)
{
	int			i;

	i = -1;
	while (s[++i] == c)
		;
	i--;
	return (ft_process_split(result, s, i, c));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x709a
jmp 0x707c
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movsbl -0x11(%rbp), %ecx
callq 0x70c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_split.c
// Function: ft_process_split
static char		**ft_process_split(char **result, const char *s, int i, char c)
{
	char	*partition;
	int		j;

	j = 0;
	partition = 0;
	while (s[++i] != '\0')
	{
		if (s[i] != c)
			partition = ft_stradd(partition, s[i]);
		else if (s[i + 1] != c)
		{
			result[j] = (char*)malloc(sizeof(char)
				* (ft_strlen(partition) + 1));
			if (result[j] == NULL)
				return (NULL);
			result[j] = ft_memcpy(result[j], partition,
				ft_strlen(partition) + 1);
			j++;
			free(partition);
			partition = 0;
		}
	}
	result[j] = partition;
	result[++j] = 0;
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x71fa
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
je 0x7136
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7240
movq %rax, -0x28(%rbp)
jmp 0x71f5
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
je 0x71f3
movq -0x28(%rbp), %rdi
callq 0x1bd0
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1110
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7196
movq $0x0, -0x8(%rbp)
jmp 0x722a
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1bd0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
addl $0x1, %eax
movslq %eax, %rdx
callq 0x7780
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq $0x0, -0x28(%rbp)
jmp 0x71f5
jmp 0x70e7
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x2c(%rbp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	char	*str;
	int		i;

	i = 0;
	str = (char *)s;
	while (i < (ft_strlen(str) + 1))
	{
		if (str[i] == c)
			return (str + i);
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bd0
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x73a6
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x14(%rbp), %eax
jne 0x739b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x73ae
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x735e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(char *s1, char *s2)
{
	unsigned char	a;
	unsigned char	b;
	unsigned int	i;

	i = 0;
	while (s1[i] != '\0' && s1[i] == s2[i])
	{
		i++;
	}
	a = s1[i];
	b = s2[i];
	return (a - b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x7406
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x740f
jmp 0x741a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x73d3
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	while (n && (*s1 || *s2))
	{
		if (*s1 != *s2)
			return ((unsigned char)*s1 - (unsigned char)*s2);
		s1++;
		s2++;
		n--;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x7483
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
jne 0x747d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x748c
jmp 0x74dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x74b3
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x74e3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7450
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_strtrim.c
// Function: ft_strtrim
char	*ft_strtrim(const char *s1, const char *set)
{
	int last_index;
	int start_trim;
	int i;

	if (s1 == NULL)
		return (NULL);
	if (set == NULL)
		return (ft_strdup(s1));
	if (s1[0] == '\0')
		return (ft_calloc(1, sizeof(char)));
	last_index = ft_strlen(s1) - 1;
	i = 0;
	while (s1[i] != '\0' && (ft_strchr(set, s1[i]) != 0))
		i++;
	start_trim = i;
	if (start_trim > last_index)
		return (ft_calloc(1, sizeof(char)));
	while (ft_strchr(set, s1[last_index]))
		last_index--;
	return (ft_substr(s1, start_trim, last_index - start_trim + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7514
movq $0x0, -0x8(%rbp)
jmp 0x7610
cmpq $0x0, -0x18(%rbp)
jne 0x752d
movq -0x10(%rbp), %rdi
callq 0x1c00
movq %rax, -0x8(%rbp)
jmp 0x7610
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x754f
movl $0x1, %esi
movq %rsi, %rdi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x7610
movq -0x10(%rbp), %rdi
callq 0x1bd0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x759a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7340
cmpq $0x0, %rax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x75a3
jmp 0x75ae
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7565
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x75cf
movl $0x1, %esi
movq %rsi, %rdi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x7610
jmp 0x75d1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x7340
cmpq $0x0, %rax
je 0x75f7
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x75d1
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
subl -0x20(%rbp), %edx
addl $0x1, %edx
callq 0x7620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, int len)
{
	char				*substr;
	unsigned int		i;

	i = 0;
	if (s == NULL)
		return (NULL);
	if ((unsigned)ft_strlen(s) < start)
		return (ft_calloc(1, sizeof(char)));
	substr = (char*)malloc((len * sizeof(char)) + 1);
	if (!substr)
		return (NULL);
	while (s[start] != '\0' && len > 0)
	{
		substr[i++] = s[start++];
		len--;
	}
	substr[i] = '\0';
	return (substr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x764d
movq $0x0, -0x8(%rbp)
jmp 0x7707
movq -0x10(%rbp), %rdi
callq 0x1bd0
cmpl -0x14(%rbp), %eax
jae 0x7671
movl $0x1, %esi
movq %rsi, %rdi
callq 0x7720
movq %rax, -0x8(%rbp)
jmp 0x7707
movslq -0x18(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7697
movq $0x0, -0x8(%rbp)
jmp 0x7707
jmp 0x7699
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x76b8
cmpl $0x0, -0x18(%rbp)
setg %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x76c1
jmp 0x76f4
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7699
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_calloc.c
// Function: ft_calloc
void	*ft_calloc(size_t count, size_t size)
{
	void	*ptr;
	size_t	len;

	len = count * size;
	if (!(ptr = malloc(len)))
		return (0);
	ft_bzero(ptr, len);
	return (ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x775a
movq $0x0, -0x8(%rbp)
jmp 0x776f
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7800
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pvineet44[P]minishell/libft/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	unsigned char	*source;
	unsigned char	*dest;
	size_t			i;

	if (!dst && !src)
		return (0);
	source = (unsigned char *)src;
	dest = (unsigned char *)dst;
	i = 0;
	while (i < n)
	{
		dest[i] = source[i];
		i++;
	}
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x77a8
cmpq $0x0, -0x18(%rbp)
jne 0x77a8
movq $0x0, -0x8(%rbp)
jmp 0x77f6
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x77ee
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x77c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/mmc.c
// Function: main
int main(int ac, char **av )
{
	char		*cmd=0, **args=0;
	int		nargs=0, r;
	CommandFunction func=0;

	r = parse_args(ac, av, &func, &nargs, &cmd, &args);
	if( r <= 0 ){
		/* error or no command to parse*/
		exit(-r);
	}

	exit(func(nargs, args));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x20(%rbp), %r9
callq 0x3400
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jg 0x33e4
xorl %edi, %edi
subl -0x28(%rbp), %edi
callq 0x3240
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, %edi
callq 0x3240
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/mmc.c
// Function: get_prgname
static char *get_prgname(char *programname)
{
	char	*np;
	np = strrchr(programname,'/');
	if(!np)
		np = programname;
	else
		np++;

	return np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x30d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x387f
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x388b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/mmc.c
// Function: help
static void help(char *np)
{
	struct Command *cp;

	printf("Usage:\n");
	for( cp = commands; cp->verb; cp++ )
		print_help(np, cp, BASIC_HELP);

	printf("\n\t%s help|--help|-h\n\t\tShow the help.\n",np);
	printf("\n\t%s <cmd> --help\n\t\tShow detailed help for a command or subset of commands.\n",np);
	printf("\n%s\n", MMC_VERSION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe75b(%rip), %rdi      # 0x1200e
movb $0x0, %al
callq 0x30c0
leaq 0x1788f(%rip), %rax     # 0x1b150
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x38ed
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3a20
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x10(%rbp)
jmp 0x38c5
movq -0x8(%rbp), %rsi
leaq 0xe7a7(%rip), %rdi      # 0x1209f
movb $0x0, %al
callq 0x30c0
movq -0x8(%rbp), %rsi
leaq 0xe7bb(%rip), %rdi      # 0x120c5
movb $0x0, %al
callq 0x30c0
leaq 0xe6fe(%rip), %rdi      # 0x12016
leaq 0xe6fc(%rip), %rsi      # 0x1201b
movb $0x0, %al
callq 0x30c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/mmc.c
// Function: split_command
static int split_command(char *cmd, char ***commands)
{
	int	c, l;
	char	*p, *s;

	for( *commands = 0, l = c = 0, p = s = cmd ; ; p++, l++ ){
		if ( *p && *p != ' ' )
			continue;

		/* c + 2 so that we have room for the null */
		(*commands) = realloc( (*commands), sizeof(char *)*(c + 2));
		(*commands)[c] = strndup(s, l);
		c++;
		l = 0;
		s = p+1;
		if( !*p ) break;
	}

	(*commands)[c] = 0;
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x397f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x397f
jmp 0x39ea
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x31d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x3130
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x39e8
jmp 0x3a04
jmp 0x39ea
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3965
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/blasphemy[P]mmc-utils/mmc.c
// Function: print_help
static void print_help(char *programname, struct Command *cmd, int helptype)
{
	char	*pc;

	printf("\t%s %s ", programname, cmd->verb );

	if (helptype == ADVANCED_HELP && cmd->adv_help)
		for(pc = cmd->adv_help; *pc; pc++){
			putchar(*pc);
			if(*pc == '\n')
				printf("\t\t");
		}
	else
		for(pc = cmd->help; *pc; pc++){
			putchar(*pc);
			if(*pc == '\n')
				printf("\t\t");
		}

	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xfbac(%rip), %rdi      # 0x135f2
movb $0x0, %al
callq 0x30c0
cmpl $0x1, -0x14(%rbp)
jne 0x3aab
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3aab
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3aa9
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x3040
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3a99
leaq 0xfb68(%rip), %rdi      # 0x135fa
movb $0x0, %al
callq 0x30c0
jmp 0x3a9b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3a6a
jmp 0x3af8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3af6
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x3040
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3ae6
leaq 0xfb1b(%rip), %rdi      # 0x135fa
movb $0x0, %al
callq 0x30c0
jmp 0x3ae8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3ab7
jmp 0x3af8
movl $0xa, %edi
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)