LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x3ad6(%rip), %rdi      # 0x119ed
movl $0x1, %esi
callq 0xf020
cmpq $0x0, -0x8(%rbp)
jne 0xdf3b
leaq 0x3b60(%rip), %rdi      # 0x11a8f
movl $0x1, %esi
callq 0xf020
jmp 0xdfac
movq -0x8(%rbp), %rdi
callq 0x10da0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl -0x1c(%rbp), %eax
jg 0xdf9b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x1c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x2c(%rbp), %rsi
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
callq 0xdfc0
movl $0xa, %edi
movl $0x1, %esi
callq 0xef10
jmp 0xdf55
leaq 0x3af8(%rip), %rdi      # 0x11a9a
movl $0x1, %esi
callq 0xf020
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x1c(%rbp)
movl %edx, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x40(%rbp)
movl -0xc(%rbp), %ecx
subl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
imull $0x6, %eax, %eax
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe03b
jmp 0xe015
movl -0x40(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x40(%rbp)
cmpl -0x3c(%rbp), %eax
jge 0xe036
movl $0x20, %edi
movl $0x1, %esi
callq 0xef10
jmp 0xe015
jmp 0xe108
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0xe0b5
jmp 0xe045
movl -0x40(%rbp), %eax
movl %eax, -0x64(%rbp)
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
subl $0x6, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0xe079
movl $0x20, %edi
movl $0x1, %esi
callq 0xef10
jmp 0xe045
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, %al
callq *%rcx
movl -0x40(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x40(%rbp)
movl -0x3c(%rbp), %ecx
subl $0x6, %ecx
cmpl %ecx, %eax
jg 0xe0b3
movl $0x20, %edi
movl $0x1, %esi
callq 0xef10
jmp 0xe08d
jmp 0xe108
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0xdfc0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movl -0x58(%rbp), %edx
callq 0xdfc0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe3b6
leaq 0x383d(%rip), %rdi      # 0x11be7
movb $0x0, %al
callq 0x20b0
jmp 0xe43a
leaq 0x3859(%rip), %rdi      # 0x11c16
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
cmpl $0xc, 0x10(%rax)
jne 0xe3de
leaq 0x37dc(%rip), %rdi      # 0x11bb1
movb $0x0, %al
callq 0x20b0
jmp 0xe424
movq -0x8(%rbp), %rax
cmpl $0xd, 0x10(%rax)
jne 0xe3f8
leaq 0x37c1(%rip), %rdi      # 0x11bb0
movb $0x0, %al
callq 0x20b0
jmp 0xe422
movq -0x8(%rbp), %rax
cmpl $0xa, 0x10(%rax)
jne 0xe412
leaq 0x37a1(%rip), %rdi      # 0x11baa
movb $0x0, %al
callq 0x20b0
jmp 0xe420
leaq 0x380b(%rip), %rdi      # 0x11c24
movb $0x0, %al
callq 0x20b0
jmp 0xe422
jmp 0xe424
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x3804(%rip), %rdi      # 0x11c37
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x312e(%rip), %rdi      # 0x11588
movb $0x0, %al
callq 0x20b0
leaq 0x37e4(%rip), %rdi      # 0x11c4c
movb $0x0, %al
callq 0x20b0
cmpq $0x0, -0x8(%rbp)
jne 0xe489
leaq 0x380f(%rip), %rdi      # 0x11c8c
movb $0x0, %al
callq 0x20b0
jmp 0xe556
leaq 0x3833(%rip), %rdi      # 0x11cc3
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe4b0
leaq 0x3821(%rip), %rdi      # 0x11cca
movb $0x0, %al
callq 0x20b0
jmp 0xe4b2
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x19(%rbp)
je 0xe4d9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xe4e2
jmp 0xe50e
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x3801(%rip), %rdi      # 0x11cfd
movb $0x0, %al
callq 0x20b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe4b2
leaq 0x37fe(%rip), %rdi      # 0x11d13
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe548
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xe390
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xe527
leaq 0x37cd(%rip), %rdi      # 0x11d1c
movb $0x0, %al
callq 0x20b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x300e(%rip), %rdi      # 0x11588
movb $0x0, %al
callq 0x20b0
leaq 0x37d4(%rip), %rdi      # 0x11d5c
movb $0x0, %al
callq 0x20b0
cmpq $0x0, -0x8(%rbp)
je 0xe5a0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe5b0
leaq 0x37f5(%rip), %rdi      # 0x11d9c
movb $0x0, %al
callq 0x20b0
jmp 0xe5f4
jmp 0xe5b2
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xe5e6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x2efe(%rip), %rdi      # 0x114d2
movb $0x0, %al
callq 0x20b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe5b2
leaq 0x37c7(%rip), %rdi      # 0x11db4
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2f75(%rip), %rdi      # 0x11588
movb $0x0, %al
callq 0x20b0
leaq 0x37d3(%rip), %rdi      # 0x11df4
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x37fe(%rip), %rdi      # 0x11e34
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xe657
leaq 0x37fb(%rip), %rdi      # 0x11e49
movb $0x0, %al
callq 0x20b0
jmp 0xe69d
leaq 0x380b(%rip), %rdi      # 0x11e69
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x3815(%rip), %rdi      # 0x11e88
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0x380b(%rip), %rdi      # 0x11e93
movb $0x0, %al
callq 0x20b0
leaq 0x3806(%rip), %rdi      # 0x11e9c
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x2ebe(%rip), %rdi      # 0x11588
movb $0x0, %al
callq 0x20b0
leaq 0x3804(%rip), %rdi      # 0x11edc
movb $0x0, %al
callq 0x20b0
cmpq $0x0, -0x8(%rbp)
je 0xe717
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
leaq 0x381a(%rip), %rdi      # 0x11f1c
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe6df
leaq 0x3811(%rip), %rdi      # 0x11f2f
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2e45(%rip), %rdi      # 0x11588
movb $0x0, %al
callq 0x20b0
leaq 0x381e(%rip), %rdi      # 0x11f6f
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x36ce(%rip), %rdi      # 0x11e34
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movsbl 0x10(%rax), %esi
leaq 0x3833(%rip), %rdi      # 0x11faf
movb $0x0, %al
callq 0x20b0
leaq 0x3850(%rip), %rdi      # 0x11fda
movb $0x0, %al
callq 0x20b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe7c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
leaq 0x383d(%rip), %rdi      # 0x11ff1
movb $0x0, %al
callq 0x20b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xe79d
leaq 0x383b(%rip), %rdi      # 0x1200b
movb $0x0, %al
callq 0x20b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x15(%rbp)
je 0xe880
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x15(%rbp)
je 0xe880
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x15(%rbp)
je 0xe880
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x15(%rbp)
je 0xe880
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x15(%rbp)
je 0xe880
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xe889
jmp 0xe897
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe7fd
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0xe8b3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe8d6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0xe8d4
imull $-0x1, -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe8d6
jmp 0xe8d8
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x16(%rbp)
jl 0xe903
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0xe90c
jmp 0xe930
imull $0xa, -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
jmp 0xe8d8
movl -0x14(%rbp), %eax
imull -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xea75
movl $0x0, -0x4(%rbp)
jmp 0xead8
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xea99
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0xea90
movl $0x1, -0x4(%rbp)
jmp 0xead8
movl $0x0, -0x4(%rbp)
jmp 0xead8
jmp 0xea9b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xead1
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xeac6
movl $0x0, -0x4(%rbp)
jmp 0xead8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xea9b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0xeb0a
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xeb1f
movl -0x1c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xeb60
jmp 0xeb21
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
je 0xeb59
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %edi
callq *%rax
cmpl $0x0, %eax
jne 0xeb57
movl $0x0, -0x4(%rbp)
jmp 0xeb60
jmp 0xeb21
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0xecb0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xebaf
movq $0x0, -0x8(%rbp)
jmp 0xeca6
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movb $0x1, %al
cmpl $0x9, -0xc(%rbp)
movb %al, -0x1d(%rbp)
jg 0xebd0
cmpl $-0x9, -0xc(%rbp)
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xebd9
jmp 0xec31
cmpl $0x0, -0xc(%rbp)
jge 0xebf6
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
xorl %eax, %eax
subl %edx, %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0xec09
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0xebbb
cmpl $0x0, -0xc(%rbp)
jge 0xec4e
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
xorl %eax, %eax
subl %edx, %eax
addl $0x30, %eax
movl %eax, -0x28(%rbp)
jmp 0xec61
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x30, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
cmpl $0x1, -0x1c(%rbp)
jne 0xec89
movl $0x2d, %eax
movl %eax, -0x2c(%rbp)
jmp 0xec93
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_itoa.c
// Function: predict_size
static int	predict_size(int n)
{
	int size;

	size = 0;
	if (n < 0)
		size++;
	while (n < -9 || n > 9)
	{
		size++;
		n = n / 10;
	}
	return (++size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xeccd
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xeccf
movb $0x1, %al
cmpl $-0x9, -0x4(%rbp)
movb %al, -0x9(%rbp)
jl 0xece4
cmpl $0x9, -0x4(%rbp)
setg %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xeced
jmp 0xed06
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
jmp 0xeccf
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_memcmp.c
// Function: ft_memcmp
int		ft_memcmp(const void *s1, const void *s2, size_t n)
{
	size_t			i;
	unsigned char	*str1;
	unsigned char	*str2;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xed9b
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xed8d
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xeda2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xed48
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_memcpy.c
// Function: ft_memcpy
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	size_t			i;
	unsigned char	*dest;
	unsigned char	*srcs;

	i = 0;
	dest = (unsigned char *)dst;
	srcs = (unsigned char *)src;
	while (i < n)
	{
		dest[i] = srcs[i];
		i++;
	}
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xee06
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xedd8
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xee74
jmp 0xee44
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xee72
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xee44
jmp 0xeeb1
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0xeeaf
jmp 0xee80
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
jbe 0xeead
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xee80
jmp 0xeeaf
jmp 0xeeb1
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *b, int c, size_t len)
{
	size_t			i;
	unsigned char	*dest;
	unsigned char	src;

	i = 0;
	dest = (unsigned char *)b;
	src = (unsigned char)c;
	while (i < len)
		dest[i++] = src;
	return (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xef0a
movb -0x29(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0xeee5
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0xefab
movl -0x8(%rbp), %esi
leaq 0x30a7(%rip), %rdi      # 0x1204b
callq 0xf020
jmp 0xefc7
cmpl $0x0, -0x4(%rbp)
jge 0xefc5
imull $-0x1, -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %esi
movl $0x2d, %edi
callq 0xef10
jmp 0xefc7
cmpl $0x0, -0x4(%rbp)
jl 0xefe6
cmpl $0x9, -0x4(%rbp)
jg 0xefe6
movl -0x4(%rbp), %eax
addl $0x30, %eax
movl -0x8(%rbp), %esi
movsbl %al, %edi
callq 0xef10
jmp 0xf018
cmpl $0xa, -0x4(%rbp)
jl 0xf016
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edi
movl -0x8(%rbp), %esi
callq 0xef80
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %edi
movl -0x8(%rbp), %esi
callq 0xef80
jmp 0xf018
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0xf11b
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0xf130
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf0ed
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xf220
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jge 0xf0eb
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0xf360
movq %rax, -0x8(%rbp)
jmp 0xf123
jmp 0xf0ed
jmp 0xf0ef
cmpl $0x0, -0x18(%rbp)
jl 0xf112
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2230
jmp 0xf0ef
movq -0x20(%rbp), %rdi
callq 0x2230
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_split.c
// Function: w_len
static int		w_len(char const *s, char c)
{
	int i;
	int len;

	i = 0;
	len = 0;
	while (s[i])
	{
		while (s[i] && s[i] == c)
			i++;
		while (s[i] && s[i] != c)
			i++;
		if (s[i - 1] != c)
			len++;
	}
	return (len + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf20d
jmp 0xf160
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xf18e
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xf197
jmp 0xf1a2
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf160
jmp 0xf1a4
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
je 0xf1d2
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0xf1db
jmp 0xf1e6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf1a4
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xf208
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf14c
movl -0x14(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_split.c
// Function: ft_malloc_w_len
static int		ft_malloc_w_len(char const *s, char c, char **result)
{
	int i;
	int j;
	int len;

	i = 0;
	j = 0;
	while (s[i])
	{
		while (s[i] && s[i] == c)
			i++;
		len = 0;
		while (s[i] && s[i] != c)
		{
			i++;
			len++;
		}
		if (s[i - 1] != c)
			if (!(result[j++] = (char *)malloc(sizeof(char) * (len + 1))))
				return (j - 1);
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf345
jmp 0xf258
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2d(%rbp)
je 0xf286
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xf28f
jmp 0xf29a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf258
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2e(%rbp)
je 0xf2cf
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
testb $0x1, %al
jne 0xf2d8
jmp 0xf2ec
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xf2a1
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0xf340
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2180
movq -0x20(%rbp), %rcx
movl -0x28(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %edx, %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xf33e
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xf34c
jmp 0xf340
jmp 0xf244
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_split.c
// Function: ft_tab_filled
static char		**ft_tab_filled(char const *s, char c, char **result)
{
	int i;
	int k;
	int l;

	i = 0;
	k = 0;
	while (s[i])
	{
		while (s[i] == c && s[i])
			i++;
		l = 0;
		while (s[i] != c && s[i])
			result[k][l++] = s[i++];
		if (s[i - 1] != c)
			result[k++][l] = '\0';
	}
	result[k] = NULL;
	return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf484
jmp 0xf394
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x25(%rbp)
jne 0xf3c2
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xf3cb
jmp 0xf3d6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf394
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x26(%rbp)
je 0xf40b
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
testb $0x1, %al
jne 0xf414
jmp 0xf448
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xf3dd
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0xf47f
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xf380
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf4f2
cmpq $0x0, -0x18(%rbp)
je 0xf4f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf640
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xf4ff
movq $0x0, -0x8(%rbp)
jmp 0xf630
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf640
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0xf628
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xf750
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xf7c0
subl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x2180
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0xf587
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xf870
movq %rax, -0x8(%rbp)
jmp 0xf630
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xf5c8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xf5d1
jmp 0xf605
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xf58e
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x28(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xf51f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xf743
jmp 0xf672
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xf6ac
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xf6b5
jmp 0xf6c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf672
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xf6f4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
cmpl $-0x1, %eax
jne 0xf6f4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf6f6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0xf72a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
cmpl $-0x1, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xf733
jmp 0xf73e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6f6
jmp 0xf65e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_split_whitespaces.c
// Function: find_end
static int	find_end(char const *s, char *ifs, int next_end)
{
	while (s[next_end] && (ft_strichr(ifs, s[next_end]) != -1))
		next_end++;
	while (s[next_end] && (ft_strichr(ifs, s[next_end]) == -1))
		next_end++;
	return (next_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xf807
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
cmpl $-0x1, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xf810
jmp 0xf81b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf7d3
jmp 0xf81d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
je 0xf851
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x10280
cmpl $-0x1, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0xf85a
jmp 0xf865
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf81d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_split_whitespaces.c
// Function: free_nested
static void	*free_nested(char **ptr, int k)
{
	while (--k >= 0)
	{
		free(ptr[k]);
		ptr[k] = NULL;
	}
	free(ptr);
	ptr = NULL;
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0xf8b0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2230
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0xf87f
movq -0x8(%rbp), %rdi
callq 0x2230
movq $0x0, -0x8(%rbp)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfb10
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x29(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xf934
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
jne 0xf926
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf93c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf8fa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/charMstr[P]minishell/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*newcpy;
	size_t	src_len;

	src_len = ft_strlen(s1);
	if ((newcpy = (char *)ft_calloc(src_len + 1, sizeof(*newcpy))) == NULL)
		return (NULL);
	return (ft_memcpy(newcpy, s1, src_len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfb10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x10f20
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xf98f
movq $0x0, -0x8(%rbp)
jmp 0xf9a4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xedb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf9d5
cmpq $0x0, -0x18(%rbp)
jne 0xf9e2
movq $0x0, -0x8(%rbp)
jmp 0xfaa5
movq -0x10(%rbp), %rdi
callq 0xfb10
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfb10
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x2180
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0xfa2b
movq $0x0, -0x8(%rbp)
jmp 0xfaa5
jmp 0xfa2d
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xfa5e
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xfa2d
jmp 0xfa60
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xfa91
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %dl
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xfa60
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf9b0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfae8
leaq -0x8(%rbp), %rdi
callq 0x10600
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xfafc
leaq -0x10(%rbp), %rdi
callq 0x10600
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0xfb41
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xfb4a
jmp 0xfb58
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xfb20
movq -0x10(%rbp), %rax
popq %rbp
retq
nop