LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24dd(%rip), %rdi      # 0xb72c
movl $0x1, %esi
callq 0x9f24
testq %rbx, %rbx
je 0x927c
movq %rbx, %rdi
callq 0xa5c8
testl %eax, %eax
je 0x928f
leaq 0x24fb(%rip), %rdi      # 0xb76c
movl %eax, %esi
xorl %eax, %eax
callq 0x20c0
jmp 0x929b
leaq 0x26ce(%rip), %rdi      # 0xb951
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
leaq 0x26d4(%rip), %rdi      # 0xb96a
callq 0x2050
leaq 0x24f1(%rip), %rdi      # 0xb793
movl $0x1, %esi
callq 0x9f24
leaq 0x2507(%rip), %r14      # 0xb7ba
movzbl (%rbx), %eax
cmpl $0x1b, %eax
je 0x92ce
testl %eax, %eax
je 0x92e0
movsbl %al, %edi
movl $0x1, %esi
callq 0x9e5c
jmp 0x92db
movq %r14, %rdi
movl $0x1, %esi
callq 0x9f24
incq %rbx
jmp 0x92b3
leaq 0x24d7(%rip), %rdi      # 0xb7be
movl $0x1, %esi
callq 0x9f24
leaq 0x2952(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9f24
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x2419(%rip), %rdi      # 0xb72c
movl $0x1, %esi
callq 0x9f24
movl %ebx, %edi
callq 0x9c14
testl %eax, %eax
je 0x933c
leaq 0x2492(%rip), %rdi      # 0xb7c1
movl %ebx, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x20c0
jmp 0x934c
leaq 0x24aa(%rip), %rdi      # 0xb7ed
movl %ebx, %esi
xorl %eax, %eax
callq 0x20c0
leaq 0x28f7(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
popq %rbx
jmp 0x9f24
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x23c3(%rip), %rdi      # 0xb72c
movl $0x1, %esi
callq 0x9f24
movl (%rbx), %esi
movl 0x4(%rbx), %edx
leaq 0x2499(%rip), %rdi      # 0xb818
xorl %eax, %eax
callq 0x20c0
leaq 0x28bd(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
popq %rbx
jmp 0x9f24
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2386(%rip), %rbx      # 0xb72c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
leaq 0x249c(%rip), %rdi      # 0xb856
xorl %eax, %eax
callq 0x20c0
leaq 0x25c4(%rip), %rdi      # 0xb98c
callq 0x2050
leaq 0x10(%r14), %rdi
callq 0x935e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
movq 0x38(%r14), %rsi
leaq 0x24a7(%rip), %rdi      # 0xb895
xorl %eax, %eax
callq 0x20c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
movq 0x40(%r14), %rsi
leaq 0x249a(%rip), %rdi      # 0xb8a7
xorl %eax, %eax
callq 0x20c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
movl 0x48(%r14), %esi
leaq 0x248d(%rip), %rdi      # 0xb8b9
xorl %eax, %eax
callq 0x20c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
leaq 0x2583(%rip), %rdi      # 0xb9ca
callq 0x2050
movq %rbx, %rdi
movl $0x1, %esi
callq 0x9f24
leaq 0x25a8(%rip), %rdi      # 0xba08
callq 0x2050
leaq 0x27de(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9f24
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x22a7(%rip), %rdi      # 0xb72c
movl $0x1, %esi
callq 0x9f24
leaq 0x25b0(%rip), %rdi      # 0xba46
callq 0x2050
leaq 0x25e2(%rip), %rdi      # 0xba84
callq 0x2050
movl 0x10(%rsp), %esi
leaq 0x2427(%rip), %rdi      # 0xb8d9
xorl %eax, %eax
callq 0x20c0
movl 0x14(%rsp), %esi
leaq 0x2426(%rip), %rdi      # 0xb8ea
xorl %eax, %eax
callq 0x20c0
movl 0x18(%rsp), %esi
leaq 0x2421(%rip), %rdi      # 0xb8f7
xorl %eax, %eax
callq 0x20c0
movq 0x20(%rsp), %rsi
leaq 0x2419(%rip), %rdi      # 0xb902
xorl %eax, %eax
callq 0x20c0
leaq 0x2551(%rip), %rdi      # 0xba48
callq 0x2050
leaq 0x2747(%rip), %rdi      # 0xbc4a
movl $0x1, %esi
popq %rax
jmp 0x9f24
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2599(%rip), %rdi      # 0xbac1
movl $0x1, %esi
callq 0x9f24
testq %r14, %r14
je 0x958f
movq %r14, %rdi
callq 0xae84
leaq 0x2628(%rip), %r15      # 0xbb6e
testl %eax, %eax
jle 0x9596
movl %eax, %r12d
movl %r12d, %ebp
negl %ebp
movl $0x1, %r13d
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x95b1
movl $0xa, %edi
movl $0x1, %esi
callq 0x9e5c
leal 0x1(%rbp,%r13), %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0x9558
jmp 0x9596
leaq 0x25cd(%rip), %r15      # 0xbb63
movq %r15, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9f24
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %r12, %rax
shrq $0x20, %rax
incl %eax
movl %r12d, %ecx
subl %eax, %ecx
movl $0x6, %r13d
shll %cl, %r13d
testq %rdi, %rdi
je 0x9610
movq %rdi, %r14
cmpl %ebp, %eax
je 0x962f
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 0x95b1
movq 0x8(%r14), %rdi
movq %r14, %r15
jmp 0x95c7
testl %r13d, %r13d
jle 0x9699
movl $0x20, %edi
movl $0x1, %esi
callq 0x9e5c
decl %r13d
jne 0x9619
jmp 0x9699
addl $-0x6, %r13d
movl %r13d, %r12d
sarl %r12d
testl %r12d, %r12d
jle 0x9663
leal 0x1(%r12), %eax
movl %eax, 0x4(%rsp)
movl %r12d, %ebp
movl $0x20, %edi
movl $0x1, %esi
callq 0x9e5c
decl %ebp
jne 0x964a
movl 0x4(%rsp), %ebp
jmp 0x9668
movl $0x1, %ebp
movq 0x10(%r14), %rdi
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq *%rbx
cmpl %r13d, %ebp
jg 0x9699
testl %r12d, %r12d
cmovgl %r12d, %r14d
movl $0x20, %edi
movl $0x1, %esi
callq 0x9e5c
incl %r14d
cmpl %r13d, %r14d
jl 0x9682
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/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 0x255f(%rip), %rdi      # 0xbc12
xorl %eax, %eax
callq 0x20c0
testq %rbx, %rbx
je 0x96e4
movq %rbx, %rdi
callq 0x640d
testl %eax, %eax
je 0x96f0
movq %rbx, %rdi
callq 0x640d
cmpl $0x1, %eax
jne 0x96fc
leaq 0x1d92(%rip), %rdi      # 0xb471
jmp 0x984f
leaq 0x2688(%rip), %rdi      # 0xbd73
jmp 0x984f
leaq 0x1dc0(%rip), %rdi      # 0xb4b7
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x2, %eax
jne 0x9715
leaq 0x1d74(%rip), %rdi      # 0xb484
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x3, %eax
jne 0x972e
leaq 0x1d60(%rip), %rdi      # 0xb489
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x4, %eax
jne 0x9747
leaq 0x1d4d(%rip), %rdi      # 0xb48f
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x5, %eax
jne 0x9760
leaq 0x1d38(%rip), %rdi      # 0xb493
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x6, %eax
jne 0x9779
leaq 0x1d02(%rip), %rdi      # 0xb476
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x7, %eax
jne 0x9792
leaq 0x1cf0(%rip), %rdi      # 0xb47d
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x8, %eax
jne 0x97ab
leaq 0x1cf4(%rip), %rdi      # 0xb49a
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0x9, %eax
jne 0x97c4
leaq 0x1ce3(%rip), %rdi      # 0xb4a2
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xa, %eax
jne 0x97da
leaq 0x1cda(%rip), %rdi      # 0xb4b2
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xb, %eax
jne 0x97f0
leaq 0x1cc3(%rip), %rdi      # 0xb4b1
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xc, %eax
jne 0x9806
leaq 0x1ca7(%rip), %rdi      # 0xb4ab
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xd, %eax
jne 0x981c
leaq 0x1c90(%rip), %rdi      # 0xb4aa
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xe, %eax
jne 0x9832
leaq 0x2579(%rip), %rdi      # 0xbda9
jmp 0x984f
movq %rbx, %rdi
callq 0x640d
cmpl $0xf, %eax
leaq 0x2560(%rip), %rax      # 0xbda4
leaq 0x253b(%rip), %rdi      # 0xbd86
cmoveq %rax, %rdi
callq 0x2050
leaq 0x23ef(%rip), %rdi      # 0xbc4a
xorl %eax, %eax
popq %rbx
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O1/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 0x9897
pushq %rbx
movq %rdi, %rbx
leaq 0x23dc(%rip), %rdi      # 0xbc4f
xorl %eax, %eax
callq 0x20c0
movl 0x10(%rbx), %eax
addl $-0xa, %eax
cmpl $0x3, %eax
ja 0x98a5
movl %eax, %eax
leaq 0x2826(%rip), %rcx      # 0xc0b4
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
jmp 0x98ac
leaq 0x2382(%rip), %rdi      # 0xbc20
xorl %eax, %eax
jmp 0x20c0
leaq 0x2506(%rip), %rdi      # 0xbdb2
callq 0x2050
movq 0x8(%rbx), %rsi
leaq 0x23a1(%rip), %rdi      # 0xbc5d
xorl %eax, %eax
popq %rbx
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O1/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 0x1dda(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x24e5(%rip), %rdi      # 0xbdc4
callq 0x2050
testq %rbx, %rbx
je 0x9976
leaq 0x250f(%rip), %rdi      # 0xbe03
callq 0x2050
cmpq $0x0, 0x8(%rbx)
jne 0x990e
leaq 0x23a2(%rip), %rdi      # 0xbca9
xorl %eax, %eax
callq 0x20c0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x9943
leaq 0x23be(%rip), %r14      # 0xbcdc
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdx
testq %rdx, %rdx
je 0x9943
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x20c0
incq %r15
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0x9921
leaq 0x24bf(%rip), %rdi      # 0xbe09
callq 0x2050
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9965
movq (%rbx), %rdi
callq 0x9863
movq 0x8(%rbx), %rbx
jmp 0x9952
leaq 0x24a5(%rip), %rdi      # 0xbe11
popq %rbx
popq %r14
popq %r15
jmp 0x2050
leaq 0x22f5(%rip), %rdi      # 0xbc72
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20c0
// File: /workspace/github_c_makefile_star2_O1/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 0x1d15(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x24ac(%rip), %rdi      # 0xbe50
callq 0x2050
leaq 0x24df(%rip), %r14      # 0xbe8f
testq %rbx, %rbx
je 0x99eb
cmpq $0x0, (%rbx)
je 0x99eb
movq (%rbx), %rsi
leaq 0x24e1(%rip), %r14      # 0xbea6
testq %rsi, %rsi
je 0x99eb
addq $0x8, %rbx
leaq 0x1bdd(%rip), %r15      # 0xb5b2
movq %r15, %rdi
xorl %eax, %eax
callq 0x20c0
movq (%rbx), %rsi
addq $0x8, %rbx
testq %rsi, %rsi
jne 0x99d5
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x1caa(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x24d6(%rip), %rdi      # 0xbee5
callq 0x2050
movq (%rbx), %rsi
leaq 0x22d4(%rip), %rdi      # 0xbcf2
xorl %eax, %eax
callq 0x20c0
cmpl $0x0, 0x14(%rbx)
je 0x9a62
leaq 0x2511(%rip), %rdi      # 0xbf43
callq 0x2050
movl 0x18(%rbx), %esi
leaq 0x22c6(%rip), %rdi      # 0xbd07
xorl %eax, %eax
callq 0x20c0
movl 0x1c(%rbx), %esi
leaq 0x22c0(%rip), %rdi      # 0xbd12
xorl %eax, %eax
callq 0x20c0
leaq 0x2501(%rip), %rdi      # 0xbf61
jmp 0x9a69
leaq 0x24bb(%rip), %rdi      # 0xbf24
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x1c30(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x2517(%rip), %rdi      # 0xbfa0
callq 0x2050
testq %rbx, %rbx
je 0x9aba
leaq 0x2281(%rip), %r14      # 0xbd1b
xorl %esi, %esi
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
testq %rbx, %rbx
jne 0x9a9c
leaq 0x251e(%rip), %rdi      # 0xbfdf
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/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 0x1bd5(%rip), %rdi      # 0xb6ad
callq 0x2050
leaq 0x253a(%rip), %rdi      # 0xc01e
callq 0x2050
movq (%rbx), %rsi
leaq 0x21ff(%rip), %rdi      # 0xbcf2
xorl %eax, %eax
callq 0x20c0
movsbl 0x10(%rbx), %esi
leaq 0x2229(%rip), %rdi      # 0xbd2e
xorl %eax, %eax
callq 0x20c0
leaq 0x254a(%rip), %rdi      # 0xc05d
callq 0x2050
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x9b40
leaq 0x2231(%rip), %rbx      # 0xbd59
movq (%r14), %rax
movl (%rax), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20c0
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x9b28
leaq 0x252c(%rip), %rdi      # 0xc073
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9b67
incq %rax
jmp 0x9b56
cmpl $0x20, %ecx
je 0x9b62
cmpl $0x2b, %ecx
je 0x9b7f
cmpl $0x2d, %ecx
jne 0x9b81
incl %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x9b86
incl %eax
movl $0x1, %ecx
movslq %eax, %rsi
movb (%rdi,%rsi), %dl
leal -0x30(%rdx), %r8d
xorl %eax, %eax
cmpb $0x9, %r8b
ja 0x9bba
addq %rdi, %rsi
incq %rsi
xorl %eax, %eax
movsbl %dl, %edx
leal (%rax,%rax,4), %eax
leal (%rdx,%rax,2), %eax
addl $-0x30, %eax
movb (%rsi), %dl
leal -0x30(%rdx), %edi
incq %rsi
cmpb $0xa, %dil
jb 0x9ba0
imull %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x9c51
cmpb $0x0, (%rdi)
je 0x9c49
movb (%rdi), %cl
testb %cl, %cl
je 0x9c43
incq %rdi
cmpb %sil, %cl
jne 0x9c51
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x9c35
movl $0x1, %eax
retq
xorl %eax, %eax
testb %sil, %sil
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9c7d
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x9c7d
movq %rsi, %rbx
movsbl (%r14), %edi
testl %edi, %edi
je 0x9c86
callq *%rbx
incq %r14
testl %eax, %eax
jne 0x9c68
xorl %eax, %eax
jmp 0x9c8b
xorl %eax, %eax
testl %edx, %edx
sete %al
jmp 0x9c8b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
leal -0xa(%rbx), %ebp
cmpl $-0x14, %ebp
ja 0x9ccf
movl %ebx, %eax
incl %r14d
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
leal (%rcx,%rdx), %eax
addl %edx, %ecx
addl $-0xa, %ecx
cmpl $-0x13, %ecx
jb 0x9cab
leal 0x2(%r14), %eax
movslq %eax, %rdi
callq 0x2190
testq %rax, %rax
je 0x9d89
movslq %r14d, %rcx
movb $0x0, 0x1(%rax,%rcx)
cmpl $-0x14, %ebp
ja 0x9d68
incq %rcx
movslq %ecx, %rcx
addq %rax, %rcx
decq %rcx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movslq %ebx, %rsi
testl %ebx, %ebx
js 0x9d21
movl %ebx, %edi
imulq %rdx, %rdi
shrq $0x23, %rdi
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
negl %edi
addl %ebx, %edi
addl $0x30, %edi
jmp 0x9d40
imulq $0x66666667, %rsi, %rdi # imm = 0x66666667
movq %rdi, %r8
shrq $0x3f, %r8
sarq $0x22, %rdi
addl %r8d, %edi
addl %edi, %edi
leal (%rdi,%rdi,4), %edi
subl %ebx, %edi
addl $0x30, %edi
movb %dil, (%rcx)
imulq $0x66666667, %rsi, %rsi # imm = 0x66666667
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x22, %rsi
leal (%rsi,%rdi), %ebx
addl %edi, %esi
addl $-0xa, %esi
decl %r14d
decq %rcx
cmpl $-0x13, %esi
jb 0x9d02
testl %ebx, %ebx
js 0x9d8d
movl %ebx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x23, %rdx
addl %edx, %edx
leal (%rdx,%rdx,4), %ecx
negl %ecx
addl %ebx, %ecx
addl $0x30, %ecx
jmp 0x9dae
xorl %eax, %eax
jmp 0x9dbf
movslq %ebx, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ebx, %ecx
addl $0x30, %ecx
movslq %r14d, %rdx
movb %cl, (%rax,%rdx)
movb $0x2d, %cl
cmpl $0x1, %edx
je 0x9dbd
movb (%rax), %cl
movb %cl, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9e25
testq %rdx, %rdx
je 0x9e49
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x9e13
jmp 0x9e49
setbe %cl
testq %rdx, %rdx
sete %dil
orb %cl, %dil
jne 0x9e49
movq %rdx, %rcx
movb -0x1(%rsi,%rdx), %dil
movb %dil, -0x1(%rax,%rdx)
decq %rcx
movq %rcx, %rdx
jne 0x9e37
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %ebp
leaq 0x2215(%rip), %r14      # 0xc0c4
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
movl %ebp, %r15d
negl %r15d
jno 0x9ec9
movq %r14, %rdi
movl %ebx, %esi
callq 0x9f24
jmp 0x9edc
testl %ebp, %ebp
jns 0x9edc
movl $0x2d, %edi
movl %ebx, %esi
callq 0x9e5c
movl %r15d, %ebp
cmpl $0x9, %ebp
jbe 0x9f03
jle 0x9f1a
movl %ebp, %r15d
imulq %r12, %r15
shrq $0x23, %r15
movl %r15d, %edi
movl %ebx, %esi
callq 0x9e9c
addl %r15d, %r15d
leal (%r15,%r15,4), %eax
subl %eax, %ebp
jmp 0x9eb5
orb $0x30, %bpl
movsbl %bpl, %edi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9e5c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa3b2
movq %rsi, %r14
movq %rdi, %rbp
callq 0xa3c6
cltq
leaq 0x8(,%rax,8), %rdi
callq 0x2190
testq %rax, %rax
je 0xa3b2
movq %rax, %rbx
movq %rbp, %rdi
movq %r14, %rsi
callq 0xa3c6
movslq %eax, %rcx
movq $0x0, (%rbx,%rcx,8)
testl %ecx, %ecx
jle 0xa3b4
movq %rbx, 0x10(%rsp)
movl %eax, %eax
movq %rax, 0x20(%rsp)
leaq 0x1(%rbp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movl $0x1, %r13d
xorl %ebx, %ebx
movq %rbp, 0x18(%rsp)
movslq %ebx, %r15
movb (%rbp,%r15), %al
testb %al, %al
je 0xa280
addq (%rsp), %r15
movsbl %al, %esi
movq %r14, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
je 0xa280
incl %ebx
movb (%r15), %al
incq %r15
testb %al, %al
jne 0xa264
movslq %ebx, %r15
movb (%rbp,%r15), %al
movl %ebx, %r12d
testb %al, %al
je 0xa2b7
movq (%rsp), %rcx
leaq (%rcx,%r15), %rbp
movl %ebx, %r12d
movsbl %al, %esi
movq %r14, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
je 0xa2b7
incl %r12d
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0xa29a
movslq %r12d, %rbp
movq 0x18(%rsp), %rax
movb (%rax,%rbp), %al
testb %al, %al
je 0xa2e7
addq (%rsp), %rbp
movsbl %al, %esi
movq %r14, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
jne 0xa2e7
incl %r12d
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0xa2ca
subl %ebx, %r12d
incl %r12d
movslq %r12d, %rdi
callq 0x2190
movq %rax, %r12
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %r12, (%rax,%rcx,8)
testq %r12, %r12
je 0xa381
movq 0x18(%rsp), %rbp
movb (%rbp,%r15), %al
testb %al, %al
je 0xa34d
addq (%rsp), %r15
xorl %ebp, %ebp
movsbl %al, %esi
movq %r14, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
jne 0xa351
movb -0x1(%r15,%rbp), %al
leaq 0x1(%rbp), %rcx
movb %al, (%r12,%rbp)
movb (%r15,%rbp), %al
movq %rcx, %rbp
testb %al, %al
jne 0xa31f
addl %ecx, %ebx
movl %ecx, %ebp
jmp 0xa353
xorl %eax, %eax
jmp 0xa35a
addl %ebp, %ebx
movl %ebp, %eax
movq 0x18(%rsp), %rbp
movq 0x8(%rsp), %rcx
incq %rcx
movb $0x0, (%r12,%rax)
incq %r13
movq %rcx, 0x8(%rsp)
cmpq 0x20(%rsp), %rcx
jne 0xa254
movq 0x10(%rsp), %rbx
jmp 0xa3b4
cmpq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rbx
je 0xa3aa
movq -0x10(%rbx,%r13,8), %rdi
callq 0x2240
movq $0x0, -0x10(%rbx,%r13,8)
decq %r13
cmpq $0x1, %r13
jg 0xa38e
movq %rbx, %rdi
callq 0x2240
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpb $0x0, (%rdi)
je 0xa466
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %r15
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq %r12d, %r13
movb (%r14,%r13), %al
testb %al, %al
je 0xa411
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
je 0xa411
incl %r12d
movb 0x1(%r14,%r13), %al
incq %r13
jmp 0xa3f0
movb (%r14,%r13), %al
testb %al, %al
je 0xa42e
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa8fc
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %cl
addl %ecx, %ebp
movslq %r12d, %r13
movb (%r14,%r13), %al
testb %al, %al
je 0xa45a
addq %r15, %r13
movsbl %al, %esi
movq %rbx, %rdi
callq 0xa8fc
cmpl $-0x1, %eax
jne 0xa45a
incl %r12d
movb (%r13), %al
incq %r13
testb %al, %al
jne 0xa43c
movslq %r12d, %rax
cmpb $0x0, (%r14,%rax)
jne 0xa3e9
jmp 0xa468
xorl %ebp, %ebp
movl %ebp, %eax
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/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 0xa5c8
movq %rax, %rcx
movsbl %bpl, %edx
xorl %eax, %eax
xorl %esi, %esi
movsbl (%rbx,%rsi), %edi
cmpl %edi, %edx
je 0xa4a6
incq %rsi
cmpq %rcx, %rsi
jbe 0xa494
jmp 0xa4ac
addq %rsi, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa576
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5c8
movq %rax, %r15
movq %rbx, %rdi
callq 0xa5c8
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x2190
xorl %ecx, %ecx
testq %rax, %rax
je 0xa579
movb (%r14), %dl
testb %dl, %dl
je 0xa54e
xorl %ecx, %ecx
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xa53f
movb (%rbx), %dl
testb %dl, %dl
je 0xa56e
movl %ecx, %ecx
movq %rax, %rdi
addq %rcx, %rdi
xorl %esi, %esi
movb %dl, (%rdi,%rsi)
movb 0x1(%rbx,%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0xa55e
addl %esi, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
jmp 0xa57b
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xa4f8
movq %rax, %rbx
testb $0x1, %bpl
je 0xa5ae
leaq 0x10(%rsp), %rdi
callq 0xaa9c
testb $0x2, %bpl
je 0xa5be
leaq 0x8(%rsp), %rdi
callq 0xaa9c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %eax, %eax
cmpb $0x0, (%rdi)
je 0xa5fe
xorl %r8d, %r8d
cmpb $0x0, (%rsi,%r8)
je 0xa602
leaq 0x1(%r8), %rcx
cmpb $0x0, 0x1(%rdi,%r8)
movq %rcx, %r8
jne 0xa5e6
jmp 0xa605
xorl %ecx, %ecx
jmp 0xa605
movq %r8, %rcx
testq %rdx, %rdx
je 0xa62f
xorl %r8d, %r8d
movzbl (%rdi,%r8), %eax
movzbl (%rsi,%r8), %r9d
cmpb %r9b, %al
jne 0xa630
leaq 0x1(%r8), %r9
xorl %eax, %eax
cmpq %rdx, %r9
jae 0xa62f
cmpq %rcx, %r8
movq %r9, %r8
jb 0xa60d
retq
subl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa5c8
movzbl %bpl, %edx
leaq 0x1(%rax), %rcx
cmpq $0x1, %rcx
adcq $0x1, %rax
xorl %ecx, %ecx
movsbl (%rbx), %esi
cmpl %esi, %edx
cmoveq %rbx, %rcx
incq %rbx
decq %rax
jne 0xa653
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0xa763
movq %rdi, %rbx
movb (%rdi), %al
movl $0x0, %r15d
testb %al, %al
sete %cl
je 0xa71d
movq %rsi, %r14
xorl %r12d, %r12d
movq %r14, %rdx
movb (%rdx), %sil
testb %sil, %sil
je 0xa6ba
incq %rdx
cmpb %al, %sil
jne 0xa6aa
testb %sil, %sil
je 0xa6d3
movb 0x1(%rbx,%r12), %al
incq %r12
testb %al, %al
sete %cl
jne 0xa6a7
xorl %r15d, %r15d
jmp 0xa71d
xorl %r15d, %r15d
testb $0x1, %cl
jne 0xa71d
movq %r12, %r15
addq %rbx, %r15
movq %r15, %rdi
callq 0xa5c8
movslq %eax, %rcx
movq %rcx, %rax
movb -0x1(%r15,%rcx), %dl
testb %dl, %dl
je 0xa714
leaq -0x1(%rax), %rcx
movq %r14, %rsi
movb (%rsi), %dil
testb %dil, %dil
je 0xa70f
incq %rsi
cmpb %dl, %dil
jne 0xa6ff
testb %dil, %dil
jne 0xa6ec
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
leal 0x1(%r15), %edi
movl $0x1, %esi
callq 0xaf3c
testq %rax, %rax
je 0xa763
movl %r12d, %esi
movb (%rbx,%rsi), %cl
testb %cl, %cl
je 0xa765
testl %r15d, %r15d
je 0xa765
movl %r15d, %edx
addq %rsi, %rbx
movl $0x1, %esi
movb %cl, -0x1(%rax,%rsi)
movb (%rbx,%rsi), %cl
testb %cl, %cl
je 0xa765
leaq 0x1(%rsi), %rdi
cmpq %rdx, %rsi
movq %rdi, %rsi
jb 0xa74a
jmp 0xa765
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xa7d3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xa5c8
movq %rax, %r15
leaq 0x1(%rbx), %rdi
movl $0x1, %esi
callq 0xaf3c
testq %rax, %rax
je 0xa7d6
movl %ebp, %ecx
cmpq %rcx, %r15
setbe %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0xa7d8
xorl %edx, %edx
leal (%rcx,%rdx), %esi
movb (%r14,%rsi), %sil
testb %sil, %sil
je 0xa7d8
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rbx
jne 0xa7b9
jmp 0xa7d8
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_O1/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 0xa858
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa853
movq %rsi, %r14
movq 0x8(%rdi), %r15
movq %r14, %rsi
callq 0xa85c
movq %r15, %rdi
testq %r15, %r15
jne 0xa838
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_lstdelone.c
// Function: ft_lstdelone
void	ft_lstdelone(t_list *lst, void (*del)(void *))
{
	if (lst)
	{
		if (del)
			del(lst->content);
		free(lst);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xa878
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa86f
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
popq %rbx
jmp 0x2240
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strichr.c
// Function: ft_strichr
int	ft_strichr(const char *str, char c)
{
	int index;

	index = 0;
	if (!str)
		return (-1);
	while (str[index])
	{
		if (str[index] == c)
			return (index);
		index++;
	}
	return (-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0xa91e
movb (%rdi), %dl
testb %dl, %dl
je 0xa91e
xorl %ecx, %ecx
cmpb %sil, %dl
je 0xa91f
movb 0x1(%rdi,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0xa90e
retq
movl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_array_free.c
// Function: ft_array_free
void	*ft_array_free(char **ptr, int k)
{
	if (!ptr)
		return (NULL);
	while (--k >= 0)
	{
		free(ptr[k]);
		ptr[k] = NULL;
	}
	free(ptr);
	ptr = NULL;
	return (NULL);
}

// Assembly:
testq %rdi, %rdi
je 0xa965
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0xa956
movl %esi, %r14d
incq %r14
movq -0x10(%rbx,%r14,8), %rdi
callq 0x2240
movq $0x0, -0x10(%rbx,%r14,8)
decq %r14
cmpq $0x1, %r14
jg 0xa93a
movq %rbx, %rdi
callq 0x2240
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_stristr.c
// Function: ft_stristr
int	ft_stristr(const char *str, char *stack)
{
	int i;
	int j;

	if (!str || !stack)
		return (-1);
	i = 0;
	j = 0;
	while (str[i])
	{
		j = 0;
		while (stack[j])
		{
			if (str[i] == stack[j])
				return (i);
			j++;
		}
		i++;
	}
	return (-1);
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0xa9b6
movb (%rdi), %cl
testb %cl, %cl
je 0xa9b6
movb (%rsi), %dl
incq %rsi
xorl %r8d, %r8d
movq %rsi, %r9
movl %edx, %r10d
testb %dl, %dl
je 0xa9a5
cmpb %r10b, %cl
je 0xa9b3
movb (%r9), %r10b
incq %r9
testb %r10b, %r10b
jne 0xa995
movb 0x1(%rdi,%r8), %cl
incq %r8
testb %cl, %cl
jne 0xa98b
jmp 0xa9b6
movl %r8d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strappend.c
// Function: ft_strappend
int	ft_strappend(char **str, char c)
{
	char *char_str;

	char_str = (char	[2]){c, '\0'};
	if (!*str)
	{
		if (!(*str = ft_strdup(char_str)))
			return (0);
	}
	else if (!(*str = ft_strjoin_free(*str, char_str, 1)))
		return (0);
	return (1);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb %sil, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa9fb
leaq 0xe(%rsp), %rsi
movl $0x1, %edx
callq 0xa584
jmp 0xaa05
leaq 0xe(%rsp), %rdi
callq 0xa4b4
movq %rax, (%rbx)
testq %rax, %rax
je 0xaa14
movl $0x1, %eax
jmp 0xaa16
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
int	ft_strcmp(const char *s1, const char *s2)
{
	int i;

	i = 0;
	while (s1[i] == s2[i])
	{
		if (s1[i] == '\0')
			return (0);
		i++;
	}
	return ((unsigned)s1[i] - (unsigned)s2[i]);
}

// Assembly:
movb (%rdi), %al
movb (%rsi), %dl
cmpb %dl, %al
jne 0xaa8e
movl $0x1, %ecx
testb %al, %al
je 0xaa97
movb (%rdi,%rcx), %al
movb (%rsi,%rcx), %dl
incq %rcx
cmpb %dl, %al
je 0xaa7d
movsbl %al, %eax
movsbl %dl, %ecx
subl %ecx, %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strcadd.c
// Function: ft_strcadd
int	ft_strcadd(char **str, char c, size_t index)
{
	size_t	tt_len;
	char	*new;
	size_t	j;

	tt_len = ft_strlen(*str) + 1;
	j = 0;
	if (!(new = (char*)malloc(sizeof(char) * (tt_len + 1))))
	{
		ft_free((void **)str);
		return (0);
	}
	new[tt_len] = '\0';
	while (j < index && j < (tt_len - 1))
	{
		new[j] = str[0][j];
		j++;
	}
	new[j] = c;
	while (++j < tt_len)
		new[j] = str[0][j - 1];
	ft_free((void**)str);
	*str = new;
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xa5c8
movq %rax, %r14
leaq 0x2(%rax), %rdi
callq 0x2190
testq %rax, %rax
je 0xab0d
movq %rax, %r15
leaq 0x1(%r14), %rcx
movb $0x0, 0x1(%rax,%r14)
cmpq %r14, %r12
cmovaeq %r14, %r12
testq %r12, %r12
je 0xab19
movq (%rbx), %rdx
xorl %eax, %eax
movb (%rdx,%rax), %sil
movb %sil, (%r15,%rax)
incq %rax
cmpq %rax, %r12
jne 0xaafb
jmp 0xab1b
movq %rbx, %rdi
callq 0xaa9c
xorl %eax, %eax
jmp 0xab4b
xorl %eax, %eax
movb %bpl, (%r15,%rax)
leaq 0x1(%rax), %rdx
cmpq %rcx, %rdx
jae 0xab3b
movq (%rbx), %rcx
movb (%rcx,%rax), %dl
movb %dl, 0x1(%r15,%rax)
incq %rax
cmpq %rax, %r14
jne 0xab2b
movq %rbx, %rdi
callq 0xaa9c
movq %r15, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strcdel.c
// Function: ft_strcdel
void	ft_strcdel(char *str, size_t i)
{
	size_t	len;

	if (!str || !ft_strlen(str))
		return ;
	len = ft_strlen(str);
	if (i >= len)
		return ;
	ft_memmove(str + i, str + i + 1, len - i);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xab94
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5c8
testq %rax, %rax
je 0xab94
movq %r14, %rdi
callq 0xa5c8
subq %rbx, %rax
jbe 0xab94
leaq (%r14,%rbx), %rdi
leaq (%r14,%rbx), %rsi
incq %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9e04
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_strstradd.c
// Function: ft_strstradd
int			ft_strstradd(char **dst, int start, char *src)
{
	int len;

	if (!dst || !src)
	{
		ft_free((void**)dst);
		return (0);
	}
	len = ft_strlen(*dst);
	if (start > len)
		start = len;
	if (!(*dst))
	{
		if (!(*dst = ft_strdup(src)))
			return (0);
	}
	else if (!ft_strstradd_assist(dst, start, src))
	{
		ft_free((void**)dst);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rdx, %rdx
setne %cl
testb %cl, %al
je 0xac21
movq %rdx, %r14
movl %esi, %ebp
movq (%rbx), %rdi
callq 0xa5c8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xac37
cmpl %ebp, %eax
cmovll %eax, %ebp
movslq %ebp, %r15
xorl %ebp, %ebp
xorl %esi, %esi
movq %r15, %rdx
callq 0xa774
testq %rax, %rax
je 0xac2d
movq %rax, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xa584
testq %rax, %rax
je 0xac2d
addq (%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0xa584
testq %rax, %rax
je 0xac2d
movq %rax, %r14
movq %rbx, %rdi
callq 0xaa9c
movq %r14, (%rbx)
jmp 0xac47
movq %rbx, %rdi
callq 0xaa9c
xorl %ebp, %ebp
jmp 0xac4c
movq %rbx, %rdi
callq 0xaa9c
jmp 0xac4c
movq %r14, %rdi
callq 0xa4b4
movq %rax, (%rbx)
testq %rax, %rax
je 0xac29
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_dlstadd_front.c
// Function: ft_dlstadd_front
void	ft_dlstadd_front(t_dlist **alst, t_dlist *new)
{
	if (!alst || !new)
		return ;
	if (*alst)
	{
		(*alst)->previous = new;
		new->next = *alst;
	}
	*alst = new;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaca6
movq (%rdi), %rax
testq %rax, %rax
je 0xaca3
movq %rsi, 0x10(%rax)
movq (%rdi), %rax
movq %rax, 0x8(%rsi)
movq %rsi, (%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_dlstclear.c
// Function: ft_dlstclear
void	ft_dlstclear(t_dlist **lst, void (*del)(void *))
{
	t_dlist	*current;
	t_dlist	*then;

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

// Assembly:
testq %rdi, %rdi
je 0xad05
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xad00
movq %rsi, %r14
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0xacdd
movq 0x8(%rdi), %r15
movq %r14, %rsi
callq 0xad08
movq %r15, %rdi
testq %r15, %r15
jne 0xacc9
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xacf9
movq 0x10(%rdi), %r15
movq %r14, %rsi
callq 0xad08
movq %r15, %rdi
testq %r15, %r15
jne 0xace5
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/charMstr[P]minishell/libft/ft_dlstdelone.c
// Function: ft_dlstdelone
void	ft_dlstdelone(t_dlist *lst, void (*del)(void *))
{
	if (lst)
	{
		if (del)
			del(lst->content);
		free(lst);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xad24
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xad1b
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
popq %rbx
jmp 0x2240
retq
nopl (%rax)