LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/list_to_cmd_assist.c
// Function: list_to_cmd_fill_redirections_fields2
int		list_to_cmd_fill_redirections_fields2(t_simple_cmd *cmd, int id, \
		t_list *tokens)
{
	t_arrow	*arrow;
	t_list	*new;
	char	**tmp;

	if (!(arrow = init_t_arrow()))
		return (0);
	tmp = &((t_token *)tokens->next->content)->str;
	arrow->dest = *tmp;
	*tmp = NULL;
	tmp = &((t_token *)tokens->content)->str;
	arrow->src = *tmp;
	*tmp = NULL;
	arrow->id = id;
	if (!(new = ft_lstnew(arrow)))
	{
		free_t_arrow(arrow);
		return (0);
	}
	ft_lstadd_back(&cmd->arrows, new);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
callq 0x873a
xorl %ebx, %ebx
testq %rax, %rax
je 0x872f
movq %rax, %r15
movq 0x8(%r12), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%r15)
andq $0x0, (%rax)
movq (%r12), %rax
movq (%rax), %rcx
movq %rcx, (%r15)
andq $0x0, (%rax)
movl %ebp, 0x10(%r15)
movq %r15, %rdi
callq 0x9e58
testq %rax, %rax
je 0x8727
movq %r14, %rdi
movq %rax, %rsi
callq 0x9dac
pushq $0x1
popq %rbx
jmp 0x872f
movq %r15, %rdi
callq 0x875b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/list_to_cmd_assist.c
// Function: free_t_arrow
void	free_t_arrow(void *void_arrow)
{
	t_arrow *arrow;

	if ((arrow = (t_arrow *)void_arrow) == NULL)
		return ;
	free(arrow->dest);
	free(arrow->src);
	free(arrow);
}

// Assembly:
testq %rdi, %rdi
je 0x877e
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2230
movq (%rbx), %rdi
callq 0x2230
movq %rbx, %rdi
popq %rbx
jmp 0x2230
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/signal_handler.c
// Function: ft_sigquit
void	ft_sigquit(int sig)
{
	ft_putstr_fd("Quit : ", 2);
	ft_putnbr_fd(sig, 2);
	ft_putchar_fd('\n', 2);
	g_sig = SIGCAUGHT + sig;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2cdd(%rip), %rdi      # 0xb469
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x9668
movl %ebx, %edi
movl %ebp, %esi
callq 0x95f0
pushq $0xa
popq %rdi
movl %ebp, %esi
callq 0x95b4
subl $-0x80, %ebx
leaq 0xa981(%rip), %rax      # 0x13134
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_functions.c
// Function: debug_lexer_flags
void	debug_lexer_flags(t_control *control)
{
	printf("[%d]%s\n", control->quit, "Quit");
	printf("[%d]%s\n", control->lexer_end.other, "Other");
	printf("[%d]%s\n", control->lexer_end.quote, "Quote");
	printf("[%d]%s\n", control->lexer_end.backslash, "Backslash");
	printf("[%d]%s\n", control->lexer_end.unexpected, "Unexpected");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl (%rdi), %esi
andl $0x1, %esi
leaq 0x2c94(%rip), %r14      # 0xb4d3
leaq 0x2c95(%rip), %rdx      # 0xb4db
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movzbl 0x28(%rbx), %esi
andl $0x1, %esi
leaq 0x2c82(%rip), %rdx      # 0xb4e0
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movl 0x28(%rbx), %esi
shrl %esi
andl $0x1, %esi
leaq 0x2c6f(%rip), %rdx      # 0xb4e6
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movl 0x28(%rbx), %esi
shrl $0x2, %esi
andl $0x1, %esi
leaq 0x2c5b(%rip), %rdx      # 0xb4ec
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movl 0x2c(%rbx), %esi
leaq 0x2c51(%rip), %rdx      # 0xb4f6
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_functions.c
// Function: debug_tokens_list
void	debug_tokens_list(t_list *head)
{
	ft_putendl_fd("\n=================\nTOKENS LIST START\n=================", 2);
	while (head)
	{
		printf("[%s]", ((t_token *)(head->content))->str);
		printf("(%s)\n", debug_id_to_str(((t_token *)head->content)->id));
		head = head->next;
	}
	ft_putendl_fd("=================\nTOKENS LIST END\n=================\n\n", 2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2c17(%rip), %rdi      # 0xb501
pushq $0x2
popq %rsi
callq 0x95cc
leaq 0x2c3f(%rip), %r14      # 0xb538
leaq 0x28c6(%rip), %r15      # 0xb1c6
testq %rbx, %rbx
je 0x8933
movq (%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rax
movl 0x8(%rax), %edi
callq 0x8810
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
movq 0x8(%rbx), %rbx
jmp 0x8900
leaq 0x2c03(%rip), %rdi      # 0xb53d
pushq $0x2
popq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x95cc
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_functions.c
// Function: debug_token_struct
void	debug_token_struct(t_token *token)
{
	ft_putendl_fd("\n---------------------\ntoken start\n-------------------", 2);
	printf("string:		[%s]\n", token->str);
	if (token->str)
		printf("lenght:		%zu\n", ft_strlen(token->str));
	printf("ID:   		%d [%s]\n", token->id, debug_id_to_str(token->id));
	printf("esc_next:	%d\n", token->esc_next);
	printf("open_quote:	%d\n", token->open_quote);
	ft_putendl_fd("---------------------\ntoken end\n---------------------\n", 2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c1f(%rip), %rdi      # 0xb573
pushq $0x2
popq %rsi
callq 0x95cc
movq (%rbx), %rsi
leaq 0x2c44(%rip), %rdi      # 0xb5aa
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x898b
callq 0x9be0
leaq 0x2c38(%rip), %rdi      # 0xb5b9
movq %rax, %rsi
xorl %eax, %eax
callq 0x20c0
movl 0x8(%rbx), %ebp
movl %ebp, %edi
callq 0x8810
leaq 0x2c2b(%rip), %rdi      # 0xb5c7
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x20c0
movl 0x10(%rbx), %esi
shrl %esi
andl $0x1, %esi
leaq 0x2c21(%rip), %rdi      # 0xb5d8
xorl %eax, %eax
callq 0x20c0
movzbl 0x10(%rbx), %esi
andl $0x1, %esi
leaq 0x2c1a(%rip), %rdi      # 0xb5e6
xorl %eax, %eax
callq 0x20c0
leaq 0x2c1c(%rip), %rdi      # 0xb5f6
pushq $0x2
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x95cc
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_functions.c
// Function: debug_env_list
void	debug_env_list(t_list *head)
{
	while (head)
	{
		printf("--------- new_link:\n");
		printf("label:%s\n",((t_env*)(head->content))->label);
		printf("value:%s\n",((t_env*)(head->content))->value);
		head = head->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2c8e(%rip), %r14      # 0xb688
leaq 0x2c2c(%rip), %r15      # 0xb62d
leaq 0x2c2f(%rip), %r12      # 0xb637
testq %rbx, %rbx
je 0x8a3c
movq %r14, %rdi
callq 0x2050
movq (%rbx), %rax
movq (%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rax
movq 0x8(%rax), %rsi
movq %r12, %rdi
xorl %eax, %eax
callq 0x20c0
movq 0x8(%rbx), %rbx
jmp 0x8a08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_functions.c
// Function: debug_history_list
void	debug_history_list(t_history *hist)
{
	int i;
	t_dlist *tmp;

	i = 0;
	if (!hist || !hist->head)
		printf("kunts fucked!!!!\n");
	tmp = hist->head;
	printf("\n==============================================================\n");
	printf("=============================== DEBUG HISTORY ================\n");
	printf("history->size = [%d]\n", hist->size);
	if (tmp)
		printf("head: [%p]\n", tmp);
	while(tmp)
	{
		printf("[%d] -- ADDRESS:[%p] -- STRING:[%s]\n"\
				, i, tmp, (char *)tmp->content);
		tmp = tmp->next;
		i++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x8a5d
movq 0x8(%r14), %rbx
testq %rbx, %rbx
jne 0x8a6d
leaq 0x2c38(%rip), %rdi      # 0xb69c
callq 0x2050
movq 0x8(%r14), %rbx
leaq 0x2c39(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2c6d(%rip), %rdi      # 0xb6ed
callq 0x2050
movl (%r14), %esi
leaq 0x2bb2(%rip), %rdi      # 0xb641
xorl %eax, %eax
callq 0x20c0
testq %rbx, %rbx
je 0x8aac
leaq 0x2bb5(%rip), %rdi      # 0xb657
movq %rbx, %rsi
xorl %eax, %eax
callq 0x20c0
leaq 0x2bb0(%rip), %r14      # 0xb663
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x8ad4
movq (%rbx), %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x20c0
movq 0x8(%rbx), %rbx
incl %ebp
jmp 0x8ab5
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_term_size
void	debug_term_size(t_term *term)
{
	printf("\n==============================================================\n");
	printf("=============================== DEBUG TERM ===================\n");
	printf("term->size_window.x = %d\n", term->size_window.x);
	printf("term->size_window.y = %d\n", term->size_window.y);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2ba8(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2e01(%rip), %rdi      # 0xb912
callq 0x2050
movl 0x28(%rbx), %esi
leaq 0x2c18(%rip), %rdi      # 0xb738
xorl %eax, %eax
callq 0x20c0
movl 0x2c(%rbx), %esi
leaq 0x2c21(%rip), %rdi      # 0xb752
xorl %eax, %eax
popq %rbx
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_escape_sequence
void debug_escape_sequence(char *str)
{
	int i = 0;
	int len;

	debug_start();
	if (!str)
	{
		printf("the caps string == NULL\r\n");
		return ;
	}
	len = ft_strlen(str);
	if (!len)
		printf("DEBUG(1/2): the sequence is empty\n");
	else
		printf("DEBUG(1/2): the sequence is [%d] long\n", len);
	ft_putstr_fd("\nDEBUG(2/2): the escape sequence is: \"", 1);
	while (str[i] != '\0')
	{
		if (str[i] == '\x1b')
			ft_putstr_fd("ESC", 1);
		else
			ft_putchar_fd(str[i], 1);
		++i;
	}
	ft_putstr_fd("\"\n", 1);
	debug_end();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x8adc
testq %rbx, %rbx
je 0x8b68
movq %rbx, %rdi
callq 0x9be0
testl %eax, %eax
je 0x8b78
leaq 0x2c0f(%rip), %rdi      # 0xb76c
movl %eax, %esi
xorl %eax, %eax
callq 0x20c0
jmp 0x8b84
leaq 0x2de2(%rip), %rdi      # 0xb951
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
leaq 0x2deb(%rip), %rdi      # 0xb96a
callq 0x2050
leaq 0x2c08(%rip), %rdi      # 0xb793
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9668
leaq 0x2c1e(%rip), %r14      # 0xb7ba
movzbl (%rbx), %eax
cmpl $0x1b, %eax
je 0x8bb4
testl %eax, %eax
je 0x8bc3
movsbl %al, %edi
movl %ebp, %esi
callq 0x95b4
jmp 0x8bbe
movq %r14, %rdi
movl %ebp, %esi
callq 0x9668
incq %rbx
jmp 0x8b9c
leaq 0x2bf4(%rip), %rdi      # 0xb7be
pushq $0x1
popq %rsi
callq 0x9668
popq %rbx
popq %r14
popq %rbp
jmp 0x8aeb
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_value_char
void debug_value_char(char c)
{
	debug_start();
	if (ft_isprint(c))
		printf("\nDEBUG: the char ['%c'] has the value [%d]\n", c, (int)c);
	else
		printf("\nDEBUG: non printable char has value [%d]\n", (int)c);

	debug_end();
}

// Assembly:
pushq %rbx
movl %edi, %ebx
callq 0x8adc
movl %ebx, %edi
callq 0x9418
testl %eax, %eax
je 0x8c02
leaq 0x2bcc(%rip), %rdi      # 0xb7c1
movl %ebx, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x20c0
jmp 0x8c12
leaq 0x2be4(%rip), %rdi      # 0xb7ed
movl %ebx, %esi
xorl %eax, %eax
callq 0x20c0
popq %rbx
jmp 0x8aeb
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_cursor
void	debug_cursor(t_int_pair *cursor)
{
	debug_start();
	printf("the coordinates for the current cursor position:\nx: %d\ny: %d\n", \
			cursor->x, cursor->y);
	debug_end();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8adc
movl (%rbx), %esi
movl 0x4(%rbx), %edx
leaq 0x2beb(%rip), %rdi      # 0xb818
xorl %eax, %eax
callq 0x20c0
popq %rbx
jmp 0x8aeb
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_term_struct
void	debug_term_struct(t_term *term)
{
	debug_start();
	printf("\n\n------------------------------------------------------------");
	printf("\n-------------------------DEBUG FOR THE TERM STRUCT----------\n");
	debug_cursor(&(term->cursor));
	debug_start();
	printf("prompt ps1: [%s]\n", term->ps1);
	debug_start();
	printf("prompt ps2: [%s]\n", term->ps2);
	debug_start();
	printf("length of current prompt: [%d]\n", term->prompt_len);
	debug_start();
	printf("\n-------------------------DEBUG END -------------------------\n");
	debug_start();
	printf("------------------------------------------------------------\n\n");
	debug_end();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8adc
leaq 0x2c0c(%rip), %rdi      # 0xb856
xorl %eax, %eax
callq 0x20c0
leaq 0x2d34(%rip), %rdi      # 0xb98c
callq 0x2050
leaq 0x10(%rbx), %rdi
callq 0x8c18
callq 0x8adc
movq 0x38(%rbx), %rsi
leaq 0x2c1f(%rip), %rdi      # 0xb895
xorl %eax, %eax
callq 0x20c0
callq 0x8adc
movq 0x40(%rbx), %rsi
leaq 0x2c1a(%rip), %rdi      # 0xb8a7
xorl %eax, %eax
callq 0x20c0
callq 0x8adc
movl 0x48(%rbx), %esi
leaq 0x2c16(%rip), %rdi      # 0xb8b9
xorl %eax, %eax
callq 0x20c0
callq 0x8adc
leaq 0x2d14(%rip), %rdi      # 0xb9ca
callq 0x2050
callq 0x8adc
leaq 0x2d41(%rip), %rdi      # 0xba08
callq 0x2050
popq %rbx
jmp 0x8aeb
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_terminfo.c
// Function: debug_clipboard_struct
void	debug_clipboard_struct(t_clipboard clip)
{
	debug_start();
	printf("\n\n-----------------------------------------------------------\n");
	printf("--------------------- CLIPBOARD DEBUG ----------------------\n");
	printf("highlight: [%d]\n", clip.highlight);
	printf("start: [%d]\n", clip.start);
	printf("end: [%d]\n", clip.end);
	printf("paste_me: [%s]\n", clip.paste_me);
	printf("-----------------------------------------------------------\n");
	debug_end();
}

// Assembly:
pushq %rax
callq 0x8adc
leaq 0x2d67(%rip), %rdi      # 0xba46
callq 0x2050
leaq 0x2d99(%rip), %rdi      # 0xba84
callq 0x2050
movl 0x10(%rsp), %esi
leaq 0x2bde(%rip), %rdi      # 0xb8d9
xorl %eax, %eax
callq 0x20c0
movl 0x14(%rsp), %esi
leaq 0x2bdd(%rip), %rdi      # 0xb8ea
xorl %eax, %eax
callq 0x20c0
movl 0x18(%rsp), %esi
leaq 0x2bd8(%rip), %rdi      # 0xb8f7
xorl %eax, %eax
callq 0x20c0
movq 0x20(%rsp), %rsi
leaq 0x2bd0(%rip), %rdi      # 0xb902
xorl %eax, %eax
callq 0x20c0
leaq 0x2d08(%rip), %rdi      # 0xba48
callq 0x2050
popq %rax
jmp 0x8aeb
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/btree_debug.c
// Function: btree_debug
void	btree_debug(t_btree *root, void (*display)())
{
	t_depth	depths;

	ft_putstr_fd("\n======================================================"\
			"=========================\n======================== BTREE DEBUG "\
			"START ====================================\n", 1);
	if (!root)
	{
		ft_putstr_fd("NULL ROOT\n", 1);
		return ;
	}
	depths.max = btree_depth(root);
	depths.current = 0;
	depths.bottom = 0;
	while (++depths.bottom <= depths.max)
	{
		btree_debug2(root, depths, display, NULL);
		ft_putchar_fd('\n', 1);
	}
	ft_putstr_fd("\n============================== DEBUG END ============="\
			"=========================\n====================================="\
			"==========================================\n\n\n", 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d5d(%rip), %rdi      # 0xbac1
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x9668
testq %r14, %r14
je 0x8dc4
movq %r14, %rdi
callq 0xa3c8
movl %eax, %r12d
movl %eax, %r13d
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
negl %r12d
movl %ebp, %r15d
leal (%r12,%rbp), %eax
cmpl $0x1, %eax
je 0x8dbb
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x8de1
pushq $0xa
popq %rdi
movl %r15d, %esi
callq 0x95b4
incl %ebp
jmp 0x8d90
leaq 0x2dac(%rip), %rdi      # 0xbb6e
jmp 0x8dcb
leaq 0x2d98(%rip), %rdi      # 0xbb63
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9668
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/btree_debug.c
// Function: btree_debug2
static	void	btree_debug2(t_btree *node, t_depth depths, void (*display)(),
		t_btree *parent)
{
	int	size_line;
	int	i;

	depths.current++;
	i = 0;
	size_line = (1 << (depths.max - depths.current)) * SIZE_LEAF;
	if (!node)
	{
		while (i++ < size_line)
			ft_putchar_fd(' ', 1);
		return ;
	}
	if (depths.current == depths.bottom)
	{
		while (i++ < (size_line - SIZE_LEAF) / 2)
			ft_putchar_fd(' ', 1);
		display(node->item, parent);
		while (i++ <= (size_line - SIZE_LEAF))
			ft_putchar_fd(' ', 1);
		return ;
	}
	btree_debug2(node->left, depths, display, node);
	btree_debug2(node->right, depths, display, node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %r12, %rax
shrq $0x20, %rax
incl %eax
testq %rdi, %rdi
je 0x8e32
movq %rdi, %r14
cmpl %ebp, %eax
je 0x8e5d
movq (%r14), %rdi
shlq $0x20, %rax
movl %r12d, %r12d
orq %rax, %r12
movq %r12, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0x8de1
movq 0x8(%r14), %rdi
movq %r14, %r8
jmp 0x8df7
subl %eax, %r12d
pushq $0x6
popq %rax
movl %r12d, %ecx
shll %cl, %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
pushq $0x20
popq %rbx
pushq $0x1
popq %rbp
subl $0x1, %r14d
jb 0x8ecb
movl %ebx, %edi
movl %ebp, %esi
callq 0x95b4
jmp 0x8e4c
movq %r8, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
subl %ebp, %r12d
pushq $0x6
popq %r13
movl %r12d, %ecx
shll %cl, %r13d
addl $-0x6, %r13d
movl %r13d, %eax
sarl %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
pushq $0x20
popq %rbp
pushq $0x1
popq %r12
movl %r15d, %ebx
subl $0x1, %ebx
jb 0x8ea1
movl %ebp, %edi
movl %r12d, %esi
callq 0x95b4
jmp 0x8e90
movq 0x10(%r14), %rdi
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq *0x10(%rsp)
pushq $0x20
popq %r14
pushq $0x1
popq %rbp
cmpl %r13d, %r15d
jge 0x8ecb
incl %r15d
movl %r14d, %edi
movl %ebp, %esi
callq 0x95b4
jmp 0x8eb7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_node_id
void	debug_node_id(t_btree *node)
{
	printf("\033[35mnode id:");
	if (!node)
		printf("\033[31mnode is NULL:\n");
	else if (btree_id(node) == TOKEN)
		printf("TOKEN\n");
	else if (btree_id(node) == SEMI)
		printf("SEMI\n");
	else if (btree_id(node) == PIPE)
		printf("PIPE\n");
	else if (btree_id(node) == OR_IF)
		printf("OR_IF\n");
	else if (btree_id(node) == AND)
		printf("AND\n");
	else if (btree_id(node) == AND_IF)
		printf("AND_IF\n");
	else if (btree_id(node) == LBRACE)
		printf("LBRACE\n");
	else if (btree_id(node) == RBRACE)
		printf("RBRACE\n");
	else if (btree_id(node) == S_QUOTE)
		printf("S_QUOTE\n");
	else if (btree_id(node) == D_QUOTE)
		printf("D_QUOTE\n");
	else if (btree_id(node) == LESS)
		printf("LESS\n");
	else if (btree_id(node) == DLESS)
		printf("DLESS\n");
	else if (btree_id(node) == GREAT)
		printf("GREAT\n");
	else if (btree_id(node) == DGREAT)
		printf("DGREAT\n");
	else if (btree_id(node) == SUBSHELL)
		printf("SUBSHELL\n");
	else if (btree_id(node) == LIST)
		printf("LIST\n");
	else
		printf("\033[31mWARNING, id unrecognized\n");
	printf("\033[0m");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2d2b(%rip), %rdi      # 0xbc12
xorl %eax, %eax
callq 0x20c0
testq %rbx, %rbx
je 0x8f18
movq %rbx, %rdi
callq 0x5fe9
testl %eax, %eax
je 0x8f24
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x1, %eax
jne 0x8f30
leaq 0x255e(%rip), %rdi      # 0xb471
jmp 0x9083
leaq 0x2e54(%rip), %rdi      # 0xbd73
jmp 0x9083
leaq 0x258c(%rip), %rdi      # 0xb4b7
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x2, %eax
jne 0x8f49
leaq 0x2540(%rip), %rdi      # 0xb484
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x3, %eax
jne 0x8f62
leaq 0x252c(%rip), %rdi      # 0xb489
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x4, %eax
jne 0x8f7b
leaq 0x2519(%rip), %rdi      # 0xb48f
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x5, %eax
jne 0x8f94
leaq 0x2504(%rip), %rdi      # 0xb493
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x6, %eax
jne 0x8fad
leaq 0x24ce(%rip), %rdi      # 0xb476
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x7, %eax
jne 0x8fc6
leaq 0x24bc(%rip), %rdi      # 0xb47d
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x8, %eax
jne 0x8fdf
leaq 0x24c0(%rip), %rdi      # 0xb49a
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0x9, %eax
jne 0x8ff8
leaq 0x24af(%rip), %rdi      # 0xb4a2
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xa, %eax
jne 0x900e
leaq 0x24a6(%rip), %rdi      # 0xb4b2
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xb, %eax
jne 0x9024
leaq 0x248f(%rip), %rdi      # 0xb4b1
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xc, %eax
jne 0x903a
leaq 0x2473(%rip), %rdi      # 0xb4ab
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xd, %eax
jne 0x9050
leaq 0x245c(%rip), %rdi      # 0xb4aa
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xe, %eax
jne 0x9066
leaq 0x2d45(%rip), %rdi      # 0xbda9
jmp 0x9083
movq %rbx, %rdi
callq 0x5fe9
cmpl $0xf, %eax
leaq 0x2d2c(%rip), %rax      # 0xbda4
leaq 0x2d07(%rip), %rdi      # 0xbd86
cmoveq %rax, %rdi
callq 0x2050
leaq 0x2bbb(%rip), %rdi      # 0xbc4a
xorl %eax, %eax
popq %rbx
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_arrow_struct
void	debug_arrow_struct(t_arrow *arrow)
{
	if (!arrow)
	{
		printf("\033[31mWARNING, the arrow pointer was null.\n\033[0m");
		return ;
	}
	printf("\tarrow->id = ");
	if (arrow->id == GREAT)
		printf("GREAT\n");
	else if (arrow->id == DGREAT)
		printf("DGREAT\n");
	else if (arrow->id == LESS)
		printf("LESS\n");
	else
		printf("\033[31mWR0NG ID\033[0m\n");
	printf("\tarrow->dest = [%s]\n", arrow->dest);
}

// Assembly:
testq %rdi, %rdi
je 0x90cb
pushq %rbx
movq %rdi, %rbx
leaq 0x2ba8(%rip), %rdi      # 0xbc4f
xorl %eax, %eax
callq 0x20c0
movl 0x10(%rbx), %eax
addl $-0xa, %eax
cmpl $0x3, %eax
ja 0x90d9
movl %eax, %eax
leaq 0x2ff2(%rip), %rcx      # 0xc0b4
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
jmp 0x90e0
leaq 0x2b4e(%rip), %rdi      # 0xbc20
xorl %eax, %eax
jmp 0x20c0
leaq 0x2cd2(%rip), %rdi      # 0xbdb2
callq 0x2050
movq 0x8(%rbx), %rsi
leaq 0x2b6d(%rip), %rdi      # 0xbc5d
xorl %eax, %eax
popq %rbx
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_simple_cmd
void	debug_simple_cmd(t_simple_cmd *cmd)
{
	int i;
	t_list *tmp;

	i = 0;
	printf("\n==============================================================\n");
	printf("=============================== DEBUG SIMPLE_CMD =============\n");
	if (!cmd)
	{
		printf("\033[31mWARNING, the cmd structure is a NULL pointer\n\033[0m");
		return ;
	}
	printf("argv:\n");
	if (!cmd->argv)
	{
		printf("\033[31mWARNING, the cmd->argv is a NULL pointer\n\033[0m");
	}
	while (cmd->argv && cmd->argv[i])
	{
		printf("\tcmd->argv[%d]: [%s]\n", i, cmd->argv[i]);
		i++;
	}
	printf("arrows:\n");
	tmp = cmd->arrows;
	while (tmp)
	{
		debug_arrow_struct((t_arrow*)tmp->content);
		tmp = tmp->next;
	}
	printf("======================= END DEBUG SIMPLE_CMD =================\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x25a6(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2cb1(%rip), %rdi      # 0xbdc4
callq 0x2050
testq %rbx, %rbx
je 0x91a3
leaq 0x2cdb(%rip), %rdi      # 0xbe03
callq 0x2050
cmpq $0x0, 0x8(%rbx)
jne 0x9142
leaq 0x2b6e(%rip), %rdi      # 0xbca9
xorl %eax, %eax
callq 0x20c0
leaq 0x2b93(%rip), %r14      # 0xbcdc
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x9170
movq (%rax,%r15,8), %rdx
testq %rdx, %rdx
je 0x9170
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x20c0
incq %r15
jmp 0x914c
leaq 0x2c92(%rip), %rdi      # 0xbe09
callq 0x2050
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9192
movq (%rbx), %rdi
callq 0x9097
addq $0x8, %rbx
jmp 0x917c
leaq 0x2c78(%rip), %rdi      # 0xbe11
popq %rbx
popq %r14
popq %r15
jmp 0x2050
leaq 0x2ac8(%rip), %rdi      # 0xbc72
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_array
void	debug_array(char **array)
{
	int i;

	i = 0;
	printf("\n==============================================================\n");
	printf("=============================== DEBUG ARRAY ==================\n");
	if (!array || !*array)
	{
		printf("\033[31mNULL POINTER!\033[0m\n");
		return ;
	}
	while (array[i])
	{
		printf("\t[%s]\n", array[i]);
		i++;
	}
	printf("======================= END DEBUG ARRAY ======================\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x24e8(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2c7f(%rip), %rdi      # 0xbe50
callq 0x2050
leaq 0x2cb2(%rip), %r14      # 0xbe8f
testq %rbx, %rbx
je 0x9214
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x9214
addq $0x8, %rbx
leaq 0x2cb1(%rip), %r14      # 0xbea6
leaq 0x23b6(%rip), %r15      # 0xb5b2
testq %rsi, %rsi
je 0x9214
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rsi
addq $0x8, %rbx
jmp 0x91fc
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_unquote
void	debug_unquote(t_token *token)
{
	printf("\n==============================================================\n");
	printf("=============================== DEBUG UNQUOTE ================\n");
	printf("the string is: [%s]\n", token->str);
	if (!token->unquote_protected)
	{
		printf("\033[31mthe protection is off\033[0m\n");
		return ;
	}
	printf("\033[32mthe protection is ON\033[0m\n");
	printf("start: %d\n", token->protect_s);
	printf("end: %d\n", token->protect_e);
	printf("======================= END DEBUG UNQUOTE ====================\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2481(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2cad(%rip), %rdi      # 0xbee5
callq 0x2050
movq (%rbx), %rsi
leaq 0x2aab(%rip), %rdi      # 0xbcf2
xorl %eax, %eax
callq 0x20c0
cmpl $0x0, 0x14(%rbx)
je 0x928b
leaq 0x2ce8(%rip), %rdi      # 0xbf43
callq 0x2050
movl 0x18(%rbx), %esi
leaq 0x2a9d(%rip), %rdi      # 0xbd07
xorl %eax, %eax
callq 0x20c0
movl 0x1c(%rbx), %esi
leaq 0x2a97(%rip), %rdi      # 0xbd12
xorl %eax, %eax
callq 0x20c0
leaq 0x2cd8(%rip), %rdi      # 0xbf61
jmp 0x9292
leaq 0x2c92(%rip), %rdi      # 0xbf24
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_path_parts
void	debug_path_parts(t_list *path_parts)
{
	int i;

	i = 0;
	printf("\n==============================================================\n");
	printf("============================= DEBUG PATH_PARTS ===============\n");
	while (path_parts)
	{
		printf("[%d] str is: [%s]\n", i++, ((t_path_part *)(path_parts->content))->path_part);
		path_parts = path_parts->next;
	}
	printf("==================== END DEBUG PATH_PARTS ====================\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2407(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2cee(%rip), %rdi      # 0xbfa0
callq 0x2050
leaq 0x2a5d(%rip), %r14      # 0xbd1b
xorl %esi, %esi
testq %rbx, %rbx
je 0x92e0
leal 0x1(%rsi), %ebp
movq (%rbx), %rax
movq (%rax), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
movq 0x8(%rbx), %rbx
movl %ebp, %esi
jmp 0x92c0
leaq 0x2cf8(%rip), %rdi      # 0xbfdf
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/sources/debug_exe.c
// Function: debug_path_part
void	debug_path_part(t_path_part *path_part)
{
	t_list *stars;

	printf("\n==============================================================\n");
	printf("============================= DEBUG PATH_PART ================\n");
	printf("the string is: [%s]\n", path_part->path_part);
	printf("quoted at the start of the string was: %d\n", path_part->quoted);
	printf("the ints linked list:\n");

	stars = path_part->star_index;
	while (stars)
	{
		printf("valid star a index: [%d]\n", *((int*)stars->content));
		stars = stars->next;
	}
	printf("===================== END DEBUG PATH_PART ====================\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x23af(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2d14(%rip), %rdi      # 0xc01e
callq 0x2050
movq (%rbx), %rsi
leaq 0x29d9(%rip), %rdi      # 0xbcf2
xorl %eax, %eax
callq 0x20c0
movsbl 0x10(%rbx), %esi
leaq 0x2a03(%rip), %rdi      # 0xbd2e
xorl %eax, %eax
callq 0x20c0
leaq 0x2d24(%rip), %rdi      # 0xc05d
callq 0x2050
leaq 0x2a14(%rip), %r14      # 0xbd59
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x935f
movq (%rbx), %rax
movl (%rax), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20c0
jmp 0x9345
leaq 0x2d0d(%rip), %rdi      # 0xc073
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	int i;
	int signe;
	int result;

	i = 0;
	signe = 1;
	result = 0;
	while (str[i] == '\t' || str[i] == '\n' || str[i] == '\v' ||
			str[i] == '\f' || str[i] == '\r' || str[i] == ' ')
		i++;
	if (str[i] == '+')
		i++;
	else if (str[i] == '-')
	{
		signe *= -1;
		i++;
	}
	while (str[i] >= '0' && str[i] <= '9')
		result = (10 * result) + str[i++] - '0';
	return (result * signe);
}

// Assembly:
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x9387
incq %rax
jmp 0x9376
cmpl $0x20, %ecx
je 0x9382
cmpl $0x2b, %ecx
je 0x939d
cmpl $0x2d, %ecx
jne 0x93a0
incq %rax
pushq $-0x1
jmp 0x93a2
incq %rax
pushq $0x1
popq %rcx
cltq
addq %rax, %rdi
xorl %eax, %eax
jmp 0x93b7
imull $0xa, %eax, %eax
addl %edx, %eax
addl $-0x30, %eax
incq %rdi
movzbl (%rdi), %edx
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
jbe 0x93ac
imull %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_isonly.c
// Function: ft_isonly
int	ft_isonly(char *str, char c)
{
	int i;

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

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x9441
cmpb $0x0, (%rdi)
je 0x9442
pushq $0x1
popq %rcx
movb (%rdi), %dl
testb %dl, %dl
je 0x944b
incq %rdi
cmpb %sil, %dl
je 0x9433
retq
xorl %eax, %eax
testb %sil, %sil
sete %al
retq
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_isonly_ft.c
// Function: ft_isonly_ft
int	ft_isonly_ft(char *str, int (*ft_issmth)(int c), int strict)
{
	int i;

	i = -1;
	if (!str || !str[0])
		return (strict ? 0 : 1);
	while (str[++i])
		if (!ft_issmth(str[i]))
			return (0);
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x947e
movq %rdi, %r15
cmpb $0x0, (%rdi)
je 0x947e
movq %rsi, %r14
pushq $0x1
popq %rbx
movsbl (%r15), %edi
testl %edi, %edi
je 0x9485
callq *%r14
incq %r15
testl %eax, %eax
jne 0x9468
xorl %ebx, %ebx
jmp 0x9485
xorl %ebx, %ebx
testl %edx, %edx
sete %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	char	*ptr;
	int		size;

	size = predict_size(n);
	if (!(ptr = (char *)malloc(sizeof(*ptr) * (size + 1))))
		return (NULL);
	ptr[size] = '\0';
	while ((n > 9) || (n < -9))
	{
		ptr[--size] = (n < 0) ? -(n % 10) + '0' : n % 10 + '0';
		n = n / 10;
	}
	ptr[--size] = (n < 0) ? -(n % 10) + '0' : n % 10 + '0';
	ptr[0] = (size == 1) ? '-' : ptr[0];
	return (ptr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %r14d
shrl $0x1f, %r14d
pushq $0xa
popq %rbp
movl %edi, %eax
leal -0xa(%rax), %ecx
cmpl $-0x14, %ecx
ja 0x94b2
cltd
idivl %ebp
incl %r14d
jmp 0x94a2
leal 0x2(%r14), %edi
callq 0x2180
movq %rax, %rcx
testq %rax, %rax
je 0x9524
leal 0x1(%r14), %eax
movl %r14d, %edx
movb $0x0, 0x1(%rcx,%rdx)
cltq
leaq (%rcx,%rax), %rsi
decq %rsi
leal -0xa(%rbx), %eax
cmpl $-0x14, %eax
ja 0x94ff
movl %ebx, %eax
negl %eax
cmovsl %ebx, %eax
xorl %edx, %edx
divl %ebp
orb $0x30, %dl
movb %dl, (%rsi)
movl %ebx, %eax
cltd
idivl %ebp
decl %r14d
decq %rsi
movl %eax, %ebx
jmp 0x94d8
movb $0x30, %al
subb %bl, %al
movl %ebx, %edx
orb $0x30, %dl
testl %ebx, %ebx
movzbl %al, %eax
movzbl %dl, %edx
cmovsl %eax, %edx
movslq %r14d, %rsi
movb %dl, (%rcx,%rsi)
movb $0x2d, %al
cmpl $0x1, %esi
je 0x9522
movb (%rcx), %al
movb %al, (%rcx)
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_memmove.c
// Function: ft_memmove
void	*ft_memmove(void *dst, const void *src, size_t len)
{
	size_t			i;
	unsigned char	*dest;
	unsigned char	*srcs;

	i = 0;
	dest = (unsigned char *)dst;
	srcs = (unsigned char *)src;
	if (dst < src)
		while (i < len)
		{
			dest[i] = srcs[i];
			i++;
		}
	else if (src < dst)
		while (len-- > 0)
			dest[len] = srcs[len];
	return (dst);
}

// Assembly:
movq %rdi, %rax
cmpq %rsi, %rdi
jae 0x9584
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x959e
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
jmp 0x9572
jbe 0x959e
movq %rdx, %rcx
subq $0x1, %rcx
jb 0x959e
movb -0x1(%rsi,%rdx), %dil
movb %dil, -0x1(%rax,%rdx)
movq %rcx, %rdx
jmp 0x9589
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_putnbr_fd.c
// Function: ft_putnbr_fd
void	ft_putnbr_fd(int n, int fd)
{
	if (n == -2147483648)
		ft_putstr_fd("-2147483648", fd);
	else if (n < 0)
	{
		n *= (-1);
		ft_putchar_fd('-', fd);
	}
	if (n >= 0 && n <= 9)
		ft_putchar_fd(n + 48, fd);
	else if (n >= 10)
	{
		ft_putnbr_fd(n / 10, fd);
		ft_putnbr_fd(n % 10, fd);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
pushq $0x2d
popq %rbp
pushq $0xa
popq %r15
movl %r14d, %r12d
negl %r12d
jo 0x9639
testl %r14d, %r14d
jns 0x961d
movl %ebp, %edi
movl %ebx, %esi
callq 0x95b4
movl %r12d, %r14d
cmpl $0x9, %r14d
jbe 0x964f
movl %r14d, %eax
xorl %edx, %edx
divl %r15d
movl %edx, %r14d
movl %eax, %edi
movl %ebx, %esi
callq 0x95f0
jmp 0x9604
leaq 0x2a84(%rip), %rdi      # 0xc0c4
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9668
orb $0x30, %r14b
movsbl %r14b, %edi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x95b4
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_split.c
// Function: ft_split
char			**ft_split(char const *s, char c)
{
	int		err;
	char	**result;

	err = -1;
	if (s)
	{
		if ((result = (char **)malloc(sizeof(char *) * w_len(s, c))))
			if ((err = ft_malloc_w_len(s, c, result)) < 0)
				return (ft_tab_filled(s, c, result));
		while (err >= 0)
			free(result[err--]);
		free(result);
	}
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x9819
movl %esi, %ebp
movq %rdi, %r14
xorl %eax, %eax
movslq %eax, %rdx
cmpb $0x0, (%r14,%rdx)
je 0x96fa
leaq -0x1(%rdx), %rcx
incq %rdx
movq %rdx, %rax
movb 0x1(%r14,%rcx), %sil
testb %sil, %sil
je 0x96d7
incq %rcx
leaq 0x1(%rax), %rdx
cmpb %bpl, %sil
je 0x96be
movb -0x1(%r14,%rax), %cl
incq %rax
testb %cl, %cl
je 0x96e8
cmpb %bpl, %cl
jne 0x96d7
xorl %ecx, %ecx
cmpb %bpl, -0x3(%r14,%rax)
setne %cl
addl %ecx, %ebx
addq $-0x2, %rax
jmp 0x96ad
movl %ebx, %eax
leaq 0x8(,%rax,8), %rdi
callq 0x2180
movq %rax, %rbx
testq %rax, %rax
je 0x97f5
xorl %r12d, %r12d
pushq $0x1
popq %r13
xorl %ecx, %ecx
movl %ecx, %r15d
movslq %r12d, %r12
cmpb $0x0, (%r14,%r12)
je 0x9779
decq %r12
movb 0x1(%r14,%r12), %al
incq %r12
testb %al, %al
je 0x973f
cmpb %bpl, %al
je 0x972e
movq %r13, %rdi
testb %al, %al
je 0x9758
cmpb %bpl, %al
je 0x9758
movb 0x1(%r14,%r12), %al
incq %r12
incq %rdi
jmp 0x9742
cmpb %bpl, -0x1(%r14,%r12)
je 0x9721
callq 0x2180
leal 0x1(%r15), %ecx
movl %r15d, %edx
movq %rax, (%rbx,%rdx,8)
testq %rax, %rax
jne 0x971e
jmp 0x980a
leaq 0x1(%r14), %rax
xorl %r8d, %r8d
xorl %esi, %esi
movl %esi, %ecx
movslq %r8d, %rdx
cmpb $0x0, (%r14,%rdx)
je 0x97ee
leaq (%rax,%rdx), %rdi
decq %rdx
movq %rdi, %rsi
movb 0x1(%r14,%rdx), %r8b
incq %rdx
cmpb %bpl, %r8b
jne 0x97ae
leaq 0x1(%rsi), %rdi
testb %r8b, %r8b
jne 0x9795
xorl %edi, %edi
cmpb %bpl, %r8b
je 0x97cd
testb %r8b, %r8b
je 0x97cd
movq (%rbx,%rcx,8), %r9
movb %r8b, (%r9,%rdi)
incq %rdi
movb (%rsi), %r8b
incq %rsi
jmp 0x97b0
leaq (%rdx,%rdi), %r8
cmpb %bpl, -0x2(%rsi)
je 0x9784
leal 0x1(%rcx), %esi
movq (%rbx,%rcx,8), %rcx
movl %edi, %r8d
movb $0x0, (%rcx,%r8)
addq %rdi, %rdx
movq %rdx, %r8
jmp 0x9782
andq $0x0, (%rbx,%rcx,8)
jmp 0x9819
pushq $-0x1
popq %r15
jmp 0x980a
movl %r15d, %eax
decl %r15d
movq (%rbx,%rax,8), %rdi
callq 0x2230
testl %r15d, %r15d
jns 0x97fb
movq %rbx, %rdi
callq 0x2230
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_split_whitespaces.c
// Function: ft_split_whitespaces
char		**ft_split_whitespaces(char const *s, char *ifs)
{
	char	**ptr;
	int		i;
	int		k;
	int		j;
	int		size;

	i = 0;
	k = 0;
	if (!s || !ifs ||
			!(ptr = (char **)malloc(sizeof(char*) * (size_array(s, ifs) + 1))))
		return (NULL);
	size = size_array(s, ifs);
	ptr[size] = NULL;
	while (k < size)
	{
		i = find_start(s, ifs, i);
		if (!(ptr[k] = (char *)malloc(sizeof(char) * (find_end(s, ifs, i) - i \
							+ 1))))
			return (free_nested(ptr, k));
		j = 0;
		while (s[i] && (-1 == ft_strichr(ifs, s[i])))
			ptr[k][j++] = s[i++];
		ptr[k++][j] = '\0';
	}
	return (ptr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x99ef
movq %rsi, %r14
movq %rdi, %rbp
callq 0x9a04
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2180
xorl %r13d, %r13d
testq %rax, %rax
je 0x99ef
movq %rax, %r15
movq %rbp, %rdi
movq %r14, %rsi
callq 0x9a04
cltq
andq $0x0, (%r15,%rax,8)
testl %eax, %eax
cmovlel %r13d, %eax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
movq %r15, 0x18(%rsp)
movq %rbp, 0x10(%rsp)
cmpq 0x20(%rsp), %rax
je 0x99f2
movq %rax, 0x8(%rsp)
movslq %r13d, %rbx
movq %rbx, %r12
negq %r12
movb (%rbp,%rbx), %al
testb %al, %al
je 0x98dc
movsbl %al, %esi
movq %r14, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
je 0x98dc
incq %rbx
decq %r12
incl %r13d
jmp 0x98b9
movslq %ebx, %r15
movq %rbp, %rax
movslq %r13d, %rbp
addl %r13d, %r12d
shlq $0x20, %r12
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %r12
leaq (%rax,%rbp), %rbx
movq 0x10(%rsp), %rax
movb (%rax,%r15), %al
testb %al, %al
je 0x992f
movsbl %al, %esi
movq %r14, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
je 0x992f
incq %r15
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r12
incq %rbx
jmp 0x98fd
movq 0x18(%rsp), %r15
movb (%rbx), %al
testb %al, %al
je 0x995c
movsbl %al, %esi
movq %r14, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
jne 0x995c
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rax, %r12
incq %rbx
jmp 0x9934
sarq $0x20, %r12
movq %r12, %rdi
callq 0x2180
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %r12, (%r15,%rax,8)
testq %r12, %r12
je 0x99c4
addq 0x10(%rsp), %rbp
xorl %ebx, %ebx
movb (%rbp,%rbx), %al
testb %al, %al
je 0x99a8
movsbl %al, %esi
movq %r14, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
jne 0x99a8
movb (%rbp,%rbx), %al
movb %al, (%r12,%rbx)
incq %rbx
incl %r13d
jmp 0x9980
movq 0x8(%rsp), %rcx
incq %rcx
movl %ebx, %eax
movb $0x0, (%r12,%rax)
movq %rcx, %rax
movq 0x10(%rsp), %rbp
jmp 0x98a0
movq 0x8(%rsp), %r14
testq %r14, %r14
jle 0x99e7
leaq -0x1(%r14), %rbx
movq -0x8(%r15,%r14,8), %rdi
callq 0x2230
andq $0x0, -0x8(%r15,%r14,8)
movq %rbx, %r14
jmp 0x99c9
movq %r15, %rdi
callq 0x2230
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_split_whitespaces.c
// Function: size_array
static int	size_array(char const *s, char *ifs)
{
	int i;
	int count;

	i = 0;
	count = 0;
	while (s[i])
	{
		while (s[i] && (-1 != ft_strichr(ifs, s[i])))
			i++;
		if (s[i] && (ft_strichr(ifs, s[i]) == -1))
			count++;
		while (s[i] && (ft_strichr(ifs, s[i]) == -1))
			i++;
	}
	return (count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %r15
xorl %r12d, %r12d
movabsq $0x100000000, %r13      # imm = 0x100000000
movl $0x0, 0x4(%rsp)
movslq %r12d, %r12
movb (%r14,%r12), %al
testb %al, %al
je 0x9a9f
leaq (%r15,%r12), %rbp
shlq $0x20, %r12
testb %al, %al
je 0x9a7e
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
je 0x9a60
movb (%rbp), %al
addq %r13, %r12
incq %rbp
jmp 0x9a41
movb -0x1(%rbp), %al
testb %al, %al
je 0x9a7e
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9eb4
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %cl
addl %ecx, 0x4(%rsp)
sarq $0x20, %r12
movb (%r14,%r12), %al
testb %al, %al
je 0x9a2e
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9eb4
cmpl $-0x1, %eax
jne 0x9a2e
incq %r12
jmp 0x9a82
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	size_t		i;
	size_t		s_len;
	char		searched;

	s_len = ft_strlen(s);
	searched = (char)c;
	i = 0;
	while (i <= s_len)
	{
		if (s[i] == searched)
			return ((char *)&(s[i]));
		i++;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x9be0
movq %rax, %rcx
movsbl %bpl, %edx
xorl %eax, %eax
xorl %esi, %esi
cmpq %rcx, %rsi
ja 0x9ae4
movsbl (%rbx,%rsi), %edi
cmpl %edi, %edx
je 0x9ade
incq %rsi
jmp 0x9acc
addq %rsi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	int		i;
	size_t	tt_len;
	char	*string;

	i = 0;
	if (!s1 || !s2)
		return (NULL);
	tt_len = ft_strlen(s1) + ft_strlen(s2) + 1;
	if (!(string = (char *)malloc(sizeof(*string) * tt_len)))
		return (NULL);
	while (*s1)
		string[i++] = *(s1++);
	while (*s2)
		string[i++] = *(s2++);
	string[i] = '\0';
	return (string);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9b91
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9be0
movq %rax, %r15
movq %rbx, %rdi
callq 0x9be0
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x2180
testq %rax, %rax
je 0x9b94
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
testb %dl, %dl
je 0x9b83
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x9b6a
incq %rbx
movb %dl, (%rax,%rcx)
incq %rcx
movb (%rbx), %dl
testb %dl, %dl
jne 0x9b7a
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
jmp 0x9b96
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strjoin_free.c
// Function: ft_strjoin_free
char	*ft_strjoin_free(char const *s1, char const *s2, int to_free)
{
	char *res;

	res = ft_strjoin(s1, s2);
	if (to_free & 1)
		ft_free((void **)&s1);
	if (to_free & 2)
		ft_free((void **)&s2);
	return (res);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x9b2c
movq %rax, %rbx
testb $0x1, %bpl
je 0x9bc6
leaq 0x10(%rsp), %rdi
callq 0xa018
testb $0x2, %bpl
je 0x9bd6
leaq 0x8(%rsp), %rdi
callq 0xa018
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t i;

	i = 0;
	while (s && s[i])
		i++;
	return (i);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x9bf2
cmpb $0x0, (%rdi,%rax)
je 0x9bf4
incq %rax
jmp 0x9be2
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t			i;
	size_t			max;
	unsigned char	*str1;
	unsigned char	*str2;

	i = 0;
	max = 0;
	str1 = (unsigned char *)s1;
	str2 = (unsigned char *)s2;
	while (str1[max] && str2[max])
		max++;
	while (i < n && i <= max)
	{
		if (str1[i] != str2[i])
			return ((int)(str1[i] - str2[i]));
		i++;
	}
	return (0);
}

// Assembly:
xorl %ecx, %ecx
cmpb $0x0, (%rdi,%rcx)
je 0x9c0b
cmpb $0x0, (%rsi,%rcx)
je 0x9c0b
incq %rcx
jmp 0x9bfa
xorl %eax, %eax
xorl %r8d, %r8d
cmpq %rdx, %r8
jae 0x9c32
cmpq %rcx, %r8
ja 0x9c32
movzbl (%rdi,%r8), %r9d
movzbl (%rsi,%r8), %r10d
incq %r8
cmpb %r10b, %r9b
je 0x9c10
subl %r10d, %r9d
movl %r9d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strrchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t			i;
	size_t			s_len;
	char			*to_return;
	unsigned char	searched;

	to_return = NULL;
	s_len = ft_strlen(s);
	searched = (unsigned char)c;
	i = 0;
	while (i <= s_len)
	{
		if (s[i] == searched)
			to_return = (char *)(&(s[i]));
		i++;
	}
	return (to_return);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x9be0
movzbl %bpl, %edx
incq %rax
xorl %ecx, %ecx
subq $0x1, %rax
jb 0x9c5e
movsbl (%rbx), %esi
cmpl %esi, %edx
cmoveq %rbx, %rcx
incq %rbx
jmp 0x9c4a
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_strtrim.c
// Function: ft_strtrim
char		*ft_strtrim(char const *s1, char const *set)
{
	int		i;
	int		j;
	int		size;
	char	*result;

	i = 0;
	j = 0;
	size = 0;
	if (!s1 || !set)
		return (NULL);
	while (s1[i] && is_to_trim(s1[i], set))
		i++;
	if (s1[i])
		size = ft_size(&s1[i], set);
	if (!(result = (char *)ft_calloc(size + 1, sizeof(char))))
		return (NULL);
	while (s1[i] && j < size)
		result[j++] = s1[i++];
	return (result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x9d26
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movb (%r15), %al
testb %al, %al
je 0x9caf
movsbl %al, %edi
movq %r14, %rsi
callq 0x9d32
testl %eax, %eax
je 0x9cb4
incl %r12d
incq %r15
jmp 0x9c91
xorl %r14d, %r14d
jmp 0x9cf3
movq %r15, %rdi
callq 0x9be0
movslq %eax, %rcx
leaq (%r15,%rcx), %r13
decq %r13
movl %eax, %r15d
movb (%r13), %al
testb %al, %al
je 0x9ce9
movsbl %al, %edi
movq %r14, %rsi
callq 0x9d32
movl %eax, %ecx
leal -0x1(%r15), %eax
decq %r13
testl %ecx, %ecx
jne 0x9cc6
xorl %r14d, %r14d
testl %r15d, %r15d
cmovgl %r15d, %r14d
leal 0x1(%r14), %edi
pushq $0x1
popq %rsi
callq 0xa47c
testq %rax, %rax
je 0x9d26
movl %r14d, %ecx
movl %r12d, %edx
addq %rdx, %rbx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
testb %sil, %sil
je 0x9d28
cmpq %rcx, %rdx
jae 0x9d28
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x9d0f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*newcpy;
	size_t	i;
	size_t	s_len;

	i = 0;
	if (s == NULL)
		return (NULL);
	s_len = ft_strlen(s);
	if ((newcpy = (char *)ft_calloc(len + 1, sizeof(*newcpy))) == NULL)
		return (NULL);
	if (start < s_len)
		while (i < len && s[start])
			newcpy[i++] = s[start++];
	return (newcpy);
}

// Assembly:
testq %rdi, %rdi
je 0x9d9b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x9be0
movq %rax, %r15
leaq 0x1(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0xa47c
testq %rax, %rax
je 0x9d9e
movl %ebp, %ecx
cmpq %rcx, %r15
jbe 0x9da0
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x9da0
leaq (%rcx,%rdx), %rsi
movl %esi, %esi
movb (%r14,%rsi), %sil
testb %sil, %sil
je 0x9da0
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x9d7e
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/charMstr[P]minishell/libft/ft_lstclear.c
// Function: ft_lstclear
void	ft_lstclear(t_list **lst, void (*del)(void *))
{
	t_list	*current;
	t_list	*then;

	if (!lst || !*lst)
		return ;
	current = *lst;
	while (current)
	{
		then = current->next;
		ft_lstdelone(current, del);
		current = then;
	}
	*lst = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x9e1f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9e1a
movq %rsi, %r14
testq %rdi, %rdi
je 0x9e16
movq 0x8(%rdi), %r15
movq %r14, %rsi
callq 0x9e20
movq %r15, %rdi
jmp 0x9e00
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq