LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator
int		lexer_operator(const char *input, int *j, t_token *token)
{
	if (token->str)
		return (1);
	lexer_set_operator_id(token, input[*j]);
	if (ft_strchr("();", input[*j]))
	{
		(*j)++;
		if (!(token->str = ft_strdup((char	[2]){input[*j - 1], '\0'})))
			return (0);
		return (1);
	}
	else if (ft_strchr("<>&|", input[*j]))
		return (lexer_operator2(input, j, token));
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2e1a
movl $0x1, -0x4(%rbp)
jmp 0x2ee0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x2ef0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe21b(%rip), %rdi      # 0x11063
callq 0xf8d0
cmpq $0x0, %rax
je 0x2ea0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
leaq -0x22(%rbp), %rdi
callq 0xf950
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x2e97
movl $0x0, -0x4(%rbp)
jmp 0x2ee0
movl $0x1, -0x4(%rbp)
jmp 0x2ee0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xe1b1(%rip), %rdi      # 0x11067
callq 0xf8d0
cmpq $0x0, %rax
je 0x2ed7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2f90
movl %eax, -0x4(%rbp)
jmp 0x2ee0
jmp 0x2ed9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_set_operator_id
void	lexer_set_operator_id(t_token *token, char c)
{
	int			i;
	char		(*op_ids)[2];

	op_ids = (char	[][2]){{'(', LBRACE}, {')', RBRACE},
	{'|', PIPE}, {'&', AND}, {';', SEMI}, {'<', LESS}, {'>', GREAT}, {0, 0}};
	i = -1;
	while (op_ids[++i][0])
		if (op_ids[i][0] == c)
			token->id = op_ids[i][1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x28, -0x28(%rbp)
movb $0x6, -0x27(%rbp)
movb $0x29, -0x26(%rbp)
movb $0x7, -0x25(%rbp)
movb $0x7c, -0x24(%rbp)
movb $0x2, -0x23(%rbp)
movb $0x26, -0x22(%rbp)
movb $0x4, -0x21(%rbp)
movb $0x3b, -0x20(%rbp)
movb $0x1, -0x1f(%rbp)
movb $0x3c, -0x1e(%rbp)
movb $0xa, -0x1d(%rbp)
movb $0x3e, -0x1c(%rbp)
movb $0xc, -0x1b(%rbp)
movb $0x0, -0x1a(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx,2)
je 0x2f8d
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx,2), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2f8b
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl 0x1(%rax,%rcx,2), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x2f4d
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_operator.c
// Function: lexer_operator2
int		lexer_operator2(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	if (input[*j] == c)
	{
		token->id++;
		(*j)++;
		if (!ft_strappend(&(token->str), c))
			return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x2fd0
movl $0x0, -0x4(%rbp)
jmp 0x302e
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3027
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
movsbl -0x21(%rbp), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x3025
movl $0x0, -0x4(%rbp)
jmp 0x302e
jmp 0x3027
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_token_or_indirection
int	lexer_token_or_indirection(const char *input, int *j, t_token *token)
{
	while (ft_isdigit(input[*j]))
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		(*j)++;
	}
	if (input[*j] && input[*j] != ' ')
	{
		if (ft_strchr("&()|;", input[*j]))
			return (1);
		else if (ft_strchr("<>", input[*j]))
			return (lexer_indirection(input, j, token));
		else
			return (lexer_just_token(input, j, token));
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %edi
callq 0xe9f0
cmpl $0x0, %eax
je 0x3273
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10460
cmpl $0x0, %eax
jne 0x3266
movl $0x0, -0x4(%rbp)
jmp 0x331d
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3224
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3316
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3316
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xddb7(%rip), %rdi      # 0x1106c
callq 0xf8d0
cmpq $0x0, %rax
je 0x32c9
movl $0x1, -0x4(%rbp)
jmp 0x331d
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xdd93(%rip), %rdi      # 0x11072
callq 0xf8d0
cmpq $0x0, %rax
je 0x3300
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3330
movl %eax, -0x4(%rbp)
jmp 0x331d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3040
movl %eax, -0x4(%rbp)
jmp 0x331d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_indirection
int	lexer_indirection(const char *input, int *j, t_token *token)
{
	if (input[*j] == '<')
		token->id = LESS;
	else
		token->id = GREAT;
	return (lexer_operator2(input, j, token));
}

// 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
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3c, %eax
jne 0x3365
movq -0x18(%rbp), %rax
movl $0xa, 0x8(%rax)
jmp 0x3370
movq -0x18(%rbp), %rax
movl $0xc, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2f90
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_id_cmp
int		lexer_id_cmp(t_token *token, int *id)
{
	while (*id != -1)
	{
		if (token->id == *id)
			return (0);
		id++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x33cb
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x33bd
movl $0x0, -0x4(%rbp)
jmp 0x33d2
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x339c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_braces_equal
int		lexer_braces_equal(t_list *tk_head, t_control *control, t_token *last)
{
	int		brace[2];

	brace[0] = 0;
	brace[1] = 0;
	while (tk_head && !control->lexer_end.unexpected)
	{
		if (((t_token *)tk_head->content)->id == LBRACE)
			brace[0]++;
		else if (((t_token *)tk_head->content)->id == RBRACE)
			brace[1]++;
		if (brace[0] < brace[1])
			control->lexer_end.unexpected = RBRACE;
		tk_head = tk_head->next;
	}
	if (brace[0] > brace[1])
	{
		control->lexer_end.brace = 1;
		if (last->id != SEMI && last->id != LBRACE)
			control->lexer_end.add_semi = 1;
	}
	else if (brace[0] == brace[1])
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x341a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3423
jmp 0x3474
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, 0x8(%rax)
jne 0x343b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3453
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x7, 0x8(%rax)
jne 0x3451
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3453
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3466
movq -0x18(%rbp), %rax
movl $0x7, 0x2c(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x33fe
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x34b2
movq -0x18(%rbp), %rax
movb 0x28(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x28(%rax)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x34b0
movq -0x20(%rbp), %rax
cmpl $0x6, 0x8(%rax)
je 0x34b0
movq -0x18(%rbp), %rax
movb 0x28(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0x28(%rax)
jmp 0x34c5
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x34c3
movl $0x1, -0x4(%rbp)
jmp 0x34cc
jmp 0x34c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_signs_near_braces
int		lexer_signs_near_braces(t_list *tk_head, t_control *control)
{
	t_token		*prev_tk;
	t_token		*curr_tk;
	t_token		*next_tk;
	int			*signs;

	signs = (int	[]){LESS, DLESS, GREAT, DGREAT, AND, AND_IF, \
		PIPE, OR_IF, SEMI, -1};
	prev_tk = NULL;
	while (tk_head && !control->lexer_end.unexpected)
	{
		curr_tk = (t_token *)tk_head->content;
		next_tk = (tk_head->next ? (t_token *)tk_head->next->content : NULL);
		if (curr_tk->id == LBRACE && prev_tk &&
			lexer_tk_notbeside(curr_tk, prev_tk, (int *)signs, 1))
			control->lexer_end.unexpected = LBRACE;
		else if (curr_tk->id == RBRACE && next_tk &&
				lexer_tk_notbeside(curr_tk, next_tk, (int *)signs, 1))
			control->lexer_end.unexpected = RBRACE;
		prev_tk = (t_token *)tk_head->content;
		tk_head = tk_head->next;
	}
	return (control->lexer_end.unexpected ? 0 : 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
leaq 0xdb7d(%rip), %rsi      # 0x11078
movl $0x28, %edx
callq 0x2160
leaq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x59(%rbp)
je 0x3531
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x353d
jmp 0x3602
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3564
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x356c
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0x356c
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x6, 0x8(%rax)
jne 0x35ad
cmpq $0x0, -0x18(%rbp)
je 0x35ad
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x1, %ecx
callq 0x3870
cmpl $0x0, %eax
je 0x35ad
movq -0x10(%rbp), %rax
movl $0x6, 0x2c(%rax)
jmp 0x35e6
movq -0x20(%rbp), %rax
cmpl $0x7, 0x8(%rax)
jne 0x35e4
cmpq $0x0, -0x28(%rbp)
je 0x35e4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x1, %ecx
callq 0x3870
cmpl $0x0, %eax
je 0x35e4
movq -0x10(%rbp), %rax
movl $0x7, 0x2c(%rax)
jmp 0x35e6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3515
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_handle_braces
int		lexer_handle_braces(t_list *tk_head, t_control *control, t_token *last)
{
	if (!lexer_signs_near_braces(tk_head, control))
		return (0);
	if (!lexer_braces_equal(tk_head, control, last))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34e0
cmpl $0x0, %eax
jne 0x364f
movl $0x0, -0x4(%rbp)
jmp 0x3675
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x33e0
cmpl $0x0, %eax
jne 0x366e
movl $0x0, -0x4(%rbp)
jmp 0x3675
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_tk_notbeside
int		lexer_tk_notbeside(t_token *curr, t_token *next, int *forbid, int self)
{
	if ((self && next->id == curr->id) ||
		(forbid && lexer_tk_id_chr(forbid, next)))
		return (0);
	return (1);
}

// 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)
cmpl $0x0, -0x24(%rbp)
je 0x389d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x38b6
cmpq $0x0, -0x20(%rbp)
je 0x38bf
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x38bf
movl $0x0, -0x4(%rbp)
jmp 0x38c6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start_no_exceptions
int		lexer_forbidden_start_no_exceptions(t_list *token)
{
	t_token *curr_tk;
	t_token *next_tk;

	curr_tk = token->content;
	next_tk = (token->next ? token->next->content : NULL);
	if (next_tk && curr_tk->id == SEMI && next_tk->id == RBRACE)
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x38ff
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3907
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3907
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3933
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x3933
movq -0x20(%rbp), %rax
cmpl $0x7, 0x8(%rax)
jne 0x3933
movl $0x0, -0x4(%rbp)
jmp 0x393a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_start
int		lexer_forbidden_start(t_list *tk_head)
{
	const int	*is_start = (int	[]){SEMI, LBRACE, PIPE, OR_IF, AND_IF, -1};
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND_IF, RBRACE, -1};

	if (lexer_tk_id_chr(forbidden, tk_head->content))
		return (((t_token *)tk_head->content)->id);
	while (tk_head)
	{
		if (lexer_forbidden_start_no_exceptions(tk_head))
			if (tk_head->next && lexer_tk_id_chr(is_start, tk_head->content) &&
					lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq 0xd74d(%rip), %rax      # 0x110a0
movq %rax, -0x30(%rbp)
movq 0xd74a(%rip), %rax      # 0x110a8
movq %rax, -0x28(%rbp)
movq 0xd747(%rip), %rax      # 0x110b0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xd73c(%rip), %rax      # 0x110b8
movq %rax, -0x50(%rbp)
movq 0xd739(%rip), %rax      # 0x110c0
movq %rax, -0x48(%rbp)
movq 0xd736(%rip), %rax      # 0x110c8
movq %rax, -0x40(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x39c2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3a3c
jmp 0x39c4
cmpq $0x0, -0x10(%rbp)
je 0x3a35
movq -0x10(%rbp), %rdi
callq 0x38d0
cmpl $0x0, %eax
je 0x3a27
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a25
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x3a25
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x3a25
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3a3c
jmp 0x3a27
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x39c4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/lexer_end2.c
// Function: lexer_forbidden_combo
int		lexer_forbidden_combo(t_list *tk_head)
{
	const int	*forbidden = (int	[]){SEMI, PIPE, OR_IF, AND, AND_IF, RBRACE,
		LBRACE, LESS, DLESS, GREAT, DGREAT, -1};
	const int	*matter = (int	[]){LESS, DLESS, GREAT, DGREAT, -1};

	while (tk_head)
	{
		if (lexer_tk_id_chr(matter, tk_head->content))
		{
			if (tk_head->next \
					&& lexer_tk_id_chr(forbidden, tk_head->next->content))
				return (((t_token *)tk_head->next->content)->id);
		}
		tk_head = tk_head->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
leaq 0xd669(%rip), %rsi      # 0x110d0
movl $0x30, %edx
callq 0x2160
leaq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xd680(%rip), %rax      # 0x11100
movq %rax, -0x64(%rbp)
movq 0xd67d(%rip), %rax      # 0x11108
movq %rax, -0x5c(%rbp)
movl 0xd67b(%rip), %eax      # 0x11110
movl %eax, -0x54(%rbp)
leaq -0x64(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b03
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x3af5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3af3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x3830
cmpl $0x0, %eax
je 0x3af3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b0a
jmp 0x3af5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3aa0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_env.c
// Function: env_builtin
int		env_builtin(t_list *env, t_control *control)
{
	while (env)
	{
		ft_putstr_fd(((t_env *)env->content)->label, 1);
		ft_putstr_fd("=", 1);
		ft_putendl_fd(((t_env *)env->content)->value, 1);
		env = env->next;
	}
	control->exit_status = 0;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3b7f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf020
leaq 0xd904(%rip), %rdi      # 0x11456
movl $0x1, %esi
callq 0xf020
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xef40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b30
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_env.c
// Function: env_build_linked_list
t_list	*env_build_linked_list(char **env)
{
	t_list	*lst_head;
	t_list	*lst_link;
	t_env	*env_struct;
	int		i;

	i = 0;
	lst_head = NULL;
	while (env[i])
	{
		if (!(env_struct = env_build(env[i])))
		{
			ft_lstclear(&lst_head, env_del_struct);
			return (NULL);
		}
		if (!(lst_link = ft_lstnew(env_struct)))
		{
			env_del_struct(env_struct);
			ft_lstclear(&lst_head, env_del_struct);
			return (NULL);
		}
		ft_lstadd_back(&lst_head, lst_link);
		i++;
	}
	return (lst_head);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3c54
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3c70
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3c03
leaq -0x18(%rbp), %rdi
leaq 0x14c(%rip), %rsi       # 0x3d40
callq 0x10090
movq $0x0, -0x8(%rbp)
jmp 0x3c5c
movq -0x28(%rbp), %rdi
callq 0x10180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3c39
movq -0x28(%rbp), %rdi
callq 0x3d40
leaq -0x18(%rbp), %rdi
leaq 0x116(%rip), %rsi       # 0x3d40
callq 0x10090
movq $0x0, -0x8(%rbp)
jmp 0x3c5c
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xfff0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3bbb
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/charMstr[P]minishell/sources/builtin_env.c
// Function: env_build
t_env	*env_build(char *str)
{
	int		i;
	t_env	*new;

	if ((i = ft_strichr(str, '=')) == -1)
		return (NULL);
	if (!(new = env_init_struct()))
		return (NULL);
	if (!(new->label = ft_substr(str, 0, i++)) ||
		!(new->value = ft_substr(str + i, 0, ft_strlen(str + i))))
	{
		env_del_struct(new);
		return (NULL);
	}
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x10280
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x3c9f
movq $0x0, -0x8(%rbp)
jmp 0x3d34
callq 0x3d80
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3cb8
movq $0x0, -0x8(%rbp)
jmp 0x3d34
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rdx
xorl %esi, %esi
callq 0xff10
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x3d19
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0xfb10
movq -0x28(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0xff10
movq -0x20(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x3d2c
movq -0x20(%rbp), %rdi
callq 0x3d40
movq $0x0, -0x8(%rbp)
jmp 0x3d34
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_env.c
// Function: env_get
char	*env_get(char *str, size_t len, t_list *env)
{
	while (env)
	{
		if (((t_env*)env->content)->label)
		{
			if (ft_strlen(((t_env*)env->content)->label) == len \
					&& !ft_strncmp(str, ((t_env*)env->content)->label, len))
				return (((t_env*)env->content)->value);
		}
		env = env->next;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3e3a
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x3e2c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfb10
cmpq -0x18(%rbp), %rax
jne 0x3e2a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xfb60
cmpl $0x0, %eax
jne 0x3e2a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e42
jmp 0x3e2c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3dd4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_env.c
// Function: env_get_addr
char	**env_get_addr(char *str, size_t len, t_list *env)
{
	while (env)
	{
		if (((t_env *)env->content)->label)
		{
			if (ft_strlen(((t_env *)env->content)->label) == len \
					&& !ft_strncmp(str, ((t_env *)env->content)->label, len))
				return (&((t_env *)env->content)->value);
		}
		env = env->next;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3eca
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x3ebc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xfb10
cmpq -0x18(%rbp), %rax
jne 0x3eba
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xfb60
cmpl $0x0, %eax
jne 0x3eba
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3ed2
jmp 0x3ebc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3e64
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_env.c
// Function: env_shlvl_update
int		env_shlvl_update(t_list **env, t_control *control)
{
	int		shlvl;
	char	*nbr;
	char	*argv[3];

	if (!(nbr = env_get("SHLVL", 5, *env)))
		nbr = "0";
	shlvl = ft_atoi(nbr) + 1;
	argv[0] = "export";
	argv[1] = NULL;
	argv[2] = NULL;
	if (!(nbr = ft_itoa(shlvl)) ||
		!(argv[1] = ft_strjoin_free("SHLVL=", nbr, 2)))
		return (0);
	export_builtin(env, argv, control);
	free(argv[1]);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd216(%rip), %rdi      # 0x11114
movl $0x5, %esi
callq 0x3dc0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3f1d
leaq 0xd364(%rip), %rax      # 0x1127d
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe7e0
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0xd1e7(%rip), %rax      # 0x1111a
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x1c(%rbp), %edi
callq 0xeb70
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3f78
movq -0x28(%rbp), %rsi
leaq 0xd1bd(%rip), %rdi      # 0x11121
movl $0x2, %edx
callq 0xfab0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x3f81
movl $0x0, -0x4(%rbp)
jmp 0x3fa2
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4250
movq -0x38(%rbp), %rdi
callq 0x2230
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_unset.c
// Function: unset_builtin
int		unset_builtin(t_list **env_head, char **argv, t_control *control)
{
	int i;

	i = 1;
	while (argv[i])
	{
		if (!is_identifier_valid(argv[i], "unset"))
			unset_in_env_list(env_head, argv[i]);
		else
			control->exit_status = 1;
		i++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4024
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xd13b(%rip), %rsi      # 0x11128
callq 0x4030
cmpl $0x0, %eax
jne 0x400e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4090
jmp 0x4019
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3fcb
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_unset.c
// Function: is_identifier_valid
int		is_identifier_valid(char *identifier, char *command)
{
	if (!identifier[0] || ft_stristr(identifier, "@~%^*+=\\/?,.") == 0)
	{
		ft_perror(command, identifier, "not a valid identifier");
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x405e
movq -0x10(%rbp), %rdi
leaq 0xd0da(%rip), %rsi      # 0x1112e
callq 0x10370
cmpl $0x0, %eax
jne 0x407b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0xd0ce(%rip), %rdx      # 0x1113b
callq 0x2620
movl $0x1, -0x4(%rbp)
jmp 0x4082
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_unset.c
// Function: unset_in_env_list
void	unset_in_env_list(t_list **env_head, char *str)
{
	t_list **ptr;
	t_list *extra;

	ptr = env_head;
	while (*ptr)
	{
		if (!ft_strncmp(str, ((t_env*)((*ptr)->content))->label, \
					ft_strlen(str) + 1))
		{
			extra = *ptr;
			*ptr = (*ptr)->next;
			env_del_struct(extra->content);
			free(extra);
			return ;
		}
		ptr = &(*ptr)->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4139
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfb10
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0xfb60
cmpl $0x0, %eax
jne 0x4125
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3d40
movq -0x20(%rbp), %rdi
callq 0x2230
jmp 0x4139
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x40a8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_echo.c
// Function: echo_builtin
int	echo_builtin(char **argv, t_control *control)
{
	int i;
	int n_option;

	i = 1;
	while (argv[i] && argv[i][0] == '-' && ft_isonly(argv[i] + 1, 'n'))
		i++;
	n_option = (i == 1 ? 0 : 1);
	while (argv[i])
	{
		ft_putstr_fd(argv[i], 1);
		if (argv[++i])
			ft_putchar_fd(' ', 1);
	}
	if (!n_option)
		ft_putchar_fd('\n', 1);
	control->exit_status = 0;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
cmpq $0x0, (%rcx,%rdx,8)
movb %al, -0x19(%rbp)
je 0x41a7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x19(%rbp)
jne 0x41a7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
movl $0x6e, %esi
callq 0xea50
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x41b0
jmp 0x41bb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4157
movl -0x14(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x421b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0xf020
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4219
movl $0x20, %edi
movl $0x1, %esi
callq 0xef10
jmp 0x41ce
cmpl $0x0, -0x18(%rbp)
jne 0x4230
movl $0xa, %edi
movl $0x1, %esi
callq 0xef10
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin
int		export_builtin(t_list **head, char **argv, t_control *control)
{
	if (argv[1] == NULL)
		export_builtin_no_arg(head, control);
	else if (!export_builtin2(head, argv, control))
	{
		control->quit = 1;
		control->exit_status = errno;
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x427e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4560
jmp 0x42bb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x42d0
cmpl $0x0, %eax
jne 0x42b9
movq -0x20(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
callq 0x2040
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x42c2
jmp 0x42bb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin2
int		export_builtin2(t_list **head, char **argv, t_control *control)
{
	int		i;
	char	**str_addr;
	char	*sep2;

	i = 1;
	control->exit_status = 0;
	while (argv[i])
	{
		if (!(sep2 = export_builtin_check_label(argv[i], control)))
		{
			i++;
			continue;
		}
		if ((str_addr = env_get_addr(argv[i], ft_strlen(argv[i]), *head)))
		{
			ft_free((void **)str_addr);
			if (!(*str_addr = ft_strdup(sep2)))
				return (0);
		}
		else if (!export_builtin_new_env(argv[i], sep2, head))
			return (0);
		i++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x43d2
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x43f0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x4333
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x42f6
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xfb10
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x3e50
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x439b
movq -0x30(%rbp), %rdi
callq 0x10600
movq -0x38(%rbp), %rdi
callq 0xf950
movq -0x30(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4399
movl $0x0, -0x4(%rbp)
jmp 0x43d9
jmp 0x43c4
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4480
cmpl $0x0, %eax
jne 0x43c2
movl $0x0, -0x4(%rbp)
jmp 0x43d9
jmp 0x43c4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x42f6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin_check_label
char	*export_builtin_check_label(char *str, t_control *control)
{
	int i;

	if (is_identifier_valid(str, "export"))
	{
		control->exit_status = 1;
		return (NULL);
	}
	if ((i = ft_strichr(str, '=')) == -1)
		return (NULL);
	str[i] = '\0';
	return (str + i + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcd0f(%rip), %rsi      # 0x1111a
callq 0x4030
cmpl $0x0, %eax
je 0x442a
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x4469
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
callq 0x10280
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x444a
movq $0x0, -0x8(%rbp)
jmp 0x4469
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %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/charMstr[P]minishell/sources/builtin_export.c
// Function: export_builtin_new_env
int		export_builtin_new_env(char *str, char *str2, t_list **head)
{
	t_env	*env;
	t_list	*new_link;

	if (!(env = ft_memalloc(sizeof(t_env))))
		return (0);
	if (!(env->label = ft_strdup(str)))
	{
		free(env);
		return (0);
	}
	if (!(env->value = ft_strdup(str2)))
	{
		free(env->label);
		free(env);
		return (0);
	}
	if (!(new_link = ft_lstnew(env)))
	{
		env_del_struct(env);
		return (0);
	}
	ft_lstadd_back(head, new_link);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0x104f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x44b4
movl $0x0, -0x4(%rbp)
jmp 0x454a
movq -0x10(%rbp), %rdi
callq 0xf950
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x44dc
movq -0x28(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0x454a
movq -0x18(%rbp), %rdi
callq 0xf950
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x4511
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x2230
movq -0x28(%rbp), %rdi
callq 0x2230
movl $0x0, -0x4(%rbp)
jmp 0x454a
movq -0x28(%rbp), %rdi
callq 0x10180
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4536
movq -0x28(%rbp), %rdi
callq 0x3d40
movl $0x0, -0x4(%rbp)
jmp 0x454a
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfff0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export2.c
// Function: export_builtin_no_arg
void		export_builtin_no_arg(t_list **head, t_control *control)
{
	const t_list	*env = *head;
	t_env			*tmp;
	t_env			*sort;
	int				list_size;

	control->exit_status = 0;
	list_size = ft_lstsize(*head);
	while (list_size--)
	{
		env = *head;
		sort = NULL;
		while (env)
		{
			tmp = env->content;
			if (tmp->tmpdeclare == 0 && alpha_cmp(tmp, sort) < 0)
				sort = tmp;
			env = env->next;
		}
		if (sort && sort->tmpdeclare == 0)
		{
			export_no_arg_display(sort);
			sort->tmpdeclare = 1;
		}
	}
	export_builtin_no_arg_end(*head);
}

// 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 -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x101e0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x462a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4600
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x45f2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4640
cmpl $0x0, %eax
jge 0x45f2
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x45bc
cmpq $0x0, -0x28(%rbp)
je 0x4625
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x4625
movq -0x28(%rbp), %rdi
callq 0x4690
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x4595
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4700
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export2.c
// Function: alpha_cmp
static int	alpha_cmp(const t_env *const s1, const t_env *const s2)
{
	int cmp;

	if (!s2)
		return (-1);
	cmp = ft_strcmp(s1->label, s2->label);
	return (cmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4660
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x467c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x10580
movl %eax, -0x1c(%rbp)
movl -0x1c(%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/charMstr[P]minishell/sources/builtin_export2.c
// Function: export_no_arg_display
static void	export_no_arg_display(const t_env *env)
{
	const char		*str = "declare -x ";

	ft_putstr_fd((char *)str, 1);
	ft_putstr_fd(env->label, 1);
	ft_putstr_fd("=\"", 1);
	ft_putstr_fd(env->value, 1);
	ft_putendl_fd("\"", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xcaaf(%rip), %rax      # 0x11152
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf020
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf020
leaq 0xca91(%rip), %rdi      # 0x1115e
movl $0x1, %esi
callq 0xf020
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xf020
leaq 0xd069(%rip), %rdi      # 0x11759
movl $0x1, %esi
callq 0xef40
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_export2.c
// Function: export_builtin_no_arg_end
static void	export_builtin_no_arg_end(t_list const *env)
{
	t_env	*tmp;

	while (env)
	{
		tmp = env->content;
		tmp->tmpdeclare = 0;
		env = env->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4733
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4708
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_cd.c
// Function: cd_builtin
int		cd_builtin(t_list *env, char **argv, t_control *control)
{
	int ret;

	if (!argv[1] || !ft_strcmp("~", argv[1]))
		ret = cd_special("HOME", env, control);
	else if (!ft_strcmp("-", argv[1]))
	{
		if ((ret = cd_special("OLDPWD", env, control)) == 1)
			ft_putendl_fd(control->cwd, STDOUT_FILENO);
	}
	else
		ret = ft_chdir(argv[1], env, control);
	if (ret == 0)
		control->quit = 1;
	else if (errno)
		ft_perror(argv[0], argv[1], strerror(errno));
	control->exit_status = (ret == 1 ? 0 : 1);
	return (ret == 0 ? 0 : 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4778
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb2a(%rip), %rdi      # 0x11298
callq 0x10580
cmpl $0x0, %eax
jne 0x4791
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xc9da(%rip), %rdi      # 0x11161
callq 0x4880
movl %eax, -0x1c(%rbp)
jmp 0x47f4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcd28(%rip), %rdi      # 0x114c8
callq 0x10580
cmpl $0x0, %eax
jne 0x47da
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xc9ad(%rip), %rdi      # 0x11166
callq 0x4880
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
jne 0x47d8
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
movl $0x1, %esi
callq 0xef40
jmp 0x47f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4900
movl %eax, -0x1c(%rbp)
jmp 0x47f4
cmpl $0x0, -0x1c(%rbp)
jne 0x480a
movq -0x18(%rbp), %rax
movb (%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, (%rax)
jmp 0x4849
callq 0x2040
cmpl $0x0, (%rax)
je 0x4847
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x2040
movl (%rax), %edi
callq 0x2210
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2620
jmp 0x4849
movl -0x1c(%rbp), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x1, %edx
cmovel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_cd.c
// Function: cd_special
int		cd_special(char *envdir, t_list *env, t_control *control)
{
	char *dir;

	if (!(dir = env_get(envdir, ft_strlen(envdir), env)))
	{
		ft_perror("cd", envdir, "environment variable not set");
		return (-1);
	}
	return (ft_chdir(dir, env, control));
}

// 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, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfb10
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3dc0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x48df
movq -0x10(%rbp), %rsi
leaq 0xc8a3(%rip), %rdi      # 0x1116d
leaq 0xc89f(%rip), %rdx      # 0x11170
callq 0x2620
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x48f3
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4900
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_cd.c
// Function: ft_chdir
int		ft_chdir(char *target_dir, t_list *env, t_control *control)
{
	char	**oldpwd;
	char	**pwd_env;

	pwd_env = env_get_addr("PWD", 3, env);
	oldpwd = env_get_addr("OLDPWD", 6, env);
	if (chdir(target_dir) == -1)
		return (-1);
	if (oldpwd)
	{
		free(*oldpwd);
		if (!(*oldpwd = ft_strdup(control->cwd)))
			return (0);
	}
	if (!(ft_getcwd(&control->cwd)))
		return (0);
	if (pwd_env && ft_getcwd(pwd_env) == 0)
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdx
leaq 0xc84a(%rip), %rdi      # 0x11169
movl $0x3, %esi
callq 0x3e50
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
leaq 0xc82e(%rip), %rdi      # 0x11166
movl $0x6, %esi
callq 0x3e50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
cmpl $-0x1, %eax
jne 0x495d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x49d5
cmpq $0x0, -0x28(%rbp)
je 0x4995
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x2230
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0xf950
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x4993
movl $0x0, -0x4(%rbp)
jmp 0x49d5
jmp 0x4995
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x4af0
cmpl $0x0, %eax
jne 0x49b0
movl $0x0, -0x4(%rbp)
jmp 0x49d5
cmpq $0x0, -0x30(%rbp)
je 0x49ce
movq -0x30(%rbp), %rdi
callq 0x4af0
cmpl $0x0, %eax
jne 0x49ce
movl $0x0, -0x4(%rbp)
jmp 0x49d5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/sources/builtin_cd_utils.c
// Function: ft_ls
void	ft_ls(char *directory, int showdot)
{
	struct dirent	*reader;
	DIR				*dir;
	int				i;

	i = 1;
	if (!(dir = opendir(directory)))
	{
		printf("Couldn't read this directory (%s)\n", directory);
		return ;
	}
	while ((reader = readdir(dir)) != NULL)
	{
		if (!(showdot == 0 && reader->d_name[0] == '.'))
		{
			ft_putstr_fd("\033[0;93m", 1);
			ft_putstr_fd(reader->d_name, 1);
			ft_putstr_fd("\033[0m", 1);
			ft_putstr_fd((i++ % 3 != 0 ? "     \t\t" : "\n"), 1);
		}
	}
	ft_putstr_fd(((i - 1) % 3 == 0 ? "" : "\n"), 1);
	closedir(dir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2070
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4a20
movq -0x8(%rbp), %rsi
leaq 0xc779(%rip), %rdi      # 0x1118d
movb $0x0, %al
callq 0x20b0
jmp 0x4ae9
jmp 0x4a22
movq -0x20(%rbp), %rdi
callq 0x2170
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4ab3
cmpl $0x0, -0xc(%rbp)
jne 0x4a48
movq -0x18(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
je 0x4aae
leaq 0xc761(%rip), %rdi      # 0x111b0
movl $0x1, %esi
callq 0xf020
movq -0x18(%rbp), %rdi
addq $0x13, %rdi
movl $0x1, %esi
callq 0xf020
leaq 0xd19f(%rip), %rdi      # 0x11c11
movl $0x1, %esi
callq 0xf020
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl $0x3, %ecx
cltd
idivl %ecx
leaq 0xc8e6(%rip), %rdi      # 0x1137c
leaq 0xc71b(%rip), %rax      # 0x111b8
cmpl $0x0, %edx
cmovneq %rax, %rdi
movl $0x1, %esi
callq 0xf020
jmp 0x4a22
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl $0x3, %ecx
cltd
idivl %ecx
leaq 0xc8b4(%rip), %rdi      # 0x1137c
leaq 0xc6f0(%rip), %rax      # 0x111bf
cmpl $0x0, %edx
cmoveq %rax, %rdi
movl $0x1, %esi
callq 0xf020
movq -0x20(%rbp), %rdi
callq 0x2110
addq $0x30, %rsp
popq %rbp
retq
nop