LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/user_name_avaialbe.c
// Function: user_name_avaiable
int user_name_avaiable(const char* user_name,MYSQL* connect)
{
    char buf[128];
    sprintf(buf,"select * from User where user_name='%s'",user_name);
    unsigned int queryRet = mysql_query(connect,buf);
    if(queryRet)
    {
        printf("Mysql query error: %s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_RES* res;
    res = mysql_store_result(connect);
    return (mysql_num_rows(res) == 0)? 1: 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x106a(%rip), %rsi      # 0x764f
movb $0x0, %al
callq 0x2070
movq -0x18(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2150
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x662e
movq -0x18(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0xaf7(%rip), %rdi       # 0x7115
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x665e
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x21a0
movq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/vsim.c
// Function: fetch_mem
unsigned short fetch_mem ( unsigned short add )
{
    unsigned short data;
    fetch_mem_count++;
    data=mem[add];
    printf("fetch_mem[0x%04X]=>0x%04X\n",add,data);
    return(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl 0x3ebb(%rip), %eax      # 0x5080
addl $0x1, %eax
movl %eax, 0x3eb2(%rip)      # 0x5080
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x3eb5(%rip), %rax      # 0x5090
movw (%rax,%rcx,2), %ax
movw %ax, -0x4(%rbp)
movzwl -0x2(%rbp), %esi
movzwl -0x4(%rbp), %edx
leaq 0x1e52(%rip), %rdi      # 0x3044
movb $0x0, %al
callq 0x1040
movw -0x4(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/vsim.c
// Function: read_mem
unsigned short read_mem ( unsigned short add )
{
    unsigned short data;
    read_mem_count++;
    data=mem[add];
    printf("read_mem[0x%04X]=>0x%04X\n",add,data);
    return(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl 0x23e6b(%rip), %eax     # 0x25090
addl $0x1, %eax
movl %eax, 0x23e62(%rip)     # 0x25090
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x3e55(%rip), %rax      # 0x5090
movw (%rax,%rcx,2), %ax
movw %ax, -0x4(%rbp)
movzwl -0x2(%rbp), %esi
movzwl -0x4(%rbp), %edx
leaq 0x1e0d(%rip), %rdi      # 0x305f
movb $0x0, %al
callq 0x1040
movw -0x4(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/vsim.c
// Function: read_reg
unsigned short read_reg ( unsigned short r )
{
    unsigned short d;
    r&=7;
    d=reg[r];
    printf("read_reg[%u]=>0x%04X\n",r,d);
    return(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0x7, %eax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x23db9(%rip), %rax     # 0x250a0
movw (%rax,%rcx,2), %ax
movw %ax, -0x4(%rbp)
movzwl -0x2(%rbp), %esi
movzwl -0x4(%rbp), %edx
leaq 0x1d96(%rip), %rdi      # 0x3094
movb $0x0, %al
callq 0x1040
movw -0x4(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/vsim.c
// Function: docc
void docc ( unsigned short x)
{
    psr&=0x8000;
    if(x&0x8000)
    {
        psr|=(1<<2);
    }
    else
    {
        if(x==0)
        {
            psr|=(1<<1);
        }
        else
        {
            psr|=(1<<0);
        }
    }
    printf("psr 0x%04X\n",psr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl 0x23c2a(%rip), %eax     # 0x250b0
andl $0x8000, %eax           # imm = 0x8000
movw %ax, 0x23c1e(%rip)      # 0x250b0
movzwl -0x2(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x14b3
movzwl 0x23c09(%rip), %eax     # 0x250b0
orl $0x4, %eax
movw %ax, 0x23bff(%rip)      # 0x250b0
jmp 0x14e2
movzwl -0x2(%rbp), %eax
cmpl $0x0, %eax
jne 0x14cf
movzwl 0x23bed(%rip), %eax     # 0x250b0
orl $0x2, %eax
movw %ax, 0x23be3(%rip)      # 0x250b0
jmp 0x14e0
movzwl 0x23bda(%rip), %eax     # 0x250b0
orl $0x1, %eax
movw %ax, 0x23bd0(%rip)      # 0x250b0
jmp 0x14e2
movzwl 0x23bc7(%rip), %esi     # 0x250b0
leaq 0x1bd1(%rip), %rdi      # 0x30c1
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/vsim.c
// Function: reset
void reset ( void )
{
    pc=0x3000;
    psr=2;
    reg[0]=0;
    reg[1]=0;
    reg[2]=0;
    reg[3]=0;
    reg[4]=0;
    reg[5]=0;
    reg[6]=0;
    reg[7]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw $0x3000, 0x22fd5(%rip)  # imm = 0x3000
movw $0x2, 0x22fca(%rip)     # 0x250b0
movw $0x0, 0x22fb1(%rip)     # 0x250a0
movw $0x0, 0x22faa(%rip)     # 0x250a2
movw $0x0, 0x22fa3(%rip)     # 0x250a4
movw $0x0, 0x22f9c(%rip)     # 0x250a6
movw $0x0, 0x22f95(%rip)     # 0x250a8
movw $0x0, 0x22f8e(%rip)     # 0x250aa
movw $0x0, 0x22f87(%rip)     # 0x250ac
movw $0x0, 0x22f80(%rip)     # 0x250ae
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/test/hello.c
// Function: main
int main(int argc, char* argv[])
{
	int err = 0;
	int major, minor;
	char name[SHMEM_MAX_NAME_LEN];

	// Starts/Initializes SHMEM/OpenSHMEM
	// Some implementations use the deprecated start_pes(0)
	shmem_init();

	// Fetch the number or processes
	// Some implementations use the deprecated num_pes()
	int n_pes = shmem_n_pes();

	// Assign my process ID to me
	int me = shmem_my_pe();

	// Query 
	shmem_info_get_name(name);
	shmem_info_get_version(&major, &minor);

	if (me == 0) {
		printf("# API   : %s (%d.%d)\n", name, major, minor);
		printf("# HEADER: %s (%d.%d)\n", SHMEM_VENDOR_STRING,
			SHMEM_MAJOR_VERSION, SHMEM_MINOR_VERSION);
	}

	// Global barrier
	shmem_barrier_all();

	// Comparing shmem.h header values and API values
	if (strncmp(name, SHMEM_VENDOR_STRING, SHMEM_MAX_NAME_LEN)) {
		printf("# %d: ERROR: vendor name mismatch\n", me);
		err++;
	}
	if (major != SHMEM_MAJOR_VERSION) {
		printf("# %d: ERROR: major version mismatch\n", me);
		err++;
	}
	if (minor != SHMEM_MINOR_VERSION) {
		printf("# %d: ERROR: minor version mismatch\n", me);
		err++;
	}

	printf("Hello, World from %d of %d\n", me, n_pes);

	return(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x1520
leaq 0x5dc3(%rip), %rax      # 0x713c
movl (%rax), %eax
movl %eax, -0x64(%rbp)
leaq 0x5db3(%rip), %rax      # 0x7138
movl (%rax), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1490
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x14f0
cmpl $0x0, -0x68(%rbp)
jne 0x13dd
leaq -0x60(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x3c4d(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x10f0
leaq 0x3c55(%rip), %rdi      # 0x501a
leaq 0x3c64(%rip), %rsi      # 0x5030
movl $0x1, %edx
movl $0x4, %ecx
movb $0x0, %al
callq 0x10f0
callq 0x1480
leaq -0x60(%rbp), %rdi
leaq 0x3c43(%rip), %rsi      # 0x5030
movl $0x40, %edx
callq 0x1070
cmpl $0x0, %eax
je 0x1416
movl -0x68(%rbp), %esi
leaq 0x3c5d(%rip), %rdi      # 0x5063
movb $0x0, %al
callq 0x10f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x18(%rbp)
je 0x1436
movl -0x68(%rbp), %esi
leaq 0x3c60(%rip), %rdi      # 0x5086
movb $0x0, %al
callq 0x10f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x4, -0x1c(%rbp)
je 0x1456
movl -0x68(%rbp), %esi
leaq 0x3c65(%rip), %rdi      # 0x50ab
movb $0x0, %al
callq 0x10f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x68(%rbp), %esi
movl -0x64(%rbp), %edx
leaq 0x3c6d(%rip), %rdi      # 0x50d0
movb $0x0, %al
callq 0x10f0
movl -0x14(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/shmem_info_get_name.c
// Function: shmem_info_get_name
SHMEM_SCOPE
void shmem_info_get_name(char *name)
{
	const char* vendor_string = SHMEM_VENDOR_STRING;
	char* tmp = (char*)vendor_string;
	while ((*tmp)) (*name++) = (*tmp++);
	*name = '\0'; // null terminate
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x3b91(%rip), %rax      # 0x5030
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x14d8
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x14ab
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/deoxysneq256128v13/ref/deoxys.c
// Function: set_nonce_in_tweak
static void set_nonce_in_tweak(uint8_t *tweak, const uint8_t *nonce) {
    tweak[0] = (tweak[0] & 0xf0)     ^ (nonce[0] >> 4);
    tweak[1] = (nonce[0] & 0xf) << 4 ^ (nonce[1] >> 4);
    tweak[2] = (nonce[1] & 0xf) << 4 ^ (nonce[2] >> 4);
    tweak[3] = (nonce[2] & 0xf) << 4 ^ (nonce[3] >> 4);
    tweak[4] = (nonce[3] & 0xf) << 4 ^ (nonce[4] >> 4);
    tweak[5] = (nonce[4] & 0xf) << 4 ^ (nonce[5] >> 4);
    tweak[6] = (nonce[5] & 0xf) << 4 ^ (nonce[6] >> 4);
    tweak[7] = (nonce[6] & 0xf) << 4 ^ (nonce[7] >> 4);
    tweak[8] = (nonce[7] & 0xf) << 4;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0xf0, %eax
movq -0x10(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rsp), %rax
movzbl 0x3(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x4(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rsp), %rax
movzbl 0x4(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x5(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rsp), %rax
movzbl 0x5(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x6(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rsp), %rax
movzbl 0x6(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movq -0x10(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
sarl $0x4, %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rsp), %rax
movzbl 0x7(%rax), %eax
andl $0xf, %eax
shll $0x4, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x8(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/main.c
// Function: main
int				main(int argc, char **argv, char **envp)
{
	t_shell shell;
	char	*line;
	char	*tmp;
	char	curr_pwd[1024];

	line = NULL;
	shell.stat_loc = 0;
	shell.instructions = NULL;
	shell.env = ft_strdup_matrix(envp);
	getcwd(curr_pwd, 1024);
	tmp = ft_strjoin("PWD=", curr_pwd);
	ft_export(&shell, tmp);
	free(tmp);
	handle_shlvl(&shell);
	tmp = ft_strdup("_=/bin/bash");
	ft_export(&shell, tmp);
	free(tmp);
	if (argc == 3 && ft_strcmp(argv[1], "-c"))
		exec_argument(ft_strdup(argv[2]), &shell);
	else
		read_input(line, &shell);
	return (shell.stat_loc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7120
movq %rax, -0x30(%rbp)
leaq -0x460(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1090
leaq -0x460(%rbp), %rsi
leaq 0x7dc6(%rip), %rdi      # 0x90c6
callq 0x8210
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq -0x60(%rbp), %rdi
callq 0x1030
leaq -0x50(%rbp), %rdi
callq 0x7810
leaq 0x7cd5(%rip), %rdi      # 0x9004
callq 0x8190
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x30c0
movq -0x60(%rbp), %rdi
callq 0x1030
cmpl $0x3, -0x8(%rbp)
jne 0x1389
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7cad(%rip), %rsi      # 0x9010
callq 0x8690
cmpq $0x0, %rax
je 0x1389
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8190
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x13b0
jmp 0x1396
movq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1430
movl -0x28(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/main.c
// Function: exec_argument
static void		exec_argument(char *line, t_shell *shell)
{
	char	*tmp;

	tmp = parse_input(line);
	free(line);
	if (tmp)
	{
		line = tmp;
		minishell(line, shell);
	}
	else
	{
		shell->stat_loc = 2;
	}
	clean_env(shell);
	clean_matrix(shell->instructions);
	free(shell->instructions);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x18(%rbp)
je 0x13f4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1860
jmp 0x13ff
movq -0x10(%rbp), %rax
movl $0x2, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x6fd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6f80
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/main.c
// Function: read_input
static void		read_input(char *line, t_shell *shell)
{
	char *tmp;
	int	 fd_out;

	fd_out = dup(1);
	signal(SIGQUIT, signal_handler_running);
	while (1)
	{
		signal(SIGINT, signal_handler_running);
		dup2(fd_out, 1);
		ft_putstr_fd("$:\\>", 1);
		if (get_next_line(&line) == 0)
		{
			ft_putendl_fd("exit", 1);
			clean_env(shell);
			free(line);
			exit(0);
		}
		tmp = parse_input(line);
		free(line);
		if (tmp)
		{
			line = tmp;
			minishell(line, shell);
		}
		else
			shell->stat_loc = 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0x1080
movl %eax, -0x1c(%rbp)
movl $0x3, %edi
leaq 0x5a17(%rip), %rsi      # 0x6e70
callq 0x1110
movl $0x2, %edi
leaq 0x5a06(%rip), %rsi      # 0x6e70
callq 0x1110
movl -0x1c(%rbp), %edi
movl $0x1, %esi
callq 0x1070
leaq 0x7e94(%rip), %rdi      # 0x9317
movl $0x1, %esi
callq 0x7de0
leaq -0x8(%rbp), %rdi
callq 0x6d80
cmpl $0x0, %eax
jne 0x14c5
leaq 0x7b71(%rip), %rdi      # 0x9013
movl $0x1, %esi
callq 0x7d80
movq -0x10(%rbp), %rdi
callq 0x6fd0
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1170
movq -0x8(%rbp), %rdi
callq 0x4c50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x18(%rbp)
je 0x14f9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1860
jmp 0x1504
movq -0x10(%rbp), %rax
movl $0x2, 0x28(%rax)
jmp 0x145e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell.c
// Function: get_path
char			*get_path(t_shell *shell)
{
	char *value;
	char *tmp;
	char *path;
	char **paths;

	value = get_env(shell, "PATH");
	if (!value || ft_strlen(value) == 0)
	{
		free(value);
		path = search_binary_in_pwd(shell);
	}
	else
	{
		tmp = append_pwd(value);
		paths = ft_split(tmp, ':');
		path = search_binary(shell, paths);
		free(value);
		free(tmp);
		clean_matrix(paths);
		free(paths);
	}
	return (path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7af1(%rip), %rsi      # 0x9018
callq 0x23f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1546
movq -0x10(%rbp), %rdi
callq 0x8550
cmpq $0x0, %rax
jne 0x155e
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x66a0
movq %rax, -0x20(%rbp)
jmp 0x15b2
movq -0x10(%rbp), %rdi
callq 0x1b30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x7e30
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x67d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x6f80
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell.c
// Function: run_command
int				run_command(t_shell *shell)
{
	pid_t	pid;
	char	*path;
	char	*tmp;

	shell->is_binary = 0;
	path = get_path(shell);
	if (path)
	{
		if ((pid = fork()) == 0 && check_permissions(shell, path))
		{
			execve(path, shell->args, shell->env);
			exit(shell->stat_loc);
		}
		signal(SIGINT, signal_handler_waiting);
		waitpid(pid, &shell->stat_loc, 0);
		if (WIFEXITED(shell->stat_loc))
			shell->stat_loc = WEXITSTATUS(shell->stat_loc);
		if (shell->stat_loc == -1)
			ft_putstr_fd("\n", 1);
		tmp = update_last_arg(shell->args);
		ft_export(shell, tmp);
		free(tmp);
	}
	free(path);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x1510
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16be
callq 0x1190
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x1633
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x76b0
cmpl $0x0, %eax
je 0x1633
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x10f0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x1170
movl $0x2, %edi
leaq 0x58a1(%rip), %rsi      # 0x6ee0
callq 0x1110
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
xorl %edx, %edx
callq 0x1150
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x167c
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
jne 0x1697
leaq 0x7990(%rip), %rdi      # 0x901d
movl $0x1, %esi
callq 0x7de0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1ae0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x30c0
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell.c
// Function: check_builtin
int				check_builtin(t_shell *shell)
{
	int		ret;
	char	*tmp;

	ret = 0;
	if (ft_strcmp(shell->args[0], "exit"))
		ft_exit(shell);
	else if (ft_strcmp(shell->args[0], "echo"))
		ret = ft_echo(shell->args + 1);
	else if (ft_strcmp(shell->args[0], "cd"))
		ret = ft_cd(shell);
	else if (ft_strcmp(*shell->args, "pwd"))
		ret = ft_pwd(shell);
	else if (ft_strcmp(*shell->args, "export"))
		ret = exec_export(shell);
	else if (ft_strcmp(*shell->args, "unset"))
		ret = ft_unset(shell);
	else
		return (exec_env(shell));
	tmp = update_last_arg(shell->args);
	ft_export(shell, tmp);
	free(tmp);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x790e(%rip), %rsi      # 0x9013
callq 0x8690
cmpq $0x0, %rax
je 0x171e
movq -0x10(%rbp), %rdi
callq 0x38a0
jmp 0x181b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x78ef(%rip), %rsi      # 0x901f
callq 0x8690
cmpq $0x0, %rax
je 0x1754
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x2bb0
movl %eax, -0x14(%rbp)
jmp 0x1819
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x78be(%rip), %rsi      # 0x9024
callq 0x8690
cmpq $0x0, %rax
je 0x1782
movq -0x10(%rbp), %rdi
callq 0x2600
movl %eax, -0x14(%rbp)
jmp 0x1817
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x7893(%rip), %rsi      # 0x9027
callq 0x8690
cmpq $0x0, %rax
je 0x17ad
movq -0x10(%rbp), %rdi
callq 0x2ca0
movl %eax, -0x14(%rbp)
jmp 0x1815
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x786c(%rip), %rsi      # 0x902b
callq 0x8690
cmpq $0x0, %rax
je 0x17d8
movq -0x10(%rbp), %rdi
callq 0x1d40
movl %eax, -0x14(%rbp)
jmp 0x1813
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
leaq 0x7848(%rip), %rsi      # 0x9032
callq 0x8690
cmpq $0x0, %rax
je 0x1803
movq -0x10(%rbp), %rdi
callq 0x2d30
movl %eax, -0x14(%rbp)
jmp 0x1811
movq -0x10(%rbp), %rdi
callq 0x1d90
movl %eax, -0x4(%rbp)
jmp 0x1848
jmp 0x1813
jmp 0x1815
jmp 0x1817
jmp 0x1819
jmp 0x181b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1ae0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x30c0
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell.c
// Function: minishell
void			minishell(char *line, t_shell *shell)
{
	size_t	it;
	size_t	jt;

	it = 0;
	line = safe_allocate(line, inject_spaces);
	if (validate_input(shell, line))
	{
		shell->instructions = ft_split_non_escaped(line, ';');
		while (shell->instructions[it])
		{
			jt = 0;
			shell->stat_loc = 0;
			while (is_space(shell->instructions[it][jt]))
				jt++;
			shell->commands = ft_split_non_escaped(&shell->instructions[it][jt],
					'|');
			handle_commands(shell);
			shell->previous_stat = shell->stat_loc;
			free(shell->commands);
			it++;
		}
	}
	free(line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x98d(%rip), %rsi       # 0x2210
callq 0x1cf0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x59a0
cmpl $0x0, %eax
je 0x1972
movq -0x8(%rbp), %rdi
movl $0x3b, %esi
callq 0x5520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1970
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x50d0
cmpw $0x0, %ax
je 0x1913
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x18e3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq -0x20(%rbp), %rdi
movl $0x7c, %esi
callq 0x5520
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1990
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x18ba
jmp 0x1972
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell.c
// Function: handle_commands
static void		handle_commands(t_shell *shell)
{
	char	*tmp;

	if (*(shell->commands + 1))
		find_pipes(shell);
	else if (shell->commands[0])
	{
		tmp = expansion(shell, shell->commands[0]);
		shell->args = get_args(tmp);
		shell->binary = ft_strdup(shell->args[0]);
		if (find_redirections(shell) != -1)
			if (shell->args[0] && !(check_builtin(shell)))
				run_command(shell);
		clean_matrix(shell->args);
		free(shell->args);
		free(tmp);
		free(shell->commands[0]);
		free(shell->binary);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x19b9
movq -0x8(%rbp), %rdi
callq 0x7390
jmp 0x1a89
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x1a87
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x4610
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4b60
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
callq 0x8190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x5fc0
cmpl $-0x1, %eax
je 0x1a47
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, (%rax)
je 0x1a45
movq -0x8(%rbp), %rdi
callq 0x16e0
cmpl $0x0, %eax
jne 0x1a45
movq -0x8(%rbp), %rdi
callq 0x15c0
jmp 0x1a47
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6f80
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
jmp 0x1a89
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: update_last_arg
char	*update_last_arg(char **args)
{
	int len;

	len = 0;
	while (args[len])
		len++;
	return (last_arg(args[len - 1]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1b0d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1af3
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1a90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: append_pwd
char	*append_pwd(char *value)
{
	char	cwd[1024];
	char	*aux;

	aux = value;
	if (getcwd(cwd, sizeof(cwd)))
	{
		if (value[0] == ':')
			return (ft_strjoin(cwd, value));
		if (value[ft_strlen(value) - 1] == ':')
			return (ft_strjoin(value, cwd));
		while (*aux)
		{
			if (!(aux = ft_strchr(aux, ':')))
				break ;
			if (*(aux + 1) == ':')
				return (ft_strjoin(value, cwd));
			aux++;
		}
	}
	return (ft_strdup(value));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1090
cmpq $0x0, %rax
je 0x1c35
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x1b8a
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8210
movq %rax, -0x8(%rbp)
jmp 0x1c42
movq -0x10(%rbp), %rax
movq %rax, -0x420(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x420(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x1bcb
movq -0x10(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x8210
movq %rax, -0x8(%rbp)
jmp 0x1c42
jmp 0x1bcd
movq -0x418(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1c33
movq -0x418(%rbp), %rdi
movl $0x3a, %esi
callq 0x8110
movq %rax, -0x418(%rbp)
cmpq $0x0, %rax
jne 0x1bf9
jmp 0x1c33
movq -0x418(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x1c1f
movq -0x10(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x8210
movq %rax, -0x8(%rbp)
jmp 0x1c42
movq -0x418(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x418(%rbp)
jmp 0x1bcd
jmp 0x1c35
movq -0x10(%rbp), %rdi
callq 0x8190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: to_lower
char	*to_lower(char *input)
{
	size_t	it;
	char	*output;
	char	*tmp;

	tmp = ft_strdup(input);
	output = calloc(1, ft_strlen(tmp));
	it = -1;
	while (tmp[++it])
	{
		output[it] = ft_tolower(tmp[it]);
	}
	free(tmp);
	output[it] = '\0';
	return (output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8550
movq %rax, %rsi
movl $0x1, %edi
callq 0x1100
movq %rax, -0x18(%rbp)
movq $-0x1, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x1cc5
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x8590
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x1c8b
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils.c
// Function: safe_allocate
char	*safe_allocate(char *line, char *(*f)(char *))
{
	char	*tmp;
	char	*aux;

	tmp = f(line);
	free(line);
	aux = ft_strdup(tmp);
	free(tmp);
	return (aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x8190
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: exec_export
int		exec_export(t_shell *shell)
{
	int ret;

	ret = 0;
	delete_environment(shell, "_", shell->env);
	ret = ft_export(shell, NULL);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x72d5(%rip), %rsi      # 0x903b
callq 0x22f0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x30c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: exec_env
int		exec_env(t_shell *shell)
{
	char	*lower;
	char	*path;
	char	*tmp;

	lower = to_lower(shell->args[0]);
	if (ft_strcmp(lower, "env"))
	{
		path = get_path(shell);
		tmp = ft_strjoin("_=", path);
		free(path);
		ft_export(shell, tmp);
		free(tmp);
		free(lower);
		return (ft_env(shell, shell->env));
	}
	free(lower);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
callq 0x1c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x729c(%rip), %rsi      # 0x9057
callq 0x8690
cmpq $0x0, %rax
je 0x1e25
movq -0x10(%rbp), %rdi
callq 0x1510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x725a(%rip), %rdi      # 0x9038
callq 0x8210
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x30c0
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x24a0
movl %eax, -0x4(%rbp)
jmp 0x1e35
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: get_var_key
char	*get_var_key(char *line, int it)
{
	int		i;
	int		k;
	char	*key;

	i = it;
	k = 0;
	while (i >= 0 && line[i] != '{')
		i--;
	if (!(key = malloc((it - i) * sizeof(char))))
		return (NULL);
	i++;
	while (i < it)
		key[k++] = line[i++];
	key[k] = '\0';
	return (key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jl 0x1e7c
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7b, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1e85
jmp 0x1e90
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e5c
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1eb6
movq $0x0, -0x8(%rbp)
jmp 0x1f07
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1ef3
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1ebf
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%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/vdedios[P]minishell/srcs/shell/shell_utils_2.c
// Function: contain_spaces
short	contain_spaces(char *value)
{
	while (*value)
	{
		if (*value == ' ')
			return (1);
		value++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1f53
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x1f45
movw $0x1, -0x2(%rbp)
jmp 0x1f59
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f28
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: add_space
char	*add_space(char *line, char *output, size_t *it, char redir)
{
	if (line[*it] == redir)
	{
		ft_strlcat(output, line, ft_strlen(output) + *it + 1);
		if (line[*it - 1] != ' ' && line[*it - 1] != redir)
			ft_strlcat(output, " ", ft_strlen(output) + 2);
		ft_strlcat(output, line + *it, ft_strlen(output) + 2);
		if (line[*it + 1] != ' ' && line[*it + 1] != redir)
			ft_strlcat(output, " ", ft_strlen(output) + 2);
		line = line + *it + 1;
		*it = -1;
	}
	return (line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x20ca
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rax
addq (%rax), %rdx
addq $0x1, %rdx
callq 0x8370
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x2023
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x2023
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq -0x38(%rbp), %rdi
movq %rax, %rdx
addq $0x2, %rdx
leaq 0x714f(%rip), %rsi      # 0x916d
callq 0x8370
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x2, %rdx
callq 0x8370
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x20ac
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0x20ac
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq -0x50(%rbp), %rdi
movq %rax, %rdx
addq $0x2, %rdx
leaq 0x70c6(%rip), %rsi      # 0x916d
callq 0x8370
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
addq (%rcx), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq $-0x1, (%rax)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: additional_spaces
size_t	additional_spaces(char *line)
{
	size_t	cont;
	size_t	it;

	it = -1;
	cont = 0;
	while (line[++it])
	{
		if (line[it] == '>' && line[it - 1] != ' ' && line[it - 1] != '>')
			cont++;
		if (line[it] == '>' && line[it + 1] != ' ')
			cont++;
		if (line[it] == '<' && line[it - 1] != ' ' && line[it - 1] != '<')
			cont++;
		if (line[it] == '<' && line[it + 1] != ' ')
			cont++;
	}
	return (cont);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x2207
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
jne 0x215d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x215d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
je 0x215d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3e, %eax
jne 0x218c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x218c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x21d3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x21d3
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
je 0x21d3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x2202
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x2202
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x20f8
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/shell/shell_utils_3.c
// Function: inject_spaces
char	*inject_spaces(char *line)
{
	size_t	it;
	size_t	cont;
	char	*output;

	it = -1;
	cont = additional_spaces(line);
	output = calloc(1, ft_strlen(line) + cont + 1);
	while (*line == ' ')
		line++;
	while (line[++it])
	{
		line = add_space(line, output, &it, '>');
		line = add_space(line, output, &it, '<');
	}
	ft_strlcat(output, line, line - output);
	return (output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8550
movq %rax, %rsi
addq -0x18(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x226d
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2253
jmp 0x226f
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
cmpb $0x0, 0x1(%rax,%rcx)
je 0x22bf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x3e, %ecx
callq 0x1f60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
movl $0x3c, %ecx
callq 0x1f60
movq %rax, -0x8(%rbp)
jmp 0x226f
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x8370
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: delete_environment
void			delete_environment(t_shell *shell, char *key, char **env)
{
	size_t	it;
	size_t	len;

	(void)shell;
	len = ft_strlen(key);
	it = 0;
	while (env[it])
	{
		if (ft_strncmp(key, env[it], len) == 0)
			break ;
		it++;
	}
	if (env[it])
	{
		free(env[it]);
		env[it] = NULL;
		it++;
		while (env[it])
		{
			env[it - 1] = env[it];
			it++;
		}
		env[it - 1] = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2356
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x85c0
cmpl $0x0, %eax
jne 0x2348
jmp 0x2356
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2319
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x23df
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x23cb
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2392
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: get_env
char			*get_env(t_shell *shell, char *arg)
{
	size_t it;
	size_t len;

	len = ft_strlen(arg);
	it = 0;
	while (shell->env[it])
	{
		if (!ft_strncmp(shell->env[it], arg, len))
			return (ft_strdup(ft_strchr(shell->env[it], '=') + 1));
		it++;
	}
	return (ft_strdup(""));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8550
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2484
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x85c0
cmpl $0x0, %eax
jne 0x2476
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x3d, %esi
callq 0x8110
movq %rax, %rdi
addq $0x1, %rdi
callq 0x8190
movq %rax, -0x8(%rbp)
jmp 0x2494
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2415
leaq 0x6b93(%rip), %rdi      # 0x901e
callq 0x8190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: ft_env
int				ft_env(t_shell *shell, char **args)
{
	size_t	it;
	char	**to_print_env;

	if (shell->args[1])
	{
		ft_putendl_fd("env: too many arguments", 1);
		return (1);
	}
	it = 0;
	to_print_env = args;
	sort_like_bash(to_print_env);
	while (to_print_env[it])
		ft_putendl_fd(to_print_env[it++], 1);
	ft_export(shell, "_=env");
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x24d9
leaq 0x6b77(%rip), %rdi      # 0x903d
movl $0x1, %esi
callq 0x7d80
movl $0x1, -0x4(%rbp)
jmp 0x253b
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2550
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2524
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x7d80
jmp 0x24f2
movq -0x10(%rbp), %rdi
leaq 0x6b26(%rip), %rsi      # 0x9055
callq 0x30c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/builtin/ft_env.c
// Function: sort_like_bash
static	void	sort_like_bash(char **env)
{
	size_t	it;
	char	*aux;

	it = 0;
	while (env[it])
	{
		if (!ft_strncmp(env[it], "PATH=", 5))
		{
			aux = env[it];
			env[it] = env[it + 1];
			env[it + 1] = aux;
			it++;
		}
		it++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x25ec
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x6ad5(%rip), %rsi      # 0x905b
movl $0x5, %edx
callq 0x85c0
cmpl $0x0, %eax
jne 0x25db
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2564
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/srcs/builtin/ft_cd/ft_cd.c
// Function: ft_cd
int		ft_cd(t_shell *shell)
{
	char	*path;
	char	*target;

	target = shell->args[1];
	if (!target || !ft_strncmp(target, "--", 3) || !ft_strncmp(target, "~", 2))
	{
		path = get_env(shell, "HOME");
		if (ft_strcmp(path, ""))
			return (home_not_exists(shell, path));
	}
	else if (!ft_strncmp(target, ".", 2) || !ft_strncmp(target, "", 1))
		path = get_env(shell, "PWD");
	else if (!ft_strncmp(target, "-", 2))
		path = get_env(shell, "OLDPWD");
	else if (shell->args[2] && *shell->args[2])
	{
		path = ft_strdup(target);
		if (shell->args[3])
			return (many_arguments(shell));
	}
	else
		path = ft_strdup(target);
	change_dir(path, shell);
	free(path);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2657
movq -0x20(%rbp), %rdi
leaq 0x6a33(%rip), %rsi      # 0x9061
movl $0x3, %edx
callq 0x85c0
cmpl $0x0, %eax
je 0x2657
movq -0x20(%rbp), %rdi
leaq 0x6a1c(%rip), %rsi      # 0x9064
movl $0x2, %edx
callq 0x85c0
cmpl $0x0, %eax
jne 0x269c
movq -0x10(%rbp), %rdi
leaq 0x6a04(%rip), %rsi      # 0x9066
callq 0x23f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x69a8(%rip), %rsi      # 0x901e
callq 0x8690
cmpq $0x0, %rax
je 0x2697
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x27b0
cwtl
movl %eax, -0x4(%rbp)
jmp 0x2799
jmp 0x277c
movq -0x20(%rbp), %rdi
leaq 0x69c4(%rip), %rsi      # 0x906b
movl $0x2, %edx
callq 0x85c0
cmpl $0x0, %eax
je 0x26d0
movq -0x20(%rbp), %rdi
leaq 0x695d(%rip), %rsi      # 0x901e
movl $0x1, %edx
callq 0x85c0
cmpl $0x0, %eax
jne 0x26e9
movq -0x10(%rbp), %rdi
leaq 0x6995(%rip), %rsi      # 0x9070
callq 0x23f0
movq %rax, -0x18(%rbp)
jmp 0x277a
movq -0x20(%rbp), %rdi
leaq 0x696e(%rip), %rsi      # 0x9062
movl $0x2, %edx
callq 0x85c0
cmpl $0x0, %eax
jne 0x2719
movq -0x10(%rbp), %rdi
leaq 0x695f(%rip), %rsi      # 0x906d
callq 0x23f0
movq %rax, -0x18(%rbp)
jmp 0x2778
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x2769
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2769
movq -0x20(%rbp), %rdi
callq 0x8190
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2767
movq -0x10(%rbp), %rdi
callq 0x2810
cwtl
movl %eax, -0x4(%rbp)
jmp 0x2799
jmp 0x2776
movq -0x20(%rbp), %rdi
callq 0x8190
movq %rax, -0x18(%rbp)
jmp 0x2778
jmp 0x277a
jmp 0x277c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2840
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)