LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: copy_string(char*, unsigned int)
char *copy_string(char *str, u32 size) {
    char *ptr = str;
    char *out = (char *) malloc(size);
    char *copy = out;
    while (*ptr) *(copy++) = *(ptr++);
    *copy = '\0';
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
callq 0x2350
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x895a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x892d
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: strip_file_ending(char*)
void strip_file_ending(char *str) {
    s32 last_dot = -1;
    char *ptr = str;
    for (s32 index = 0; ptr[index]; index++) {
        if (ptr[index] == '.')
            last_dot = index;
    }
    if (last_dot != -1)
        str[last_dot] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8a60
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x8a53
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x8a55
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a2e
cmpl $-0x1, -0xc(%rbp)
je 0x8a72
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: append(char*, char const*)
void append(char *str, const char *postfix) {
    while (*(str++)) /* NO-OP */;
    str--;
    while (*postfix)
        *(str++) = *(postfix++);
    *str = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, (%rax)
je 0x8aa2
jmp 0x8a8c
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8adb
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x8aae
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/unix_assets.cpp
// Function: asset_name_from_file(char*, Asset::Type)
char *asset_name_from_file(char *path, Asset::Type type) {
    u32 start = (strncmp(path, "res/", 4) == 0) * 3;
    while (path[start] == '/')
        start++;
    path += start; // Strip leading "res\/*"
    const u32 len = strlen(path) + (type == Asset::Type::FONT) * 5 + 1;
    char *name = copy_string(path, len);
    strip_file_ending(name);
    replace_all(name, '/', '_');
    replace_all(name, '-', '_');
    make_uppercase(name);
    if (type == Asset::Type::FONT)
        append(name, "_FONT");
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1fef9(%rip), %rsi     # 0x28a03
movl $0x4, %edx
callq 0x2130
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
imull $0x3, %eax, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x8b40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8b25
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2110
cmpl $0x2, -0xc(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
imull $0x5, %ecx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8900
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8a10
movq -0x20(%rbp), %rdi
movl $0x2f, %esi
movl $0x5f, %edx
callq 0x8970
movq -0x20(%rbp), %rdi
movl $0x2d, %esi
movl $0x5f, %edx
callq 0x8970
movq -0x20(%rbp), %rdi
callq 0x89c0
cmpl $0x2, -0xc(%rbp)
jne 0x8bd4
movq -0x20(%rbp), %rdi
leaq 0x1fe39(%rip), %rsi     # 0x28a08
callq 0x8a80
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FredTheDino[P]Fog/src/engine/math/block_vector.h
// Function: Vec4::operator==(Vec4)
b8 operator==(Vec4 other) {
        return (x - other.x) * (x - other.x) < FLOAT_EQ_MARGIN &&
               (y - other.y) * (y - other.y) < FLOAT_EQ_MARGIN &&
               (z - other.z) * (z - other.z) < FLOAT_EQ_MARGIN &&
               (w - other.w) * (w - other.w) < FLOAT_EQ_MARGIN;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movss (%rax), %xmm0
subss -0x10(%rbp), %xmm0
movss (%rax), %xmm1
subss -0x10(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
xorl %eax, %eax
movsd 0x7232(%rip), %xmm0     # 0x28050
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jbe 0x20ec3
movq -0x28(%rbp), %rax
movss 0x4(%rax), %xmm0
subss -0xc(%rbp), %xmm0
movss 0x4(%rax), %xmm1
subss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
xorl %eax, %eax
movsd 0x71fb(%rip), %xmm0     # 0x28050
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jbe 0x20ec3
movq -0x28(%rbp), %rax
movss 0x8(%rax), %xmm0
subss -0x8(%rbp), %xmm0
movss 0x8(%rax), %xmm1
subss -0x8(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
xorl %eax, %eax
movsd 0x71c8(%rip), %xmm0     # 0x28050
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jbe 0x20ec3
movq -0x28(%rbp), %rax
movss 0xc(%rax), %xmm0
subss -0x4(%rbp), %xmm0
movss 0xc(%rax), %xmm1
subss -0x4(%rbp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x7197(%rip), %xmm0     # 0x28050
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/rrdtest.c
// Function: sample
static          rrd_value_t
sample(void *userdata)
{
    rrd_value_t     v;
    static size_t   i = 0;
    RRD_SOURCE      *src = (RRD_SOURCE*) userdata;

    v.int64 = numbers[i++ % (sizeof(numbers) / sizeof(numbers[0]))];

    printf("sample called: %"PRId64" from %s\n", v.int64, src->name);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xbbf5(%rip), %rax      # 0xd2c0
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xbbe7(%rip)      # 0xd2c0
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
leaq 0xba76(%rip), %rax      # 0xd160
movq (%rax,%rdx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x79eb(%rip), %rdi      # 0x90ef
movb $0x0, %al
callq 0x1110
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: ft_prepare_cd
void		ft_prepare_cd(char **tab, t_list_ex **lst)
{
	char			*oldpwd;

	oldpwd = NULL;
	if (tab[1] && tab[2])
	{
		ft_dprintf(2, "cd: %s: string not in pwd\n", tab[1]);
		return ;
	}
	if (ft_lst_returnvalue(*lst, "PWD"))
		oldpwd = ft_strdup(ft_lst_returnvalue(*lst, "PWD"));
	else
	{
		if (!(oldpwd = getcwd(oldpwd, 0)))
		{
			ft_dprintf(2, "minishell: current dir not found\n");
			return ;
		}
		ft_lst_changevalue(lst, "PWD", oldpwd);
	}
	if (!ft_lst_returnvalue(*lst, "OLDPWD"))
		ft_lst_changevalue(lst, "OLDPWD", oldpwd);
	ft_cd(*lst, tab[1]);
	chdir(ft_lst_returnvalue(*lst, "PWD"));
	ft_lst_changevalue(lst, "OLDPWD", oldpwd);
	ft_strdel(&oldpwd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12be
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12be
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x2, %edi
leaq 0xad52(%rip), %rsi      # 0xc004
movb $0x0, %al
callq 0x5630
jmp 0x13b4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xad78(%rip), %rsi      # 0xc044
callq 0x2b90
cmpq $0x0, %rax
je 0x12f8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xad5f(%rip), %rsi      # 0xc044
callq 0x2b90
movq %rax, %rdi
callq 0x3990
movq %rax, -0x18(%rbp)
jmp 0x133b
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1327
movl $0x2, %edi
leaq 0xad04(%rip), %rsi      # 0xc01f
movb $0x0, %al
callq 0x5630
jmp 0x13b4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xad0e(%rip), %rsi      # 0xc044
callq 0x2a90
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xacf8(%rip), %rsi      # 0xc041
callq 0x2b90
cmpq $0x0, %rax
jne 0x1368
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xacde(%rip), %rsi      # 0xc041
callq 0x2a90
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x26f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xacba(%rip), %rsi      # 0xc044
callq 0x2b90
movq %rax, %rdi
callq 0x1080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xac9b(%rip), %rsi      # 0xc041
callq 0x2a90
leaq -0x18(%rbp), %rdi
callq 0x3d50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: main
int			main(int ac, char **av, char **envp)
{
	char		*line;
	t_list_ex	*env;

	(void)ac;
	(void)av;
	if (signal(SIGINT, ft_ctrlc) == SIG_ERR)
		return (1);
	env = ft_dup_env(envp);
	ft_shlvl(&env);
	ft_set_global(env);
	ft_print_prompt();
	line = NULL;
	while (get_next_line(0, &line) > 0)
	{
		ft_split_line(line, &env);
		ft_strdel(&line);
		ft_set_global(env);
		ft_print_prompt();
	}
	ft_free_global();
	ft_freelistex(env);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, %edi
leaq 0x3ba(%rip), %rsi       # 0x17a0
callq 0x10e0
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x1400
movl $0x1, -0x4(%rbp)
jmp 0x1477
movq -0x18(%rbp), %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1910
movq -0x28(%rbp), %rdi
callq 0x1820
callq 0x17f0
movq $0x0, -0x20(%rbp)
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
callq 0x4af0
cmpl $0x0, %eax
jle 0x1462
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1480
leaq -0x20(%rbp), %rdi
callq 0x3d50
movq -0x28(%rbp), %rdi
callq 0x1820
callq 0x17f0
jmp 0x142c
callq 0x18c0
movq -0x28(%rbp), %rdi
callq 0x2bf0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: ft_split_line
static void	ft_split_line(char *s, t_list_ex **lst)
{
	char	**tab;
	char	**sc;
	int		i;

	i = 0;
	if (!(sc = ft_strsplit(s, ';')))
		return ;
	while (sc[i])
	{
		if (!(tab = ft_strsplit_whitespaces(sc[i])) || !tab[0])
		{
			if (tab)
				ft_free_tab_str(tab);
			break ;
		}
		if (ft_change_dollar_and_tild(tab, *lst))
			ft_command(tab, lst, "minishell", sc);
		ft_free_tab_str(tab);
		i++;
	}
	ft_free_tab_str(sc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x4010
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x14b4
jmp 0x1549
jmp 0x14b6
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1540
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4380
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x14ea
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14fc
cmpq $0x0, -0x18(%rbp)
je 0x14fa
movq -0x18(%rbp), %rdi
callq 0x3d90
jmp 0x1540
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2e90
cmpl $0x0, %eax
je 0x1529
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0xab24(%rip), %rdx      # 0xc048
callq 0x1550
movq -0x18(%rbp), %rdi
callq 0x3d90
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14b6
movq -0x20(%rbp), %rdi
callq 0x3d90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: ft_command
static void	ft_command(char **tab, t_list_ex **lst, char *process, char **sc)
{
	t_list_ex	*env;

	if (!ft_strcmp(tab[0], "exit"))
		ft_exit(tab, lst, sc);
	else if (!ft_strcmp(tab[0], "env"))
	{
		env = ft_duplist(*lst);
		ft_process_env((tab + 1), &env);
		ft_freelistex(env);
	}
	else if (!ft_strcmp(tab[0], "setenv"))
		ft_setenv(lst, tab + 1);
	else if (!ft_strcmp(tab[0], "unsetenv"))
		ft_unsetenv(lst, tab + 1);
	else if (!ft_strcmp(tab[0], "cd"))
		ft_prepare_cd(tab, lst);
	else if (!ft_strcmp(tab[0], "echo"))
		ft_echo(tab + 1);
	else
		ft_process_out(*lst, process, tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xaadc(%rip), %rsi      # 0xc052
callq 0x3640
cmpl $0x0, %eax
jne 0x1596
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16b0
jmp 0x16a2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xaab8(%rip), %rsi      # 0xc05c
callq 0x3640
cmpl $0x0, %eax
jne 0x15dd
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2c40
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cf0
movq -0x28(%rbp), %rdi
callq 0x2bf0
jmp 0x16a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xaa6e(%rip), %rsi      # 0xc059
callq 0x3640
cmpl $0x0, %eax
jne 0x160b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b90
jmp 0x169e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xaa3e(%rip), %rsi      # 0xc057
callq 0x3640
cmpl $0x0, %eax
jne 0x1636
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x1b40
jmp 0x169c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xaa1c(%rip), %rsi      # 0xc060
callq 0x3640
cmpl $0x0, %eax
jne 0x165d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1270
jmp 0x169a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xa9f8(%rip), %rsi      # 0xc063
callq 0x3640
cmpl $0x0, %eax
jne 0x1684
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x19d0
jmp 0x1698
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x30f0
jmp 0x169a
jmp 0x169c
jmp 0x169e
jmp 0x16a0
jmp 0x16a2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_minishell.c
// Function: ft_exit
static void	ft_exit(char **tab, t_list_ex **lst, char **sc)
{
	if (tab[1] && tab[2])
		ft_dprintf(2, "exit: Too much arguments\n");
	else if (tab[1])
	{
		if (!ft_str_is_numeric(tab[1]))
			ft_dprintf(2, "exit: Numeric argument required\n");
		else
		{
			ft_free_global();
			ft_freelistex(*lst);
			g_glob.ret = ft_atoi(tab[1]);
			ft_free_tab_str(tab);
			ft_free_tab_str(sc);
			exit(g_glob.ret);
		}
	}
	else
	{
		ft_free_global();
		ft_freelistex(*lst);
		ft_free_tab_str(tab);
		ft_free_tab_str(sc);
		exit(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16f2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x16f2
movl $0x2, %edi
leaq 0xa982(%rip), %rsi      # 0xc068
movb $0x0, %al
callq 0x5630
jmp 0x1793
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1767
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e00
cmpl $0x0, %eax
jne 0x1724
movl $0x2, %edi
leaq 0xa967(%rip), %rsi      # 0xc082
movb $0x0, %al
callq 0x5630
jmp 0x1765
callq 0x18c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2bf0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4860
movl %eax, 0xf98c(%rip)      # 0x110d4
movq -0x8(%rbp), %rdi
callq 0x3d90
movq -0x18(%rbp), %rdi
callq 0x3d90
movl 0xf974(%rip), %edi      # 0x110d4
callq 0x1150
jmp 0x1791
callq 0x18c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2bf0
movq -0x8(%rbp), %rdi
callq 0x3d90
movq -0x18(%rbp), %rdi
callq 0x3d90
xorl %edi, %edi
callq 0x1150
jmp 0x1793
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_ctrlc
void	ft_ctrlc(int c)
{
	(void)c;
	if (g_glob.pid)
	{
		kill(g_glob.pid, SIGINT);
		g_glob.ret = c;
	}
	else
	{
		ft_putchar('\n');
		ft_print_prompt();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xf91e(%rip), %rax      # 0x110d0
cmpl $0x0, (%rax)
je 0x17d9
leaq 0xf912(%rip), %rax      # 0x110d0
movl (%rax), %edi
movl $0x2, %esi
callq 0x1100
movl -0x4(%rbp), %ecx
leaq 0xf8fc(%rip), %rax      # 0x110d0
movl %ecx, 0x4(%rax)
jmp 0x17e8
movl $0xa, %edi
callq 0x4730
callq 0x17f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_set_global
void	ft_set_global(t_list_ex *lst)
{
	struct passwd	*pw;

	ft_free_global();
	if (!ft_lst_returnvalue(lst, "USER"))
	{
		pw = getpwuid(geteuid());
		g_glob.user = ft_strdup(pw->pw_name);
	}
	else
		g_glob.user = ft_strdup(ft_lst_returnvalue(lst, "USER"));
	g_glob.cur_dir = ft_curdir();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x18c0
movq -0x8(%rbp), %rdi
leaq 0xa867(%rip), %rsi      # 0xc0a3
callq 0x2b90
cmpq $0x0, %rax
jne 0x1873
callq 0x1090
movl %eax, %edi
callq 0x1070
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3990
movq %rax, %rcx
leaq 0xf863(%rip), %rax      # 0x110d0
movq %rcx, 0x10(%rax)
jmp 0x1899
movq -0x8(%rbp), %rdi
leaq 0xa825(%rip), %rsi      # 0xc0a3
callq 0x2b90
movq %rax, %rdi
callq 0x3990
movq %rax, %rcx
leaq 0xf83b(%rip), %rax      # 0x110d0
movq %rcx, 0x10(%rax)
callq 0x2320
movq %rax, %rcx
leaq 0xf828(%rip), %rax      # 0x110d0
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_free_global
void	ft_free_global(void)
{
	free(g_glob.cur_dir);
	free(g_glob.user);
	g_glob.cur_dir = NULL;
	g_glob.user = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xf805(%rip), %rax      # 0x110d0
movq 0x8(%rax), %rdi
callq 0x1030
leaq 0xf7f5(%rip), %rax      # 0x110d0
movq 0x10(%rax), %rdi
callq 0x1030
leaq 0xf7e5(%rip), %rax      # 0x110d0
movq $0x0, 0x8(%rax)
leaq 0xf7d6(%rip), %rax      # 0x110d0
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_shlvl
void	ft_shlvl(t_list_ex **lst)
{
	char	*tmp;
	char	*tmp2;
	int		lvl;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
		ft_dprintf(2, "minishell: shell path not found\n");
	ft_lst_changevalue(lst, "SHELL", tmp2);
	ft_strdel(&tmp2);
	if ((tmp = ft_lst_returnvalue(*lst, "SHLVL")))
		lvl = ft_atoi(tmp) + 1;
	else
		lvl = 1;
	tmp = ft_itoa(lvl);
	ft_lst_changevalue(lst, "SHLVL", tmp);
	ft_strdel(&tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x194e
movl $0x2, %edi
leaq 0xa783(%rip), %rsi      # 0xc0ca
movb $0x0, %al
callq 0x5630
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa78e(%rip), %rsi      # 0xc0eb
callq 0x2a90
leaq -0x18(%rbp), %rdi
callq 0x3d50
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xa778(%rip), %rsi      # 0xc0f1
callq 0x2b90
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1999
movq -0x10(%rbp), %rdi
callq 0x4860
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19a0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x4970
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa736(%rip), %rsi      # 0xc0f1
callq 0x2a90
leaq -0x10(%rbp), %rdi
callq 0x3d50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_echo.c
// Function: ft_echo
void		ft_echo(char **tab)
{
	int		i;
	int		flag_n;
	char	*s;

	flag_n = 0;
	i = 0;
	s = NULL;
	ft_quote(tab);
	if (tab[0] && !ft_strcmp(tab[0], "-n"))
	{
		flag_n = 1;
		i++;
	}
	while (tab[i])
	{
		s = ft_strjoinfree(s, tab[i++], FIRST);
		if (tab[i])
			s = ft_strjoinfree(s, " ", FIRST);
	}
	if (!flag_n)
		s = ft_strjoinfree(s, "\n", FIRST);
	ft_putstr(s);
	ft_strdel(&s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ad0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a2d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xa6e4(%rip), %rsi      # 0xc0f7
callq 0x3640
cmpl $0x0, %eax
jne 0x1a2d
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a2f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a90
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1a8e
movq -0x18(%rbp), %rdi
leaq 0xa648(%rip), %rsi      # 0xc0c8
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x18(%rbp)
jmp 0x1a2f
cmpl $0x0, -0x10(%rbp)
jne 0x1aaf
movq -0x18(%rbp), %rdi
leaq 0xa6ae(%rip), %rsi      # 0xc14f
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4760
leaq -0x18(%rbp), %rdi
callq 0x3d50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_echo.c
// Function: ft_quote
static void	ft_quote(char **tab)
{
	char	*tmp;

	tmp = ft_strctrim(*tab, '\'');
	ft_strdel(tab);
	*tab = tmp;
	tmp = ft_strctrim(*tab, '\"');
	ft_strdel(tab);
	*tab = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x27, %esi
callq 0x3ee0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d50
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x22, %esi
callq 0x3ee0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d50
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_unsetenv
void		ft_unsetenv(t_list_ex **lst, char **tab)
{
	int		i;

	i = 0;
	while (tab[i])
		ft_lstexpop(lst, tab[i++]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1b87
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2930
jmp 0x1b57
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_setenv
void		ft_setenv(t_list_ex **lst, char **tab)
{
	char	*tmp;
	char	*tmp2;

	if (!tab || !tab[0])
		return ;
	if (tab[0] && (tmp = ft_strchr(tab[0], '=')))
	{
		tmp2 = ft_strcdup(tab[0], '=');
		tmp = ft_strdup(tmp + 1);
		if (tmp && *(tmp) == '~')
			if (!ft_tilde(&tmp, *lst, NULL, 0))
				return ;
		ft_lst_changevalue(lst, tmp2, tmp);
		ft_strdel(&tmp2);
		ft_strdel(&tmp);
	}
	else if (tab[0] && tab[1])
	{
		tmp2 = ft_strcdup(tab[0], '=');
		if (tab[1][0] == '~')
			if (!ft_tilde(tab, *lst, NULL, 1))
				return ;
		ft_lst_changevalue(lst, tmp2, tab[1]);
		ft_strdel(&tmp2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bb1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1bb6
jmp 0x1cdf
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1c63
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x37d0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1c63
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x39f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x3990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c3e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x1c3e
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x2ca0
cmpl $0x0, %eax
jne 0x1c3c
jmp 0x1cdf
jmp 0x1c3e
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a90
leaq -0x20(%rbp), %rdi
callq 0x3d50
leaq -0x18(%rbp), %rdi
callq 0x3d50
jmp 0x1cdf
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1cdd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1cdd
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x39f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x1cbf
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x2ca0
cmpl $0x0, %eax
jne 0x1cbd
jmp 0x1cdf
jmp 0x1cbf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2a90
leaq -0x20(%rbp), %rdi
callq 0x3d50
jmp 0x1cdf
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_process_env
void		ft_process_env(char **tab, t_list_ex **lst)
{
	int			i;
	int			flag_i;
	t_list_ex	*new_env;
	char		*tmp;
	char		*tmp2;

	i = 0;
	flag_i = 0;
	new_env = NULL;
	if (!ft_env_options(tab, &i, &flag_i))
		return ;
	while (tab[i] && (tmp = ft_strchr(tab[i], '=')))
	{
		tmp2 = ft_strsub(tab[i], 0, tmp - tab[i]);
		ft_lst_changevalue(flag_i ? &new_env : lst, tmp2, tmp + 1);
		ft_strdel(&tmp2);
		i++;
	}
	if (!tab[i])
		ft_lst_printenv(flag_i ? new_env : *lst);
	else if (!ft_is_builtin(tab[i], lst, &new_env, flag_i))
		ft_process_out((flag_i ? new_env : *lst), "env", tab + i);
	ft_freelistex(new_env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1e90
cmpl $0x0, %eax
jne 0x1d31
jmp 0x1e7d
jmp 0x1d33
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x31(%rbp)
je 0x1d6b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3d, %esi
callq 0x37d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1d74
jmp 0x1de2
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x3c00
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1dae
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1db6
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
callq 0x2a90
leaq -0x30(%rbp), %rdi
callq 0x3d50
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d33
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1e17
cmpl $0x0, -0x18(%rbp)
je 0x1e01
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x1e0c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2b40
jmp 0x1e74
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %ecx
leaq -0x20(%rbp), %rdx
callq 0x1fd0
cmpl $0x0, %eax
jne 0x1e72
cmpl $0x0, -0x18(%rbp)
je 0x1e48
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1e53
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rdx
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0xa1ef(%rip), %rsi      # 0xc05c
callq 0x30f0
jmp 0x1e74
movq -0x20(%rbp), %rdi
callq 0x2bf0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_env_options
static int	ft_env_options(char **tab, int *i, int *flag_i)
{
	int			j;

	while (tab[*i] && tab[*i][0] == '-')
	{
		j = 1;
		if (tab[*i][j] == '-')
			break ;
		while (tab[*i][j] == 'i')
		{
			*flag_i = 1;
			j++;
		}
		if (tab[*i][j])
		{
			ft_dprintf(2, "env: Illegal option -- %c\n", tab[*i][j]);
			ft_dprintf(2, "usage: env [-i] [name=value ...]");
			ft_dprintf(2, " [utility [argument ...]]\n");
			return (FALSE);
		}
		(*i)++;
	}
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq (%rax), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x25(%rbp)
je 0x1ed6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x1ee2
jmp 0x1fbf
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x1f0a
jmp 0x1fbf
jmp 0x1f0c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x69, %eax
jne 0x1f3d
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1f0c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1faf
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movl $0x2, %edi
leaq 0xa181(%rip), %rsi      # 0xc0fa
movb $0x0, %al
callq 0x5630
movl $0x2, %edi
leaq 0xa189(%rip), %rsi      # 0xc115
movb $0x0, %al
callq 0x5630
movl $0x2, %edi
leaq 0xa197(%rip), %rsi      # 0xc136
movb $0x0, %al
callq 0x5630
movl $0x0, -0x4(%rbp)
jmp 0x1fc6
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1ea4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_is_builtin
static int	ft_is_builtin(char *s, t_list_ex **lst, t_list_ex **new, int flag_i)
{
	if (!ft_strcmp(s, "exit")
		|| !ft_strcmp(s, "cd")
		|| !ft_strcmp(s, "env")
		|| !ft_strcmp(s, "setenv")
		|| !ft_strcmp(s, "unsetenv"))
	{
		ft_dprintf(2, "env: %s: is a built-in\n", s);
		return (TRUE);
	}
	if (flag_i && !ft_lst_returnvalue(*new, "PATH")
		&& ft_lst_returnvalue(*lst, "PATH"))
		ft_lst_changevalue(new, "PATH", ft_lst_returnvalue(*lst, "PATH"));
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa060(%rip), %rsi      # 0xc052
callq 0x3640
cmpl $0x0, %eax
je 0x2050
movq -0x10(%rbp), %rdi
leaq 0xa059(%rip), %rsi      # 0xc060
callq 0x3640
cmpl $0x0, %eax
je 0x2050
movq -0x10(%rbp), %rdi
leaq 0xa040(%rip), %rsi      # 0xc05c
callq 0x3640
cmpl $0x0, %eax
je 0x2050
movq -0x10(%rbp), %rdi
leaq 0xa028(%rip), %rsi      # 0xc059
callq 0x3640
cmpl $0x0, %eax
je 0x2050
movq -0x10(%rbp), %rdi
leaq 0xa011(%rip), %rsi      # 0xc057
callq 0x3640
cmpl $0x0, %eax
jne 0x2070
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0xa0f1(%rip), %rsi      # 0xc151
movb $0x0, %al
callq 0x5630
movl $0x1, -0x4(%rbp)
jmp 0x20dd
cmpl $0x0, -0x24(%rbp)
je 0x20d6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0xa0e5(%rip), %rsi      # 0xc169
callq 0x2b90
cmpq $0x0, %rax
jne 0x20d6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xa0cc(%rip), %rsi      # 0xc169
callq 0x2b90
cmpq $0x0, %rax
je 0x20d6
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0xa0ab(%rip), %rsi      # 0xc169
callq 0x2b90
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xa098(%rip), %rsi      # 0xc169
callq 0x2a90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_strcnextdup
char		*ft_strcnextdup(char *s, char c)
{
	char	*new;
	char	*tmp;

	new = ft_strdup(s);
	if (!(tmp = ft_strchr(s, c)))
		return (new);
	*(tmp + 1) = '\0';
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3990
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x37d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x2130
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2140
movq -0x28(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_lst_to_tab
char		**ft_lst_to_tab(t_list_ex *lst)
{
	char	**tab;
	int		count;
	int		i;

	count = ft_lstexsize(lst);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	i = 0;
	while (lst)
	{
		tab[i] = ft_strnew(ft_strlen(lst->name) + ft_strlen(lst->value) + 2);
		ft_strcat(tab[i], lst->name);
		ft_strcat(tab[i], "=");
		ft_strcat(tab[i], lst->value);
		lst = lst->next;
		i++;
	}
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2191
movq $0x0, -0x8(%rbp)
jmp 0x225b
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2253
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3c90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c90
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
callq 0x3e70
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x35c0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x9f52(%rip), %rsi      # 0xc16e
callq 0x35c0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x35c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x21a8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_dup_env
t_list_ex	*ft_dup_env(char **env)
{
	t_list_ex	*lst;
	char		*tmp;
	char		*tmp2;

	lst = NULL;
	while (*env)
	{
		ft_lstexadd(&lst, ft_lstexnew((tmp = ft_strcdup(*env, '=')),
					(tmp2 = ft_strchr(*env, '=')) ? tmp2 + 1 : NULL));
		ft_strdel(&tmp);
		env++;
	}
	return (lst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x230b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x39f0
movq %rax, -0x28(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x3d, %esi
callq 0x37d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x22d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x22d8
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x22d8
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2860
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x29e0
leaq -0x18(%rbp), %rdi
callq 0x3d50
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x2284
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_curdir
char	*ft_curdir(void)
{
	char	*tmp;
	char	*tmp2;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
	{
		ft_dprintf(2, "minishell: current dir not found\n");
		return (NULL);
	}
	tmp = ft_strdup(ft_strrchr(tmp2, '/'));
	ft_strdel(&tmp2);
	if (tmp && *(tmp + 1))
	{
		tmp2 = ft_strdup(tmp + 1);
		ft_strdel(&tmp);
		return (tmp2);
	}
	return (tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2364
movl $0x2, %edi
leaq 0x9ccc(%rip), %rsi      # 0xc01f
movb $0x0, %al
callq 0x5630
movq $0x0, -0x8(%rbp)
jmp 0x23c7
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x3860
movq %rax, %rdi
callq 0x3990
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3d50
cmpq $0x0, -0x10(%rbp)
je 0x23bf
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x23bf
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x3990
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3d50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23c7
movq -0x10(%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/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd_access
int		ft_cd_access(t_list_ex *lst, char *tmp, char *s)
{
	DIR		*dir;
	int		ret;

	ret = 0;
	if (access(tmp, F_OK) == -1)
		ret = 1;
	else if (access(tmp, R_OK) == -1)
		ret = -1;
	else if (!(dir = opendir(tmp)))
		ret = -2;
	else
	{
		closedir(dir);
		ft_lst_changevalue(&lst, "PWD", tmp);
		ft_strdel(&tmp);
		return (ft_process_cd(lst, ft_strchr(s, '/')));
	}
	ft_strdel(&tmp);
	g_glob.ret = ret;
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1140
cmpl $-0x1, %eax
jne 0x2417
movl $0x1, -0x2c(%rbp)
jmp 0x24a0
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x1140
cmpl $-0x1, %eax
jne 0x2433
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x249e
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x244f
movl $0xfffffffe, -0x2c(%rbp) # imm = 0xFFFFFFFE
jmp 0x249c
movq -0x28(%rbp), %rdi
callq 0x10b0
movq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq 0x9bdd(%rip), %rsi      # 0xc044
callq 0x2a90
leaq -0x18(%rbp), %rdi
callq 0x3d50
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2f, %esi
callq 0x37d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x24d0
movl %eax, -0x4(%rbp)
jmp 0x24bc
jmp 0x249e
jmp 0x24a0
leaq -0x18(%rbp), %rdi
callq 0x3d50
movl -0x2c(%rbp), %ecx
leaq 0xec1d(%rip), %rax      # 0x110d0
movl %ecx, 0x4(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd
void	ft_cd(t_list_ex *lst, char *s)
{
	int				ret;
	char			*tru;
	struct passwd	*pwd;

	tru = ft_lst_returnvalue(lst, "PWD");
	if (!s)
	{
		pwd = getpwuid(geteuid());
		if (!(s = ft_lst_returnvalue(lst, "HOME")))
			s = pwd->pw_dir;
	}
	else if (!ft_strcmp(s, "."))
		return ;
	else if (!ft_strcmp(s, "-"))
		s = ft_lst_returnvalue(lst, "OLDPWD");
	if (s && s[0] == '/')
		ft_lst_changevalue(&lst, "PWD", "/");
	if ((ret = ft_process_cd(lst, s)) == 1)
		ft_dprintf(2, "cd: %s: No such file or directory\n", s);
	else if (ret == -1)
		ft_dprintf(2, "cd: %s: Permission denied\n", s);
	else if (ret == -2)
		ft_dprintf(2, "cd: %s: Not a directory\n", s);
	if (ret)
		ft_lst_changevalue(&lst, "PWD", ft_strdup(tru));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9939(%rip), %rsi      # 0xc044
callq 0x2b90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2753
callq 0x1090
movl %eax, %edi
callq 0x1070
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9a3f(%rip), %rsi      # 0xc175
callq 0x2b90
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2751
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x279a
movq -0x10(%rbp), %rdi
leaq 0x9a13(%rip), %rsi      # 0xc171
callq 0x3640
cmpl $0x0, %eax
jne 0x276d
jmp 0x2854
movq -0x10(%rbp), %rdi
leaq 0x9a02(%rip), %rsi      # 0xc17a
callq 0x3640
cmpl $0x0, %eax
jne 0x2796
movq -0x8(%rbp), %rdi
leaq 0x98b4(%rip), %rsi      # 0xc041
callq 0x2b90
movq %rax, -0x10(%rbp)
jmp 0x2798
jmp 0x279a
cmpq $0x0, -0x10(%rbp)
je 0x27c4
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x27c4
leaq -0x8(%rbp), %rdi
leaq 0x988c(%rip), %rsi      # 0xc044
leaq 0x99b4(%rip), %rdx      # 0xc173
callq 0x2a90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24d0
movl %eax, -0x14(%rbp)
cmpl $0x1, %eax
jne 0x27f2
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x9993(%rip), %rsi      # 0xc17c
movb $0x0, %al
callq 0x5630
jmp 0x2832
cmpl $-0x1, -0x14(%rbp)
jne 0x2811
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x9997(%rip), %rsi      # 0xc19f
movb $0x0, %al
callq 0x5630
jmp 0x2830
cmpl $-0x2, -0x14(%rbp)
jne 0x282e
movq -0x10(%rbp), %rdx
movl $0x2, %edi
leaq 0x9993(%rip), %rsi      # 0xc1ba
movb $0x0, %al
callq 0x5630
jmp 0x2830
jmp 0x2832
cmpl $0x0, -0x14(%rbp)
je 0x2854
movq -0x20(%rbp), %rdi
callq 0x3990
movq %rax, %rdx
leaq -0x8(%rbp), %rdi
leaq 0x97f5(%rip), %rsi      # 0xc044
callq 0x2a90
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexnew
t_list_ex	*ft_lstexnew(char *name, char *value)
{
	t_list_ex	*list;

	if (!(list = (t_list_ex *)malloc(sizeof(t_list_ex))))
		return (NULL);
	list->next = NULL;
	list->name = ft_strdup(name);
	list->value = ft_strdup(value);
	return (list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x288e
movq $0x0, -0x8(%rbp)
jmp 0x28c9
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3990
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x3990
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_free_node
void		ft_free_node(t_list_ex **lst)
{
	ft_strdel(&(*lst)->name);
	ft_strdel(&(*lst)->value);
	free(*lst);
	*lst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
callq 0x3d50
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x3d50
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexpop
void		ft_lstexpop(t_list_ex **lst, char *name)
{
	t_list_ex	*before;
	t_list_ex	*tmp;
	int			first;

	before = *lst;
	tmp = *lst;
	first = 0;
	while (tmp)
	{
		if (tmp->name && !ft_strcmp(tmp->name, name))
		{
			if (first != 0)
				before->next = tmp->next;
			else
			{
				before = tmp->next;
				*lst = before;
			}
			ft_free_node(&tmp);
			return ;
		}
		before = tmp;
		first++;
		tmp = tmp->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29da
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x29bc
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3640
cmpl $0x0, %eax
jne 0x29bc
cmpl $0x0, -0x24(%rbp)
je 0x299b
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x29b1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x28e0
jmp 0x29da
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x295d
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexadd
void		ft_lstexadd(t_list_ex **alst, t_list_ex *new)
{
	t_list_ex	*tmp;

	if (!alst || !new)
		return ;
	if (!*alst)
		*alst = new;
	else
	{
		tmp = *alst;
		while (tmp->next)
			tmp = tmp->next;
		tmp->next = new;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29fa
cmpq $0x0, -0x10(%rbp)
jne 0x29fc
jmp 0x2a40
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2a13
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2a40
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a35
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2a1e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexsize
int			ft_lstexsize(t_list_ex *lst)
{
	int	count;

	count = 0;
	while (lst)
	{
		lst = lst->next;
		count++;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a7c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a5f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_changevalue
int			ft_lst_changevalue(t_list_ex **lst, char *name, char *value)
{
	t_list_ex	*tmp;

	tmp = *lst;
	while (tmp)
	{
		if (!ft_strcmp(tmp->name, name))
		{
			ft_strdel(&tmp->value);
			tmp->value = ft_strdup(value);
			return (TRUE);
		}
		tmp = tmp->next;
	}
	ft_lstexadd(lst, ft_lstexnew(name, value));
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2b03
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3640
cmpl $0x0, %eax
jne 0x2af6
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3d50
movq -0x20(%rbp), %rdi
callq 0x3990
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2b2b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2aaf
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2860
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x29e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)