LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_a
void		ft_swap_a(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp_1 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_2->next = NULL;
	new_list = lists->list_a;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_a = new_list;
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x13c8
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x13bf
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movq %r15, %rdi
callq 0x330e
movq %r15, %rdi
movq %r14, %rsi
callq 0x330e
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_b
void		ft_swap_b(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp_1 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_2->next = NULL;
	new_list = lists->list_b;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_b = new_list;
}

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x1424
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x141b
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
movq %r15, %rdi
callq 0x330e
movq %r15, %rdi
movq %r14, %rsi
callq 0x330e
movq (%r15), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_a
void	ft_rotate_a(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_a, tmp);
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1499
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1499
movq %rax, (%rdi)
movq $0x0, 0x8(%rsi)
jmp 0x33be
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_b
void	ft_rotate_b(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_b, tmp);
}

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x14c0
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x14c0
addq $0x8, %rdi
movq %rax, (%rdi)
movq $0x0, 0x8(%rsi)
jmp 0x33be
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_a
void	del_last_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_a;
	while (i < (ft_lstsize(lists->list_a) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x3359
cmpl $0x3, %eax
jl 0x1546
xorl %ebp, %ebp
incl %ebp
movq 0x8(%rbx), %rbx
movq (%r14), %rdi
callq 0x3359
addl $-0x2, %eax
cmpl %eax, %ebp
jl 0x1531
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_b
void	del_last_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_b;
	while (i < (ft_lstsize(lists->list_b) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x3359
cmpl $0x3, %eax
jl 0x1583
xorl %ebp, %ebp
incl %ebp
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %rdi
callq 0x3359
addl $-0x2, %eax
cmpl %eax, %ebp
jl 0x156d
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_a
void	ft_rev_rotate_a(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = ft_lstlast(lists->list_a);
	del_last_a(lists);
	ft_lstadd_front(&lists->list_a, tmp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x15c8
cmpq $0x0, 0x8(%rdi)
je 0x15c8
callq 0x338e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1518
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x330e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_b
void	ft_rev_rotate_b(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = ft_lstlast(lists->list_b);
	del_last_b(lists);
	ft_lstadd_front(&lists->list_b, tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x160c
cmpq $0x0, 0x8(%rdi)
je 0x160c
leaq 0x8(%rbx), %r14
callq 0x338e
movq %rax, %r15
movq %rbx, %rdi
callq 0x1553
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x330e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_a
void	ft_print_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_a;
	printf("\033[1;34mLIST A :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
leaq 0x2a01(%rip), %rdi      # 0x4033
callq 0x1040
leaq 0x2a15(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x2a2d(%rip), %rdi      # 0x4077
callq 0x1040
testq %r14, %r14
je 0x167c
leaq 0x29c6(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x165d
leaq 0x2a1a(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_b
void	ft_print_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_b;
	printf("\033[1;33mLIST B :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
leaq 0x29a8(%rip), %rdi      # 0x4043
callq 0x1040
leaq 0x29ac(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x29c4(%rip), %rdi      # 0x4077
callq 0x1040
testq %r14, %r14
je 0x16e5
leaq 0x295d(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x16c6
leaq 0x29b1(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_both
void	ft_print_both(t_lists *lists)
{
	ft_print_a(lists);
	printf("-------------------------------------\n");
	ft_print_b(lists);
	printf("\033[1;31m=====================================\033[0;m\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1624
leaq 0x29c1(%rip), %rdi      # 0x40c6
callq 0x1040
movq %rbx, %rdi
callq 0x168c
leaq 0x29d3(%rip), %rdi      # 0x40ec
popq %rbx
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: use_commands
void	use_commands(t_list *commands, t_lists *lists)
{
	t_list	*cursor;

	cursor = commands->next;
	while (cursor)
	{
		swap_fct(lists, cursor);
		push_fct(lists, cursor);
		rotate_fct(lists, cursor);
		rev_rotate_fct(lists, cursor);
		cursor = cursor->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1765
movq %rsi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x191c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1994
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a54
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1730
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: ft_read_command
int		ft_read_command(t_list *commands)
{
	int		ret;
	char	*line;

	while ((ret = get_next_line(0, &line)) == 1)
	{
		if (!ft_strcmp(line, "sa") || !ft_strcmp(line, "sb")
		|| !ft_strcmp(line, "ss"))
			get_swap(commands, line);
		else if (!ft_strcmp(line, "pa") || !ft_strcmp(line, "pb"))
			get_push(commands, line);
		else if (!ft_strcmp(line, "ra") || !ft_strcmp(line, "rb")
		|| !ft_strcmp(line, "rr"))
			get_rotate(commands, line);
		else if (!ft_strcmp(line, "rra") ||
		!ft_strcmp(line, "rrb") || !ft_strcmp(line, "rrr"))
			get_rev_rotate(commands, line);
		else
		{
			get_next_line(-42, &line);
			free(line);
			return (-1);
		}
		free(line);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rsp, %rsi
xorl %edi, %edi
callq 0x1d89
cmpl $0x1, %eax
jne 0x190b
leaq 0x2987(%rip), %r14      # 0x411e
movq %rsp, %r15
leaq 0x2980(%rip), %r12      # 0x4121
leaq 0x297c(%rip), %r13      # 0x4124
xorl %ebp, %ebp
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x3694
testl %eax, %eax
je 0x18a8
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x3694
testl %eax, %eax
je 0x18a8
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x3694
testl %eax, %eax
je 0x18a8
movq (%rsp), %rdi
leaq 0x2936(%rip), %rsi      # 0x4127
callq 0x3694
testl %eax, %eax
je 0x18d2
movq (%rsp), %rdi
leaq 0x2921(%rip), %rsi      # 0x412a
callq 0x3694
testl %eax, %eax
je 0x18d2
movq (%rsp), %rdi
leaq 0x290d(%rip), %rsi      # 0x412e
callq 0x3694
testl %eax, %eax
je 0x18e0
movq (%rsp), %rdi
leaq 0x28f9(%rip), %rsi      # 0x4132
callq 0x3694
testl %eax, %eax
je 0x18e0
movq (%rsp), %rdi
leaq 0x28e5(%rip), %rsi      # 0x4136
callq 0x3694
testl %eax, %eax
je 0x18e0
movq (%rsp), %rdi
leaq 0x28c4(%rip), %rsi      # 0x412d
callq 0x3694
testl %eax, %eax
je 0x189a
movq (%rsp), %rdi
leaq 0x28b4(%rip), %rsi      # 0x4131
callq 0x3694
testl %eax, %eax
je 0x189a
movq (%rsp), %rdi
leaq 0x28a4(%rip), %rsi      # 0x4135
callq 0x3694
testl %eax, %eax
jne 0x18ee
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1c4a
jmp 0x18b4
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1b6a
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
movq %r15, %rsi
callq 0x1d89
cmpl $0x1, %eax
je 0x17aa
jmp 0x190b
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1b10
jmp 0x18b4
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1bda
jmp 0x18b4
movq %rsp, %rbx
movl $0xffffffd6, %edi       # imm = 0xFFFFFFD6
movq %rbx, %rsi
callq 0x1d89
movq (%rbx), %rdi
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: swap_fct
void	swap_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "sa"))
		ft_swap_a(lists);
	else if (!ft_strcmp(commands->content, "sb"))
		ft_swap_b(lists);
	else if (!ft_strcmp(commands->content, "ss"))
		ft_swap_ss(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x27ee(%rip), %rsi      # 0x411e
callq 0x3694
testl %eax, %eax
je 0x1967
movq (%r14), %rdi
leaq 0x27de(%rip), %rsi      # 0x4121
callq 0x3694
testl %eax, %eax
je 0x1976
movq (%r14), %rdi
leaq 0x27ce(%rip), %rsi      # 0x4124
callq 0x3694
testl %eax, %eax
je 0x1985
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1370
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13c9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1425
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: push_fct
void	push_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "pa"))
		ft_push_a(lists);
	else if (!ft_strcmp(commands->content, "pb"))
		ft_push_b(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x277f(%rip), %rsi      # 0x4127
callq 0x3694
testl %eax, %eax
je 0x19cc
movq (%r14), %rdi
leaq 0x276f(%rip), %rsi      # 0x412a
callq 0x3694
testl %eax, %eax
je 0x19db
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1438
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1457
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rotate_fct
void	rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "ra"))
		ft_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rb"))
		ft_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rr"))
		ft_rotate_rr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2730(%rip), %rsi      # 0x412e
callq 0x3694
testl %eax, %eax
jne 0x1a0f
movq %rbx, %rdi
callq 0x1478
movq (%r14), %rdi
leaq 0x2719(%rip), %rsi      # 0x4132
callq 0x3694
testl %eax, %eax
jne 0x1a2a
movq %rbx, %rdi
callq 0x149a
movq (%r14), %rdi
leaq 0x2702(%rip), %rsi      # 0x4136
callq 0x3694
testl %eax, %eax
je 0x1a45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14c1
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rev_rotate_fct
void	rev_rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "rra"))
		ft_rev_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rrb"))
		ft_rev_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rrr"))
		ft_rev_rotate_rrr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x26c5(%rip), %rsi      # 0x412d
callq 0x3694
testl %eax, %eax
jne 0x1a79
movq %rbx, %rdi
callq 0x1590
movq (%r14), %rdi
leaq 0x26ae(%rip), %rsi      # 0x4131
callq 0x3694
testl %eax, %eax
jne 0x1a94
movq %rbx, %rdi
callq 0x15d0
movq (%r14), %rdi
leaq 0x2697(%rip), %rsi      # 0x4135
callq 0x3694
testl %eax, %eax
je 0x1aaf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1612
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/checker/check_sort.c
// Function: check_sort
void		check_sort(int ac, t_lists *lists)
{
	int		value;
	t_list	*cursor;
	t_data	*this;
	t_data	*the_next;

	cursor = lists->list_a;
	if (ft_lstsize(cursor) != (ac - 1))
	{
		printf("\033[1;31mKO\n\033[0;m");
		return ;
	}
	while (cursor->next)
	{
		this = cursor->content;
		value = this->value;
		the_next = cursor->next->content;
		if (value > the_next->value)
		{
			printf("\033[1;31mKO\n\033[0;m");
			return ;
		}
		cursor = cursor->next;
	}
	printf("\033[1;32mOK\n\033[0;m");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq (%rsi), %rbx
movq %rbx, %rdi
callq 0x3359
decl %ebp
leaq 0x2660(%rip), %rdi      # 0x4139
cmpl %ebp, %eax
jne 0x1b01
leaq 0x2665(%rip), %rax      # 0x4149
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1afe
movq (%rbx), %rdx
movl (%rdx), %edx
movq (%rcx), %rsi
movq %rcx, %rbx
cmpl (%rsi), %edx
jle 0x1ae4
jmp 0x1b01
movq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_first_lines
char	*append_first_lines(char *str, char **line, int i)
{
	char *tmp;

	str[i] = '\0';
	*line = ft_strdup(str);
	tmp = ft_strdup(str + (i + 1));
	free(str);
	str = tmp;
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
leaq (%rdi,%rax), %r15
incq %r15
movb $0x0, -0x1(%r15)
callq 0x3616
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3616
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_next_lines
char	*append_next_lines(char *str, char **line, int i, int output)
{
	if (output == 0 && i != -1)
	{
		append_first_lines(str, line, i);
		return (str);
	}
	else if (output == 0)
	{
		*line = ft_strdup(str);
		free(str);
		str = NULL;
		return (str);
	}
	free(str);
	str = NULL;
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
setne %al
cmpl $-0x1, %edx
sete %sil
orb %al, %sil
jne 0x1d22
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1cbc
jmp 0x1d3b
testl %ecx, %ecx
jne 0x1d31
movq %rbx, %rdi
callq 0x3616
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: get_next_line
int		get_next_line(int fd, char **line)
{
	static char		*str = NULL;
	char			buffer[BUFFER_SIZE + 1];
	int				output;
	int				i;

	i = 0;
	if (fd < 0 && str)
	{
		free(str);
		return (-1);
	}
	while (((output = read(fd, buffer, BUFFER_SIZE)) && output > 0) || i != -1)
	{
		buffer[output] = '\0';
		str = ft_join(str, buffer);
		i = check_line(str);
		if (i >= 0)
		{
			str = append_first_lines(str, line, i);
			return (1);
		}
		if (is_output_null(output, str) == 0)
			return (0);
	}
	return (read_finished(str, line, output, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebp
testl %edi, %edi
sets %al
movq 0x52cd(%rip), %rdi      # 0x7070
testq %rdi, %rdi
setne %cl
testb %cl, %al
je 0x1dbc
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1e67
movq %rsi, %rbx
xorl %r12d, %r12d
movq %rsp, %r14
movl $0x20, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x1070
movq %rax, %r15
testl %r15d, %r15d
setle %al
cmpl $-0x1, %r12d
sete %cl
testb %al, %cl
jne 0x1e29
movslq %r15d, %rax
movb $0x0, (%rsp,%rax)
movq 0x527a(%rip), %rdi      # 0x7070
movq %r14, %rsi
callq 0x1e74
movq %rax, 0x526b(%rip)      # 0x7070
movq %rax, %rdi
callq 0x1f19
movl %eax, %r12d
testl %eax, %eax
jns 0x1e49
testl %r15d, %r15d
jne 0x1dc5
movq 0x5250(%rip), %rdi      # 0x7070
callq 0x1030
xorl %eax, %eax
jmp 0x1e67
movq 0x5240(%rip), %rdi      # 0x7070
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %ecx
callq 0x1cfa
xorl %eax, %eax
negl %r15d
sbbl %eax, %eax
jmp 0x1e67
movq 0x5220(%rip), %rdi      # 0x7070
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1cbc
movq %rax, 0x520e(%rip)      # 0x7070
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/gnl/get_next_line_utils.c
// Function: ft_join
char	*ft_join(char *s1, char *s2)
{
	size_t		i;
	size_t		j;
	size_t		len1;
	char		*str;

	if (s1 == NULL)
		len1 = 0;
	else
		len1 = ft_strlen(s1);
	if (!(str = malloc(sizeof(char) * (len1 + ft_strlen(s2) + 1))))
		return (NULL);
	i = 0;
	j = 0;
	while (i < len1)
	{
		str[i] = s1[i];
		i++;
	}
	while (j < ft_strlen(s2))
		str[i++] = s2[j++];
	str[i] = '\0';
	free(s1);
	return (str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1e97
movq %rbx, %rdi
callq 0x3412
movq %rax, %r15
jmp 0x1e9a
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3412
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1090
movq %rax, %r12
testq %rax, %rax
je 0x1f07
testq %r15, %r15
je 0x1ec9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1080
movq %r14, %rdi
callq 0x3412
testq %rax, %rax
je 0x1efa
movq %r12, %r13
addq %r15, %r13
xorl %ebp, %ebp
movb (%r14,%rbp), %al
movb %al, (%r13,%rbp)
incq %rbp
movq %r14, %rdi
callq 0x3412
cmpq %rax, %rbp
jb 0x1ede
addq %rbp, %r15
movb $0x0, (%r12,%r15)
movq %rbx, %rdi
callq 0x1030
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/get_index.c
// Function: get_index
void	get_index(t_list *l_a)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = l_a;
	while (cursor)
	{
		this = cursor->content;
		index = comp_value(l_a, this);
		this->index = index;
		cursor = cursor->next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x1f8e
movq %rdi, %rax
movq (%rax), %rcx
movl (%rcx), %esi
xorl %edx, %edx
movq %rdi, %r8
movq (%r8), %r9
xorl %r10d, %r10d
cmpl (%r9), %esi
movq 0x8(%r8), %r8
setg %r10b
addl %r10d, %edx
testq %r8, %r8
jne 0x1f69
movl %edx, 0x4(%rcx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1f5f
retq
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: first_in_chunk
int		first_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		ret;

	cursor = la;
	this = cursor->content;
	ret = 0;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			return (ret);
		ret++;
		cursor = cursor->next;
	}
	return (-1);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x201d
xorl %ecx, %ecx
movq (%rdx), %r8
movl 0x4(%r8), %r8d
cmpl %edi, %r8d
setge %r9b
cmpl %esi, %r8d
setle %r8b
testb %r8b, %r9b
jne 0x201e
incl %ecx
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0x1ff8
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: last_in_chunk
int		last_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = la;
	this = cursor->content;
	index = -1;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			index = this->index;
		cursor = cursor->next;
	}
	if (index != -1)
		return (how_many_rotate(la, index) - 1);
	return (-1);
}

// Assembly:
testq %rdx, %rdx
je 0x2066
pushq %rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rdx, %rcx
movl %eax, %r8d
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movl 0x4(%rax), %r9d
cmpl %esi, %r9d
movl %r9d, %eax
cmovgl %r8d, %eax
cmpl %edi, %r9d
cmovll %r8d, %eax
testq %rcx, %rcx
jne 0x202f
cmpl $-0x1, %eax
je 0x206c
movq %rdx, %rdi
movl %eax, %esi
callq 0x3178
decl %eax
jmp 0x2071
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: fill_b_per_chunk
void	fill_b_per_chunk(t_lists *l, int chunk1, int chunk2)
{
	int ra_nb;
	int rra_nb;
	int rb_nb;

	while (first_in_chunk(chunk1, chunk2, l->list_a) != -1)
	{
		ra_nb = first_in_chunk(chunk1, chunk2, l->list_a);
		rra_nb = ft_lstsize(l->list_a) -
		last_in_chunk(chunk1, chunk2, l->list_a);
		if (ft_lstsize(l->list_b) > 1)
			rb_nb = how_many_rotate(l->list_b,
			chose_index_to_push(l, chunk1, chunk2)) - 1;
		ra_or_rra_hundred(l, ra_nb, rra_nb, rb_nb);
		write_pb(l);
		if (chose_index_to_push(l, chunk1, chunk2) == -1)
			write_rb(l);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2171
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %rax
movq (%rax), %rcx
movl 0x4(%rcx), %ecx
cmpl %ebp, %ecx
setl %dl
cmpl %ebx, %ecx
setg %cl
orb %dl, %cl
je 0x20b9
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2097
jmp 0x2171
xorl %r12d, %r12d
movq %rdi, %rax
movq (%rax), %rcx
movl 0x4(%rcx), %ecx
cmpl %ebp, %ecx
setge %dl
cmpl %ebx, %ecx
setle %cl
testb %cl, %dl
jne 0x20e5
incl %r12d
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x20bf
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
callq 0x3359
movl %eax, %r13d
movq (%r14), %rdx
movl %ebp, %edi
movl %ebx, %esi
callq 0x2021
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x3359
cmpl $0x2, %eax
movl (%rsp), %eax
jl 0x212e
movq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x24b0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x3178
decl %eax
subl %r15d, %r13d
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %eax, (%rsp)
movl %eax, %ecx
callq 0x30b7
movq %r14, %rdi
callq 0x21f4
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x24b0
cmpl $-0x1, %eax
jne 0x2165
movq %r14, %rdi
callq 0x2289
movq (%r14), %rdi
testq %rdi, %rdi
jne 0x2094
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/smaller_index.c
// Function: new_smaller
int		new_smaller(t_list *la, int smaller_a)
{
	int		i;
	t_list	*cursor;
	t_data	*this;
	int		new_smaller;

	i = -1;
	new_smaller = smaller_a;
	cursor = la;
	while (i < get_good_smaller(la, smaller_a))
	{
		this = cursor->content;
		new_smaller = this->index;
		cursor = cursor->next;
		i++;
	}
	return (new_smaller);
}

// Assembly:
movl %esi, %eax
leal 0x1(%rax), %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdi, %rsi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x2362
xorl %r8d, %r8d
movq %rdi, %r9
movq (%r9), %r10
cmpl %ecx, 0x4(%r10)
je 0x2362
movq 0x8(%r9), %r9
incl %r8d
testq %r9, %r9
jne 0x2347
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpl %r8d, %edx
jge 0x2375
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movl 0x4(%rax), %eax
incl %edx
jmp 0x2336
retq
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: does_lb_exist
int		does_lb_exist(t_lists *l, int idx_to_push)
{
	if (ft_lstsize(l->list_b) > 1)
	{
		if (smaller(l->list_b) > idx_to_push)
			return (-1);
		else if (bigger(l->list_b) < idx_to_push)
			return (bigger(l->list_b));
		else
			return (between_index(l->list_b, idx_to_push));
	}
	else if (ft_lstsize(l->list_b) == 1)
	{
		if (smaller(l->list_b) > idx_to_push)
			return (-1);
		else if (bigger(l->list_b) < idx_to_push)
			return (bigger(l->list_b));
	}
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x3359
movq 0x8(%r14), %rdi
cmpl $0x2, %eax
jl 0x2431
callq 0x22e8
cmpl %ebx, %eax
jle 0x246d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x24a8
callq 0x3359
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x24a8
movq 0x8(%r14), %rdi
callq 0x22e8
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ebx, %ecx
jg 0x24a8
movq 0x8(%r14), %rdi
callq 0x2378
movl %eax, %ecx
movl $0x0, %eax
cmpl %ebx, %ecx
jge 0x24a8
movq 0x8(%r14), %rdi
jmp 0x247e
movq 0x8(%r14), %rdi
callq 0x2378
movq 0x8(%r14), %rdi
cmpl %ebx, %eax
jge 0x248a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2378
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x242a
movq (%rdi), %rcx
movq %rax, %rdi
cmpl %ebx, 0x4(%rcx)
jle 0x248a
movq (%rdi), %rax
movl 0x4(%rax), %eax
cmpl %ebx, %eax
jge 0x248a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: chose_index_to_push
int		chose_index_to_push(t_lists *l, int ch1, int ch2)
{
	int		idx_to_push;
	int		ra;
	int		rra;

	ra = first_in_chunk(ch1, ch2, l->list_a);
	rra = ft_lstsize(l->list_a) -
	last_in_chunk(ch1, ch2, l->list_a);
	if (ra < rra)
		idx_to_push = first_in_chunk_index(ch1, ch2, l->list_a);
	else
		idx_to_push = last_in_chunk_index(ch1, ch2, l->list_a);
	return (does_lb_exist(l, idx_to_push));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdx
movl %esi, %edi
movl %ebp, %esi
callq 0x1fec
movl %eax, %r15d
movq (%rbx), %rdi
callq 0x3359
movl %eax, %r12d
movq (%rbx), %rdx
movl %r14d, %edi
movl %ebp, %esi
callq 0x2021
subl %eax, %r12d
movq (%rbx), %rax
cmpl %r12d, %r15d
jge 0x2512
testq %rax, %rax
je 0x253a
movq (%rax), %rcx
movl 0x4(%rcx), %esi
cmpl %r14d, %esi
setge %cl
cmpl %ebp, %esi
setle %dl
testb %dl, %cl
jne 0x253f
movq 0x8(%rax), %rax
jmp 0x24f2
testq %rax, %rax
je 0x253a
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %ecx
cmpl %ebp, %ecx
movl %ecx, %edx
cmovgl %esi, %edx
cmpl %r14d, %ecx
cmovgel %edx, %esi
testq %rax, %rax
jne 0x251c
jmp 0x253f
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2406
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_three.c
// Function: how_sort_three
void		how_sort_three(int first, int second, int third, t_lists *l)
{
	if (first > second && first < third)
		write_sa(l);
	else if (first > second && first > third && second < third)
		write_ra(l);
	else if (first < second && first > third)
		write_rra(l);
	else if (first > second && first > third && second > third)
	{
		write_sa(l);
		write_rra(l);
	}
	else if (first < second && first < third && second > third)
	{
		write_sa(l);
		write_ra(l);
	}
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpl %esi, %edi
setle %al
cmpl %edx, %edi
setge %cl
orb %al, %cl
jne 0x256b
movq %rbx, %rdi
popq %rbx
jmp 0x2180
cmpl %esi, %edi
setg %cl
cmpl %edx, %edi
setg %al
andb %cl, %al
xorb $0x1, %al
cmpl %edx, %esi
setge %cl
orb %al, %cl
jne 0x258b
movq %rbx, %rdi
popq %rbx
jmp 0x226c
cmpl %edx, %edi
setle %cl
cmpl %esi, %edi
setge %r8b
orb %cl, %r8b
je 0x25ac
cmpl %edx, %esi
setle %cl
orb %al, %cl
jne 0x25b5
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
popq %rbx
jmp 0x2214
cmpl %edx, %esi
jle 0x25cb
cmpl %esi, %edi
jge 0x25cb
cmpl %edx, %edi
jge 0x25cb
movq %rbx, %rdi
callq 0x2180
jmp 0x2582
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_three.c
// Function: sorting_three
void		sorting_three(t_lists *l)
{
	int		first;
	int		second;
	int		third;
	t_data	*this;

	if (ft_lstsize(l->list_a) == 1)
		return ;
	else if (ft_lstsize(l->list_a) == 2)
	{
		if (check_sort_ps(l) != 0)
			write_sa(l);
		return ;
	}
	else
	{
		this = l->list_a->content;
		first = this->index;
		this = l->list_a->next->content;
		second = this->index;
		this = l->list_a->next->next->content;
		third = this->index;
		how_sort_three(first, second, third, l);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3359
cmpl $0x1, %eax
jne 0x25e0
popq %rbx
retq
movq (%rbx), %rdi
callq 0x3359
cmpl $0x2, %eax
jne 0x2602
movq %rbx, %rdi
callq 0x22c4
testl %eax, %eax
je 0x25de
movq %rbx, %rdi
popq %rbx
jmp 0x2180
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %edi
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %esi
movq (%rax), %rax
movl 0x4(%rax), %edx
movq %rbx, %rcx
popq %rbx
jmp 0x2550
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_one
void	check_still_in_b_one(t_lists *l, int first, int second)
{
	if (first == 1)
	{
		write_pa(l);
		write_pa(l);
	}
	else if (first == 2)
	{
		write_pa(l);
		write_sa(l);
		if (second == 1)
		{
			write_pa(l);
			write_sa(l);
		}
		else
			write_pa(l);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x264e
cmpl $0x1, %esi
jne 0x267b
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d7
movl %edx, %ebp
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21d7
cmpl $0x1, %ebp
jne 0x267b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_two
void	check_still_in_b_two(t_lists *l, int first, int second)
{
	if (first == 3)
	{
		write_rra(l);
		write_pa(l);
		if (second == 0)
		{
			write_ra(l);
			write_ra(l);
			write_pa(l);
		}
		else if (second == 1)
		{
			write_ra(l);
			write_ra(l);
			write_pa(l);
			write_sa(l);
		}
		else if (second == 2)
		{
			pa_ra(l);
			write_ra(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jne 0x26c8
movl %edx, %ebp
movq %rdi, %rbx
callq 0x2214
movq %rbx, %rdi
callq 0x21d7
cmpl $0x2, %ebp
je 0x26f5
cmpl $0x1, %ebp
je 0x26cf
testl %ebp, %ebp
jne 0x26c8
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2180
movq %rbx, %rdi
callq 0x28d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x226c
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_three
void	check_still_in_b_three(t_lists *l, int first, int second)
{
	if (first == 4)
	{
		write_pa(l);
		if (second == 3)
			pa_ra(l);
		else if (second == 2)
		{
			write_rra(l);
			pa_ra(l);
			write_ra(l);
		}
		else if (second == 1)
		{
			write_ra(l);
			write_pa(l);
			write_sa(l);
		}
		else if (second == 0)
		{
			write_ra(l);
			write_pa(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x4, %esi
jne 0x274a
movl %edx, %ebp
movq %rdi, %rbx
callq 0x21d7
cmpl $0x3, %ebp
ja 0x274a
movl %ebp, %eax
leaq 0x1a51(%rip), %rcx      # 0x417c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x2214
movq %rbx, %rdi
callq 0x28d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x226c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x28d8
movq %rbx, %rdi
callq 0x226c
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: sort_four
void	sort_four(int index, t_lists *l)
{
	if (index == 0)
		write_pa(l);
	else if (index == 1)
	{
		write_pa(l);
		write_sa(l);
	}
	else if (index == 2)
	{
		write_rra(l);
		write_pa(l);
		write_ra(l);
		write_ra(l);
	}
	else if (index == 3)
	{
		write_pa(l);
		write_ra(l);
	}
}

// Assembly:
pushq %rbx
cmpl $0x3, %edi
ja 0x27fb
movq %rsi, %rbx
movl %edi, %eax
leaq 0x19df(%rip), %rcx      # 0x418c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x21d7
movq %rbx, %rdi
callq 0x2214
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
callq 0x226c
jmp 0x27e1
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
popq %rbx
jmp 0x226c
movq %rbx, %rdi
callq 0x21d7
movq %rbx, %rdi
popq %rbx
jmp 0x2180
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: sorting_five
void	sorting_five(t_lists *l)
{
	int		how_many_pb;
	t_data	*first_b;
	t_data	*sec_b;

	how_many_pb = ft_lstsize(l->list_a);
	if (check_sort_ps(l) != 0)
	{
		while (how_many_pb-- > 3)
			write_pb(l);
		sorting_three(l);
		first_b = l->list_b->content;
		if (ft_lstsize(l->list_b) == 2)
		{
			sec_b = l->list_b->next->content;
			if (first_b->index < sec_b->index)
				write_sb(l);
			first_b = l->list_b->content;
			sec_b = l->list_b->next->content;
			check_still_in_b_one(l, first_b->index, sec_b->index);
			check_still_in_b_two(l, first_b->index, sec_b->index);
			check_still_in_b_three(l, first_b->index, sec_b->index);
		}
		else
			sort_four(first_b->index, l);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3359
movl %eax, %ebp
movq %rbx, %rdi
callq 0x22c4
testl %eax, %eax
je 0x28b5
cmpl $0x4, %ebp
jl 0x2837
incl %ebp
movq %rbx, %rdi
callq 0x21f4
decl %ebp
cmpl $0x4, %ebp
ja 0x2828
movq %rbx, %rdi
callq 0x25cd
movq 0x8(%rbx), %rdi
movq (%rdi), %r15
callq 0x3359
cmpl $0x2, %eax
jne 0x28c0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %r14
movl 0x4(%r14), %edx
cmpl %edx, 0x4(%r15)
jge 0x287c
movq %rbx, %rdi
callq 0x219d
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %r14
movl 0x4(%r14), %edx
movq (%rax), %r15
movl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x2628
movl 0x4(%r15), %esi
movl 0x4(%r14), %edx
movq %rbx, %rdi
callq 0x2682
movl 0x4(%r15), %esi
movl 0x4(%r14), %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x270b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r15), %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x279b
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: refill_a_sorted
void	refill_a_sorted(t_lists *l)
{
	int		rb_nb;
	int		i;

	i = ft_lstsize(l->list_b);
	while (i > 0)
	{
		rb_nb = how_many_rotate(l->list_b, bigger(l->list_b)) - 1;
		if (rb_nb < ft_lstsize(l->list_b) / 2)
		{
			while (rb_nb-- > 0)
				write_rb(l);
			write_pa(l);
			i--;
		}
		else
		{
			while (rb_nb++ < ft_lstsize(l->list_b))
				write_rrb(l);
			write_pa(l);
			i--;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3359
testl %eax, %eax
jle 0x2a98
movl %eax, %r14d
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2378
movq %r15, %rdi
movl %eax, %esi
callq 0x3178
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x3359
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
jle 0x2a6f
movq 0x8(%rbx), %rdi
callq 0x3359
cmpl %eax, %ebp
jg 0x2a83
decl %ebp
incl %ebp
movq %rbx, %rdi
callq 0x2231
movq 0x8(%rbx), %rdi
callq 0x3359
cmpl %eax, %ebp
jl 0x2a56
jmp 0x2a83
cmpl $0x2, %ebp
jl 0x2a83
movq %rbx, %rdi
callq 0x2289
decl %ebp
cmpl $0x1, %ebp
ja 0x2a74
movq %rbx, %rdi
callq 0x21d7
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x2a19
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: bigger_on_top
void	bigger_on_top(t_lists *l)
{
	int		rb;

	rb = how_many_rotate(l->list_b, bigger(l->list_b)) - 1;
	if (rb < ft_lstsize(l->list_b) / 2)
	{
		while (rb > 0)
		{
			write_rb(l);
			rb--;
		}
	}
	else
	{
		while (rb < ft_lstsize(l->list_b))
		{
			write_rrb(l);
			rb++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2378
movq %r14, %rdi
movl %eax, %esi
callq 0x3178
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x3359
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
jle 0x2b00
movq 0x8(%rbx), %rdi
callq 0x3359
cmpl %eax, %ebp
jg 0x2b14
decl %ebp
movq %rbx, %rdi
callq 0x2231
incl %ebp
movq 0x8(%rbx), %rdi
callq 0x3359
cmpl %eax, %ebp
jl 0x2ae7
jmp 0x2b14
cmpl $0x2, %ebp
jl 0x2b14
movq %rbx, %rdi
callq 0x2289
decl %ebp
cmpl $0x1, %ebp
ja 0x2b05
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: sorting_hundred
void	sorting_hundred(t_lists *l)
{
	t_chunk_h	chunks;

	init_chunks_h(&chunks, l->list_a);
	fill_b_per_chunk(l, 0, chunks.chunk1);
	fill_b_per_chunk(l, chunks.chunk1, chunks.chunk2);
	fill_b_per_chunk(l, chunks.chunk2, chunks.chunk3);
	fill_b_per_chunk(l, chunks.chunk3, chunks.chunk4);
	fill_b_per_chunk(l, chunks.chunk4, chunks.chunk5);
	fill_b_per_chunk(l, chunks.chunk5, chunks.chunk6);
	fill_b_per_chunk(l, chunks.chunk6, chunks.chunk7);
	bigger_on_top(l);
	refill_a_sorted(l);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x28f4
movl (%r14), %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x2076
movl 0x4(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x8(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0xc(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x10(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x14(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x18(%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2076
movq %rbx, %rdi
callq 0x2aa3
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29fb
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_five_hundred.c
// Function: sorting_five_hundred
void	sorting_five_hundred(t_lists *l)
{
	t_chunk_fh	chunks;

	init_chunks_fh(&chunks, l->list_a);
	fill_b_per_chunk(l, 0, chunks.chunk1);
	fill_b_per_chunk(l, chunks.chunk1, chunks.chunk2);
	fill_b_per_chunk(l, chunks.chunk2, chunks.chunk3);
	fill_b_per_chunk(l, chunks.chunk3, chunks.chunk4);
	fill_b_per_chunk(l, chunks.chunk4, chunks.chunk5);
	fill_b_per_chunk(l, chunks.chunk5, chunks.chunk6);
	fill_b_per_chunk(l, chunks.chunk6, chunks.chunk7);
	fill_b_per_chunk(l, chunks.chunk7, chunks.chunk8);
	fill_b_per_chunk(l, chunks.chunk8, chunks.chunk9);
	fill_b_per_chunk(l, chunks.chunk9, chunks.chunk10);
	fill_b_per_chunk(l, chunks.chunk10, chunks.chunk11);
	fill_b_per_chunk(l, chunks.chunk11, chunks.chunk12);
	fill_b_per_chunk(l, chunks.chunk12, chunks.chunk13);
	fill_b_per_chunk(l, chunks.chunk13, chunks.chunk14);
	fill_b_per_chunk(l, chunks.chunk14, chunks.chunk15);
	refill_a_sorted(l);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x2bc4
movl (%r14), %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x2076
movl 0x4(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x8(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0xc(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x10(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x14(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x18(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x1c(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x20(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x24(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x28(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x2c(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x30(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2076
movl 0x34(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2076
movl 0x38(%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2076
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29fb
nop
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: ranbrbnb_hundred
void	ranbrbnb_hundred(t_lists *l, int ra_nb, int rb_nb)
{
	int	a;
	int b;

	a = ra_nb;
	b = rb_nb;
	while (a > 0 && b > 0)
	{
		write_rr(l);
		a--;
		b--;
	}
	while (a > 0)
	{
		write_ra(l);
		a--;
	}
	while (b > 0)
	{
		write_rb(l);
		b--;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
setle %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x2f87
movl %ebp, %r12d
movq %rbx, %rdi
callq 0x22a6
leal -0x1(%r12), %ebp
leal -0x1(%r14), %r15d
cmpl $0x2, %r12d
jb 0x2f8a
cmpl $0x1, %r14d
movl %r15d, %r14d
ja 0x2f62
jmp 0x2f8a
movl %r14d, %r15d
testl %ebp, %ebp
jle 0x2f9f
incl %ebp
movq %rbx, %rdi
callq 0x226c
decl %ebp
cmpl $0x1, %ebp
ja 0x2f90
testl %r15d, %r15d
jle 0x2fb8
incl %r15d
movq %rbx, %rdi
callq 0x2289
decl %r15d
cmpl $0x1, %r15d
ja 0x2fa7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: ranbrrbnb_hundred
void	ranbrrbnb_hundred(t_lists *l, int ra_nb, int rb_nb)
{
	int a;
	int b;

	a = ra_nb;
	b = rb_nb;
	while (a > 0)
	{
		write_ra(l);
		a--;
	}
	while (b < ft_lstsize(l->list_b))
	{
		write_rrb(l);
		b++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x2fe1
movl %esi, %ebp
incl %ebp
movq %r14, %rdi
callq 0x226c
decl %ebp
cmpl $0x1, %ebp
ja 0x2fd2
movq 0x8(%r14), %rdi
callq 0x3359
cmpl %ebx, %eax
jle 0x3005
movq %r14, %rdi
callq 0x2231
incl %ebx
movq 0x8(%r14), %rdi
callq 0x3359
cmpl %eax, %ebx
jl 0x2fee
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: rranbrbnb_hundred
void	rranbrbnb_hundred(t_lists *l, int rra_nb, int rb_nb)
{
	int a;
	int b;

	a = rra_nb;
	b = rb_nb;
	while (a > 0)
	{
		write_rra(l);
		a--;
	}
	while (b > 0)
	{
		write_rb(l);
		b--;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x302a
movl %esi, %ebp
incl %ebp
movq %r14, %rdi
callq 0x2214
decl %ebp
cmpl $0x1, %ebp
ja 0x301b
testl %ebx, %ebx
jle 0x303f
incl %ebx
movq %r14, %rdi
callq 0x2289
decl %ebx
cmpl $0x1, %ebx
ja 0x3030
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: rranbrrbnb_hundred
void	rranbrrbnb_hundred(t_lists *l, int rra_nb, int rb_nb)
{
	int a;
	int b;

	a = rra_nb;
	b = rb_nb;
	while (a > 0 && b < ft_lstsize(l->list_b))
	{
		write_rrr(l);
		a--;
		b++;
	}
	while (a > 0)
	{
		write_rra(l);
		a--;
	}
	while (b < ft_lstsize(l->list_b))
	{
		write_rrb(l);
		b++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x309f
movl %esi, %r15d
leal (%rbx,%r15), %ebp
incl %r15d
movq 0x8(%r14), %rdi
callq 0x3359
cmpl %eax, %ebx
jge 0x3082
movq %r14, %rdi
callq 0x224e
incl %ebx
decl %r15d
cmpl $0x1, %r15d
jg 0x305e
movl %ebp, %ebx
jmp 0x309f
movq %r14, %rdi
callq 0x2214
decl %r15d
cmpl $0x1, %r15d
ja 0x3082
jmp 0x309f
movq %r14, %rdi
callq 0x2231
incl %ebx
movq 0x8(%r14), %rdi
callq 0x3359
cmpl %eax, %ebx
jl 0x3095
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq