LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted
int	lexer_quoted(const char *input, int *j, t_token *token)
{
	char c;

	c = input[*j];
	if (!ft_strappend(&(token->str), c))
		return (0);
	(*j)++;
	token->open_quote = 1;
	if (c == '\'')
	{
		token->id = S_QUOTE;
		return (lexer_quoted_single(input, c, j, token));
	}
	else
	{
		token->id = D_QUOTE;
		return (lexer_quoted_double(input, c, j, token));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movb (%rdi,%rax), %r12b
movsbl %r12b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0xa9d0
testl %eax, %eax
je 0x28fa
incl (%r14)
orb $0x1, 0x10(%rbx)
cmpb $0x27, %r12b
jne 0x2905
movl $0x8, 0x8(%rbx)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2924
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x9, 0x8(%rbx)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2997
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_single
int	lexer_quoted_single(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq (%rdx), %rax
movb (%rdi,%rax), %al
movl $0x1, %ebp
testb %al, %al
je 0x2972
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa9d0
testl %eax, %eax
je 0x2970
movslq (%r14), %rcx
leaq 0x1(%rcx), %rax
cmpb %r12b, (%r15,%rcx)
movl %eax, (%r14)
je 0x297d
movb (%r15,%rax), %al
testb %al, %al
jne 0x2947
jmp 0x2972
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27e0
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_quoted.c
// Function: lexer_quoted_double
int	lexer_quoted_double(const char *input, char c, int *j, t_token *token)
{
	while (input[*j])
	{
		if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		if (!token->esc_next && input[*j] == '\\' && lexer_jump_esc(j, token))
			continue;
		else if (!token->esc_next && input[*j] == c)
		{
			(*j)++;
			token->open_quote = 0;
			return (lexer_find_token(input, j, token));
		}
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq (%rdx), %rax
movb (%rdi,%rax), %al
movl $0x1, %ebp
testb %al, %al
je 0x2a0f
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa9d0
testl %eax, %eax
je 0x2a0d
testb $0x2, 0x10(%rbx)
jne 0x29e8
movslq (%r14), %rax
cmpb $0x5c, (%r15,%rax)
jne 0x29e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2897
testl %eax, %eax
jne 0x2a00
movb 0x10(%rbx), %al
testb $0x2, %al
jne 0x29f8
movslq (%r14), %rcx
cmpb %r12b, (%r15,%rcx)
je 0x2a1a
andb $-0x3, %al
movb %al, 0x10(%rbx)
incl (%r14)
movslq (%r14), %rax
movb (%r15,%rax), %al
testb %al, %al
jne 0x29ba
jmp 0x2a0f
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incl %ecx
movl %ecx, (%r14)
andb $-0x2, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, %eax
cmpq $0x0, (%rdx)
jne 0x2aac
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movsbl (%rdi,%rax), %esi
movq %rdx, %rdi
callq 0x2ae7
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x8609(%rip), %rdi      # 0xb080
callq 0xa47c
movslq (%r14), %rcx
testq %rax, %rax
je 0x2ab6
leal 0x1(%rcx), %eax
movl %eax, (%r14)
movb (%r15,%rcx), %al
leaq 0xe(%rsp), %rdi
movb %al, (%rdi)
movb $0x0, 0x1(%rdi)
callq 0xa4b4
movq %rax, %rcx
movq %rax, (%rbx)
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsbl (%r15,%rcx), %esi
leaq 0x85c2(%rip), %rdi      # 0xb084
callq 0xa47c
testq %rax, %rax
je 0x2ae3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2b17
xorl %eax, %eax
jmp 0x2aac
// File: /workspace/github_c_makefile_star2_O1/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:
movaps 0x8582(%rip), %xmm0     # 0xb070
movups %xmm0, -0x10(%rsp)
xorl %eax, %eax
testb %al, %al
jne 0x2b16
movb $0x28, %cl
leaq -0xe(%rsp), %rax
cmpb %sil, %cl
jne 0x2b0c
movsbl -0x1(%rax), %ecx
movl %ecx, 0x8(%rdi)
movb (%rax), %cl
addq $0x2, %rax
testb %cl, %cl
jne 0x2b00
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq (%rsi), %rax
movb (%rdi,%rax), %r13b
movsbl %r13b, %ebp
movq %rdx, %rdi
movl %ebp, %esi
callq 0xa9d0
xorl %ebx, %ebx
testl %eax, %eax
je 0x2b71
movslq (%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
cmpb %r13b, 0x1(%r12,%rax)
jne 0x2b6c
incl 0x8(%r14)
incl (%r15)
movq %r14, %rdi
movl %ebp, %esi
callq 0xa9d0
testl %eax, %eax
je 0x2b71
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_just_token.c
// Function: lexer_just_token
int	lexer_just_token(const char *input, int *j, t_token *token)
{
	while (input[*j] && (token->esc_next || input[*j] != ' '))
	{
		if (!token->esc_next && ft_strchr("\"\'", input[*j]))
			return (lexer_quoted(input, j, token));
		else if (!token->esc_next && ft_strchr("&<>()|;", input[*j]))
			return (1);
		else if (!token->esc_next && input[*j] == '\\')
		{
			token->esc_next = 1;
			if (!ft_strappend(&(token->str), input[*j]))
				return (0);
			(*j)++;
			continue;
		}
		else if (!ft_strappend(&(token->str), input[*j]))
			return (0);
		token->esc_next = 0;
		(*j)++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rsi), %rax
movb (%rdi,%rax), %al
movl $0x1, %ebx
testb %al, %al
je 0x2c68
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x84a6(%rip), %r13      # 0xb058
leaq 0x84a2(%rip), %rbp      # 0xb05b
movb 0x10(%r14), %cl
movl %ecx, %edx
andb $0x2, %dl
movl %eax, %esi
xorb $0x20, %sil
orb %dl, %sil
je 0x2c68
testb $0x2, %cl
jne 0x2bea
movsbl %al, %esi
movq %r13, %rdi
callq 0xa47c
testq %rax, %rax
jne 0x2c79
testb $0x2, 0x10(%r14)
jne 0x2c06
movslq (%r15), %rax
movsbl (%r12,%rax), %esi
movq %rbp, %rdi
callq 0xa47c
testq %rax, %rax
jne 0x2c68
movb 0x10(%r14), %al
testb $0x2, %al
jne 0x2c34
movslq (%r15), %rcx
cmpb $0x5c, (%r12,%rcx)
jne 0x2c34
orb $0x2, %al
movb %al, 0x10(%r14)
movslq (%r15), %rax
movsbl (%r12,%rax), %esi
movq %r14, %rdi
callq 0xa9d0
testl %eax, %eax
jne 0x2c4d
jmp 0x2c66
movslq (%r15), %rax
movsbl (%r12,%rax), %esi
movq %r14, %rdi
callq 0xa9d0
testl %eax, %eax
je 0x2c66
andb $-0x3, 0x10(%r14)
movslq (%r15), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
movb 0x1(%r12,%rax), %al
testb %al, %al
jne 0x2bb9
jmp 0x2c68
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28a4
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rsi), %rax
movsbl (%rdi,%rax), %edi
callq 0x9c08
testl %eax, %eax
je 0x2cdb
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
movq %rbx, %rdi
callq 0xa9d0
testl %eax, %eax
je 0x2d48
movslq (%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r14)
movsbl 0x1(%r15,%rax), %edi
jmp 0x2cac
movslq (%r14), %rax
movzbl (%r15,%rax), %eax
movl $0x1, %ebp
testb $-0x21, %al
je 0x2d4a
movsbl %al, %esi
leaq 0x8393(%rip), %rdi      # 0xb089
callq 0xa47c
testq %rax, %rax
jne 0x2d4a
movslq (%r14), %rax
movsbl (%r15,%rax), %esi
leaq 0x8380(%rip), %rdi      # 0xb08f
callq 0xa47c
testq %rax, %rax
je 0x2d57
movslq (%r14), %rax
xorl %ecx, %ecx
cmpb $0x3c, (%r15,%rax)
setne %cl
leal 0xa(,%rcx,2), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b17
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $-0x1, %ecx
je 0x2dae
movl 0x8(%rdi), %edx
addq $0x4, %rsi
cmpl %ecx, %edx
je 0x2daf
movl (%rsi), %ecx
addq $0x4, %rsi
cmpl $-0x1, %ecx
jne 0x2d9f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2df9
movl 0x2c(%rsi), %r8d
xorl %eax, %eax
xorl %ecx, %ecx
testl %r8d, %r8d
jne 0x2dfd
movq (%rdi), %r9
movl 0x8(%r9), %r9d
cmpl $0x7, %r9d
je 0x2ddb
cmpl $0x6, %r9d
jne 0x2ddd
incl %eax
jmp 0x2ddd
incl %ecx
cmpl %ecx, %eax
jge 0x2dee
movl $0x7, 0x2c(%rsi)
movl $0x7, %r8d
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2dbf
jmp 0x2dfd
xorl %ecx, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x2e20
movb 0x28(%rsi), %al
movl %eax, %ecx
orb $0x8, %cl
movb %cl, 0x28(%rsi)
movl 0x8(%rdx), %ecx
cmpl $0x1, %ecx
je 0x2e27
cmpl $0x6, %ecx
je 0x2e27
orb $0x18, %al
movb %al, 0x28(%rsi)
jmp 0x2e27
movl $0x1, %eax
je 0x2e29
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movups 0x8263(%rip), %xmm0     # 0xb0a4
movaps %xmm0, 0x10(%rsp)
movups 0x8247(%rip), %xmm0     # 0xb094
movaps %xmm0, (%rsp)
movabsq $-0xffffffff, %rax      # imm = 0xFFFFFFFF00000001
movq %rax, 0x20(%rsp)
testq %rdi, %rdi
je 0x2f01
movq %rdi, %r14
xorl %esi, %esi
movq %rsp, %r15
cmpl $0x0, 0x2c(%rbx)
jne 0x2f01
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2e89
movq (%rax), %r12
jmp 0x2e8c
xorl %r12d, %r12d
movq (%r14), %r13
cmpl $0x6, 0x8(%r13)
sete %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2ebd
movq %r13, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x304e
movl $0x6, %ecx
testl %eax, %eax
jne 0x2eee
cmpl $0x7, 0x8(%r13)
sete %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2ef1
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x304e
movl $0x7, %ecx
testl %eax, %eax
je 0x2ef1
movl %ecx, 0x2c(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2e71
xorl %eax, %eax
cmpl $0x0, 0x2c(%rbx)
sete %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/lexer_end.c
// Function: lexer_end
int		lexer_end(t_list *token_head, t_control *control)
{
	t_token	*last;

	if (token_head == NULL || (t_token *)(token_head->content) == NULL)
		return (0);
	last = (t_token *)(ft_lstlast(token_head)->content);
	if ((control->lexer_end.unexpected = lexer_forbidden_start(token_head)) ||
	(control->lexer_end.unexpected = lexer_forbidden_combo(token_head)))
		;
	else if (last->open_quote)
		control->lexer_end.quote = 1;
	else if (last->esc_next)
		control->lexer_end.backslash = 1;
	else if (last->id == AND_IF || last->id == PIPE || last->id == OR_IF)
		control->lexer_end.other = 1;
	else if (last->id == LESS || last->id == DLESS ||
			last->id == GREAT || last->id == DGREAT)
		control->lexer_end.unexpected = last->id;
	else if (ft_lstfind(token_head, (int	[]){LBRACE, RBRACE, -1},
			lexer_id_cmp) && !lexer_handle_braces(token_head, control, last))
		;
	else
		return (1);
	if (control->lexer_end.unexpected != 0)
		control->exit_status = (IS_APPLE ? 258 : 2);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2fdd
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x2fdd
movq %rsi, %rbx
movq %r14, %rdi
callq 0xa87c
movq (%rax), %r15
movq %r14, %rdi
callq 0x30a9
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jne 0x2fd0
movq %r14, %rdi
callq 0x3172
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jne 0x2fd0
movb 0x10(%r15), %al
testb $0x1, %al
jne 0x2fb6
testb $0x2, %al
jne 0x2fbc
movl 0x8(%r15), %eax
cmpl $0xd, %eax
ja 0x2fec
movl $0x3c00, %ecx           # imm = 0x3C00
btl %eax, %ecx
jae 0x2fc2
movl %eax, 0x2c(%rbx)
jmp 0x2fd0
orb $0x2, 0x28(%rbx)
jmp 0x2fd0
orb $0x4, 0x28(%rbx)
jmp 0x2fd0
movl $0x2c, %ecx
btl %eax, %ecx
jae 0x2fec
orb $0x1, 0x28(%rbx)
cmpl $0x0, 0x2c(%rbx)
je 0x2fdd
movl $0x2, 0x4(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x700000006, %rax      # imm = 0x700000006
leaq 0xc(%rsp), %rsi
movq %rax, (%rsi)
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
leaq -0x280(%rip), %rdx      # 0x2d8c
movq %r14, %rdi
callq 0xa8c8
movl $0x1, %ebp
testq %rax, %rax
je 0x2fdf
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2f18
testl %eax, %eax
jne 0x2fdf
jmp 0x2fd0
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
je 0x305a
movl 0x8(%rsi), %eax
cmpl 0x8(%rdi), %eax
je 0x307a
testq %rdx, %rdx
je 0x3074
pushq %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2d8c
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x307a
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x308b
movq (%rax), %rcx
jmp 0x308d
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x30a3
movq (%rdi), %rax
cmpl $0x1, 0x8(%rax)
jne 0x30a3
xorl %eax, %eax
cmpl $0x7, 0x8(%rcx)
je 0x30a8
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movups 0x8000(%rip), %xmm0     # 0xb0bc
movaps %xmm0, (%rsp)
movabsq $-0xfffffffb, %rax      # imm = 0xFFFFFFFF00000005
movq %rax, 0x10(%rsp)
movups 0x7ffe(%rip), %xmm0     # 0xb0d4
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $-0xfffffff9, %rax      # imm = 0xFFFFFFFF00000007
movq %rax, 0x10(%rsi)
movq (%rdi), %rdi
callq 0x2d8c
testl %eax, %eax
je 0x3162
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x310e
movq (%rax), %rcx
jmp 0x3110
xorl %ecx, %ecx
movq (%rbx), %rdi
testq %rcx, %rcx
je 0x3126
cmpl $0x1, 0x8(%rdi)
jne 0x3126
movb $0x1, %dl
cmpl $0x7, 0x8(%rcx)
je 0x3128
xorl %edx, %edx
testq %rax, %rax
sete %al
orb %dl, %al
jne 0x3151
movq %r14, %rsi
callq 0x2d8c
testl %eax, %eax
jne 0x3151
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq %r15, %rsi
callq 0x2d8c
testl %eax, %eax
je 0x315e
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3100
xorl %eax, %eax
jmp 0x3168
movq 0x8(%rbx), %rbx
movq (%rbx), %rax
movl 0x8(%rax), %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movups 0x7f89(%rip), %xmm0     # 0xb10c
movaps %xmm0, 0x40(%rsp)
movups 0x7f6d(%rip), %xmm0     # 0xb0fc
movaps %xmm0, 0x30(%rsp)
movups 0x7f51(%rip), %xmm0     # 0xb0ec
movaps %xmm0, 0x20(%rsp)
movups 0x7f75(%rip), %xmm0     # 0xb11c
movaps %xmm0, (%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x31f5
movq %rdi, %rbx
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2d8c
testl %eax, %eax
jne 0x31ec
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x31ec
movq (%rax), %rdi
movq %r15, %rsi
callq 0x2d8c
testl %eax, %eax
je 0x3202
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x31c5
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl 0x8(%rax), %ebp
jmp 0x31f5
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x325e
movq %rdi, %r14
leaq 0x8bda(%rip), %r15      # 0xbe01
movq (%r14), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x9f24
movq %r15, %rdi
movl $0x1, %esi
callq 0x9f24
movq (%r14), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x9e78
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x3227
movl $0x0, 0x4(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x32c7
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
callq 0x32f3
testq %rax, %rax
je 0x32d6
movq %rax, %r15
movq %rax, %rdi
callq 0xa894
testq %rax, %rax
je 0x32ce
movq %r14, %rdi
movq %rax, %rsi
callq 0xa7e4
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x3296
movq 0x8(%rsp), %rax
jmp 0x32e9
movq %r15, %rdi
callq 0x3374
leaq 0x97(%rip), %rsi        # 0x3374
leaq 0x8(%rsp), %rdi
callq 0xa820
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x3d, %esi
callq 0xa8fc
cmpl $-0x1, %eax
je 0x3364
movl %eax, %ebp
movl $0x18, %edi
callq 0xaa1c
testq %rax, %rax
je 0x3364
movq %rax, %rbx
movslq %ebp, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xa774
movq %rax, (%rbx)
testq %rax, %rax
je 0x335c
addq %r15, %r14
incq %r14
movq %r14, %rdi
callq 0xa5c8
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xa774
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x3366
movq %rbx, %rdi
callq 0x3374
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x33e9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq (%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x33de
callq 0xa5c8
cmpq %r15, %rax
jne 0x33de
movq (%r14), %rax
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xa5dc
testl %eax, %eax
je 0x33ed
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x33b4
jmp 0x33f4
xorl %ebx, %ebx
jmp 0x33f4
movq (%r14), %rax
movq 0x8(%rax), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x3450
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq (%r14), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3445
callq 0xa5c8
cmpq %r15, %rax
jne 0x3445
movq (%r14), %rax
movq (%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xa5dc
testl %eax, %eax
je 0x3454
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x341b
jmp 0x345b
xorl %ebx, %ebx
jmp 0x345b
movq (%r14), %rbx
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdx
leaq 0x7cac(%rip), %rdi      # 0xb130
movl $0x5, %esi
callq 0x339c
testq %rax, %rax
leaq 0x7e37(%rip), %rdi      # 0xb2cf
cmovneq %rax, %rdi
callq 0x9b54
leal 0x1(%rax), %edi
leaq 0x7c8b(%rip), %rax      # 0xb136
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
callq 0x9c94
xorl %ebp, %ebp
testq %rax, %rax
je 0x3500
leaq 0x7c73(%rip), %rdi      # 0xb13d
movq %rax, %rsi
movl $0x2, %edx
callq 0xa584
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3500
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x36cc
movq 0x8(%r15), %rdi
callq 0x2240
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x3562
movq %rdx, %rbx
movq %rsi, %r14
addq $0x10, %r14
leaq 0x7c0f(%rip), %r12      # 0xb144
movq %r12, %rsi
callq 0x3573
testl %eax, %eax
je 0x354a
movl $0x1, 0x4(%rbx)
jmp 0x3556
movq -0x8(%r14), %rsi
movq %r15, %rdi
callq 0x35b8
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x3535
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x35ff
movq %rsi, %rbx
movq %rdi, %r14
movq (%rcx), %rax
movq (%rax), %r15
movq %rbx, %rdi
callq 0xa5c8
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa5dc
movq (%r14), %r15
movq 0x8(%r15), %rcx
testl %eax, %eax
je 0x3605
addq $0x8, %r15
movq %r15, %r14
testq %rcx, %rcx
jne 0x35cb
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, (%r14)
movq (%r15), %rdi
callq 0x3374
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2240
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x365f
movl $0x1, %r15d
cmpb $0x2d, (%rdi)
jne 0x3665
incq %rdi
movl $0x6e, %esi
callq 0x9c20
testl %eax, %eax
je 0x3665
movq 0x8(%r14,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x363a
jmp 0x3665
movl $0x1, %r15d
movl %r15d, %eax
movq (%r14,%rax,8), %rdi
testq %rdi, %rdi
je 0x36a4
leaq (%r14,%rax,8), %r14
addq $0x8, %r14
movl $0x1, %esi
callq 0x9f24
cmpq $0x0, (%r14)
je 0x3698
movl $0x20, %edi
movl $0x1, %esi
callq 0x9e5c
movq (%r14), %rdi
addq $0x8, %r14
testq %rdi, %rdi
jne 0x3679
cmpl $0x1, %r15d
jne 0x36b9
movl $0xa, %edi
movl $0x1, %esi
callq 0x9e5c
movl $0x0, 0x4(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdx, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x36fb
movq %rbx, %rdx
callq 0x370a
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x3708
orb $0x1, (%rbx)
callq 0x2040
movl (%rax), %eax
movl %eax, 0x4(%rbx)
xorl %eax, %eax
jmp 0x3708
movq %rbx, %rsi
callq 0x3890
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl $0x0, 0x4(%rdx)
movq 0x8(%rsi), %rdi
movl $0x1, %ebx
testq %rdi, %rdi
je 0x37a7
movq %rdx, %r14
movq %rsi, %r15
addq $0x8, %r15
movq %r14, %rsi
callq 0x37b8
testq %rax, %rax
je 0x3796
movq %rax, %r13
movq (%r15), %rbp
movq %rbp, %rdi
callq 0xa5c8
movq (%r12), %rdx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3403
testq %rax, %rax
je 0x3784
movq %rax, %rbp
movq %rax, %rdi
callq 0xaa9c
movq %r13, %rdi
callq 0xa4b4
movq %rax, (%rbp)
testq %rax, %rax
jne 0x3796
jmp 0x37a5
movq (%r15), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3804
testl %eax, %eax
je 0x37a5
movq 0x8(%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x3737
jmp 0x37a7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x796d(%rip), %rsi      # 0xb136
callq 0x3573
testl %eax, %eax
je 0x37de
movl $0x1, 0x4(%r14)
xorl %eax, %eax
jmp 0x37fc
movq %rbx, %rdi
movl $0x3d, %esi
callq 0xa8fc
cmpl $-0x1, %eax
je 0x37da
cltq
addq %rbx, %rax
incq %rax
movb $0x0, -0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x18, %edi
callq 0xaa1c
xorl %ebx, %ebx
testq %rax, %rax
je 0x387a
movq %rax, %r14
movq %r13, %rdi
callq 0xa4b4
movq %rax, (%r14)
testq %rax, %rax
je 0x3872
movq %r12, %rdi
callq 0xa4b4
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x386a
movq %r14, %rdi
callq 0xa894
testq %rax, %rax
je 0x3886
movq %r15, %rdi
movq %rax, %rsi
callq 0xa7e4
movl $0x1, %ebx
jmp 0x387a
movq (%r14), %rdi
callq 0x2240
movq %r14, %rdi
callq 0x2240
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x3374
jmp 0x387a
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x4(%rsi)
movq (%rdi), %rdi
callq 0xa8b8
testl %eax, %eax
je 0x395a
movl %eax, %ebp
leaq 0x7efa(%rip), %r12      # 0xb7b8
movq (%rbx), %r14
xorl %r15d, %r15d
testq %r14, %r14
je 0x38f4
movq (%r14), %r13
cmpl $0x0, 0x10(%r13)
jne 0x38ee
testq %r15, %r15
je 0x38eb
movq (%r13), %rdi
movq (%r15), %rsi
callq 0xaa70
testl %eax, %eax
js 0x38eb
movq %r15, %r13
movq %r13, %r15
movq 0x8(%r14), %r14
jmp 0x38c4
testq %r15, %r15
je 0x3952
cmpl $0x0, 0x10(%r15)
jne 0x3952
leaq 0x7867(%rip), %rdi      # 0xb16e
movl $0x1, %esi
callq 0x9f24
movq (%r15), %rdi
movl $0x1, %esi
callq 0x9f24
leaq 0x7855(%rip), %rdi      # 0xb17a
movl $0x1, %esi
callq 0x9f24
movq 0x8(%r15), %rdi
movl $0x1, %esi
callq 0x9f24
movq %r12, %rdi
movl $0x1, %esi
callq 0x9e78
movl $0x1, 0x10(%r15)
decl %ebp
jne 0x38be
movq (%rbx), %rax
testq %rax, %rax
je 0x3972
movq (%rax), %rcx
movl $0x0, 0x10(%rcx)
movq 0x8(%rax), %rax
jmp 0x395d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x39d2
leaq 0x7946(%rip), %rdi      # 0xb2ea
callq 0xaa70
testl %eax, %eax
je 0x39d2
movq 0x8(%r14), %rsi
leaq 0x7bf0(%rip), %rdi      # 0xb5a8
callq 0xaa70
testl %eax, %eax
je 0x3a31
movq 0x8(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3ab9
jmp 0x39e4
leaq 0x77a4(%rip), %rdi      # 0xb17d
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3a5f
movl %eax, %ebp
testl %ebp, %ebp
je 0x3a11
callq 0x2040
movl (%rax), %edi
testl %edi, %edi
je 0x3a14
movq (%r14), %r15
movq 0x8(%r14), %r14
callq 0x2220
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2511
jmp 0x3a14
orb $0x1, (%rbx)
xorl %eax, %eax
testl %ebp, %ebp
setne %al
xorl %ecx, %ecx
cmpl $0x1, %ebp
setne %cl
movl %ecx, 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x774a(%rip), %rdi      # 0xb182
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3a5f
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x39e6
movq 0x78(%rbx), %rdi
movl $0x1, %ebp
movl $0x1, %esi
callq 0x9e78
jmp 0x39e6
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x76b4(%rip), %rdi      # 0xb185
movl $0x3, %esi
movq %r15, %rdx
callq 0x3403
movq %rax, %rbx
leaq 0x769a(%rip), %rdi      # 0xb182
movl $0x6, %esi
movq %r15, %rdx
callq 0x3403
movq %rax, %r15
movq %r12, %rdi
callq 0x20a0
cmpl $-0x1, %eax
je 0x3b4d
testq %r15, %r15
je 0x3b23
movq (%r15), %rdi
callq 0x2240
movq 0x78(%r14), %rdi
callq 0xa4b4
movq %rax, (%r15)
testq %rax, %rax
je 0x3b54
addq $0x78, %r14
movq %r14, %rdi
callq 0x3c87
xorl %ebp, %ebp
testl %eax, %eax
je 0x3b56
testq %rbx, %rbx
je 0x3b46
movq %rbx, %rdi
callq 0x3c87
testl %eax, %eax
je 0x3b56
movl $0x1, %ebp
jmp 0x3b56
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x3b56
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
callq 0x2080
testq %rax, %rax
je 0x3c3e
movq %rax, %rbx
movq %rax, %rdi
callq 0x2180
testq %rax, %rax
je 0x3c5d
movq %rax, %r13
movl $0x1, %r15d
leaq 0x78b6(%rip), %r14      # 0xb45c
leaq 0x7627(%rip), %r12      # 0xb1d4
testl %ebp, %ebp
jne 0x3bb8
cmpb $0x2e, 0x13(%r13)
je 0x3c10
leaq 0x760d(%rip), %rdi      # 0xb1cc
movl $0x1, %esi
callq 0x9f24
addq $0x13, %r13
movq %r13, %rdi
movl $0x1, %esi
callq 0x9f24
leaq 0x8069(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
callq 0x9f24
imull $0xaaaaaaab, %r15d, %eax # imm = 0xAAAAAAAB
incl %r15d
addl $0x2aaaaaaa, %eax       # imm = 0x2AAAAAAA
cmpl $0x55555555, %eax       # imm = 0x55555555
movq %r12, %rdi
cmovbq %r14, %rdi
movl $0x1, %esi
callq 0x9f24
movq %rbx, %rdi
callq 0x2180
movq %rax, %r13
testq %rax, %rax
jne 0x3bad
imull $0xaaaaaaab, %r15d, %eax # imm = 0xAAAAAAAB
addl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpl $0x55555555, %eax       # imm = 0x55555555
leaq 0x75a3(%rip), %rax      # 0xb1db
cmovbq %rax, %r14
jmp 0x3c64
leaq 0x7564(%rip), %rdi      # 0xb1a9
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
leaq 0x7577(%rip), %r14      # 0xb1db
movq %r14, %rdi
movl $0x1, %esi
callq 0x9f24
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/builtin_cd_utils.c
// Function: ft_getcwd
int		ft_getcwd(char **target)
{
	if (!(getcwd(*target, ft_strlen(*target))))
	{
		errno = 0;
		ft_free((void **)target);
		if (!(*target = getcwd(NULL, 0)))
			return (0);
	}
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0xa5c8
movq %r14, %rdi
movq %rax, %rsi
callq 0x2100
testq %rax, %rax
jne 0x3cd0
callq 0x2040
movl $0x0, (%rax)
movq %rbx, %rdi
callq 0xaa9c
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
callq 0x2100
movq %rax, (%rbx)
testq %rax, %rax
je 0x3cd6
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/builtin_exit.c
// Function: exit_builtin
int		exit_builtin(char **argv, t_control *control)
{
	int has_sign;

	control->quit = 1;
	if (control->parent_pid == getpid())
		ft_putendl_fd("exit", 2);
	if (!argv || !argv[1])
		return (1);
	has_sign = (argv[1][0] == '-' || argv[1][0] == '+' ? 1 : 0);
	if (!ft_isonly_ft(argv[1] + has_sign, ft_isdigit, 1))
	{
		ft_perror("exit", argv[1], "numeric argument required");
		control->exit_status = (IS_APPLE ? 255 : 2);
	}
	else if (ft_array_len(argv) >= 3)
	{
		ft_perror("exit", NULL, "too many arguments");
		control->quit = 0;
		control->exit_status = 1;
	}
	else
		control->exit_status = (unsigned char)ft_atoi(argv[1]);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
orb $0x1, (%rsi)
movl 0x8(%rsi), %ebp
callq 0x2070
cmpl %eax, %ebp
jne 0x3d2e
leaq 0x74b8(%rip), %rdi      # 0xb1dc
movl $0x2, %esi
callq 0x9e78
testq %r14, %r14
je 0x3dba
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3dba
movb (%rdi), %al
addb $-0x2b, %al
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %rdi
leaq 0x5eb5(%rip), %rsi      # 0x9c08
movl $0x1, %edx
callq 0x9c54
testl %eax, %eax
je 0x3d8d
movq %r14, %rdi
callq 0xa9b8
cmpl $0x3, %eax
jl 0x3dab
leaq 0x7467(%rip), %rdi      # 0xb1dc
leaq 0x747f(%rip), %rdx      # 0xb1fb
xorl %esi, %esi
callq 0x2511
andb $-0x2, (%rbx)
movl $0x1, %eax
jmp 0x3db7
movq 0x8(%r14), %rsi
leaq 0x7444(%rip), %rdi      # 0xb1dc
leaq 0x7442(%rip), %rdx      # 0xb1e1
callq 0x2511
movl $0x2, %eax
jmp 0x3db7
movq 0x8(%r14), %rdi
callq 0x9b54
movzbl %al, %eax
movl %eax, 0x4(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/input_root.c
// Function: input_root
t_list	*input_root(t_control *control)
{
	t_list *tokens_lst;

	control->ctrl_c = 0;
	control->term->prompt_ps1 = 1;
	if (!reset_prompts(control->env, control->term))
	{
		control->quit = 1;
		return (NULL);
	}
	if (!history_add_new_link(control))
	{
		control->quit = 1;
		return (NULL);
	}
	tokens_lst = input_root_assist_and_prompt(control);
	return (tokens_lst);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andb $-0x3, (%rdi)
movq 0x18(%rdi), %rsi
movl $0x1, 0x30(%rsi)
movq 0x20(%rdi), %rdi
callq 0x3fec
testl %eax, %eax
je 0x3df8
movq %rbx, %rdi
callq 0x59d7
testl %eax, %eax
je 0x3df8
movq %rbx, %rdi
popq %rbx
jmp 0x3dff
orb $0x1, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/input_root.c
// Function: input_root_assist_and_prompt
t_list	*input_root_assist_and_prompt(t_control *control)
{
	t_list *tokens_lst;

	tokens_lst = NULL;
	while (!tokens_lst && !control->quit && !control->ctrl_c \
			&& !control->lexer_end.unexpected)
	{
		if (!terminfo_load_win_size(control->term) && (control->quit = 1))
			break ;
		control->term->clipboard.highlight = 0;
		if (control->term->prompt_ps1)
			ft_putstr_fd(control->term->ps1, 2);
		else
			ft_putstr_fd(control->term->ps2, 2);
		if (!input_reset_term_struct(control))
			return (NULL);
		tokens_lst = input_reading_and_lexing(control);
		control->term->prompt_ps1 = 0;
		ft_free((void **)&(control->term->line));
	}
	if (control->lexer_end.unexpected)
		input_synthax_error(control, control->lexer_end.unexpected);
//	debug_tokens_list(tokens_lst);
	//ft_lstclear(&tokens_lst, del_token);
	return (tokens_lst);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
testb $0x3, (%rbx)
jne 0x3e75
cmpl $0x0, 0x2c(%rbx)
jne 0x3e75
movq 0x18(%rbx), %rdi
callq 0x4306
testl %eax, %eax
je 0x3e72
movq 0x18(%rbx), %rax
movl $0x0, 0x60(%rax)
xorl %ecx, %ecx
cmpl $0x0, 0x30(%rax)
sete %cl
movq 0x38(%rax,%rcx,8), %rdi
movl $0x2, %esi
callq 0x9f24
movq %rbx, %rdi
callq 0x3e94
testl %eax, %eax
je 0x3e86
movq %rbx, %rdi
callq 0x3ee4
movq %rax, %r14
movq 0x18(%rbx), %rdi
movl $0x0, 0x30(%rdi)
callq 0xaa9c
testq %r14, %r14
je 0x3e09
jmp 0x3e75
orb $0x1, (%rbx)
movl 0x2c(%rbx), %esi
testl %esi, %esi
je 0x3e89
movq %rbx, %rdi
callq 0x3f47
jmp 0x3e89
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/sources/input_root.c
// Function: input_reset_term_struct
int		input_reset_term_struct(t_control *control)
{
	if (!terminfo_cursor_get_pos(control, &(control->term->cursor_start)))
		return (0);
	control->term->cursor = control->term->cursor_start;
	control->term->prompt_len = control->term->cursor.x;
	control->term->inline_position = -1;
	control->term->line_len = 0;
	control->term->current_history_link = control->history->head;
	return (1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
addq $0x20, %rsi
callq 0x455c
testl %eax, %eax
je 0x3ee0
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%rbx), %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x48(%rax)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x58(%rax)
movl $0x1, %eax
jmp 0x3ee2
xorl %eax, %eax
popq %rbx
retq