LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x448a
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x204d
leaq 0x30fc(%rip), %rdi      # 0x5140
movb $0x0, %al
callq 0x1050
jmp 0x20b4
jmp 0x204f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x20a6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2098
leaq 0x30b1(%rip), %rdi      # 0x5140
movb $0x0, %al
callq 0x1050
jmp 0x20b4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x204f
leaq 0x30a3(%rip), %rdi      # 0x5150
movb $0x0, %al
callq 0x1050
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/get_commands.c
// Function: get_push
void	get_push(t_list *commands, char *strin)
{
	t_list	*new;

	if (!ft_strcmp(strin, "pa"))
	{
		new = ft_lstnew(ft_strdup("pa"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "pb"))
	{
		new = ft_lstnew(ft_strdup("pb"));
		ft_lstadd_back(&commands, new);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3053(%rip), %rsi      # 0x512e
callq 0x47c5
cmpl $0x0, %eax
jne 0x210c
leaq 0x3042(%rip), %rdi      # 0x512e
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x2148
movq -0x10(%rbp), %rdi
leaq 0x301a(%rip), %rsi      # 0x5131
callq 0x47c5
cmpl $0x0, %eax
jne 0x2146
leaq 0x3009(%rip), %rdi      # 0x5131
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x2148
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/get_commands.c
// Function: get_swap
void	get_swap(t_list *commands, char *strin)
{
	t_list	*new;

	if (!ft_strcmp(strin, "sa"))
	{
		new = ft_lstnew(ft_strdup("sa"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "sb"))
	{
		new = ft_lstnew(ft_strdup("sb"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "ss"))
	{
		new = ft_lstnew(ft_strdup("ss"));
		ft_lstadd_back(&commands, new);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2fba(%rip), %rsi      # 0x5125
callq 0x47c5
cmpl $0x0, %eax
jne 0x219c
leaq 0x2fa9(%rip), %rdi      # 0x5125
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x2216
movq -0x10(%rbp), %rdi
leaq 0x2f81(%rip), %rsi      # 0x5128
callq 0x47c5
cmpl $0x0, %eax
jne 0x21d8
leaq 0x2f70(%rip), %rdi      # 0x5128
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x2214
movq -0x10(%rbp), %rdi
leaq 0x2f48(%rip), %rsi      # 0x512b
callq 0x47c5
cmpl $0x0, %eax
jne 0x2212
leaq 0x2f37(%rip), %rdi      # 0x512b
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x2214
jmp 0x2216
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/get_commands.c
// Function: get_rotate
void	get_rotate(t_list *commands, char *strin)
{
	t_list	*new;

	if (!ft_strcmp(strin, "ra"))
	{
		new = ft_lstnew(ft_strdup("ra"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "rb"))
	{
		new = ft_lstnew(ft_strdup("rb"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "rr"))
	{
		new = ft_lstnew(ft_strdup("rr"));
		ft_lstadd_back(&commands, new);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2efa(%rip), %rsi      # 0x5135
callq 0x47c5
cmpl $0x0, %eax
jne 0x226c
leaq 0x2ee9(%rip), %rdi      # 0x5135
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x22e6
movq -0x10(%rbp), %rdi
leaq 0x2ec2(%rip), %rsi      # 0x5139
callq 0x47c5
cmpl $0x0, %eax
jne 0x22a8
leaq 0x2eb1(%rip), %rdi      # 0x5139
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x22e4
movq -0x10(%rbp), %rdi
leaq 0x2e8a(%rip), %rsi      # 0x513d
callq 0x47c5
cmpl $0x0, %eax
jne 0x22e2
leaq 0x2e79(%rip), %rdi      # 0x513d
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x22e4
jmp 0x22e6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/checker/get_commands.c
// Function: get_rev_rotate
void	get_rev_rotate(t_list *commands, char *strin)
{
	t_list	*new;

	if (!ft_strcmp(strin, "rra"))
	{
		new = ft_lstnew(ft_strdup("rra"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "rrb"))
	{
		new = ft_lstnew(ft_strdup("rrb"));
		ft_lstadd_back(&commands, new);
	}
	else if (!ft_strcmp(strin, "rrr"))
	{
		new = ft_lstnew(ft_strdup("rrr"));
		ft_lstadd_back(&commands, new);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2e29(%rip), %rsi      # 0x5134
callq 0x47c5
cmpl $0x0, %eax
jne 0x233c
leaq 0x2e18(%rip), %rdi      # 0x5134
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x23b6
movq -0x10(%rbp), %rdi
leaq 0x2df1(%rip), %rsi      # 0x5138
callq 0x47c5
cmpl $0x0, %eax
jne 0x2378
leaq 0x2de0(%rip), %rdi      # 0x5138
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x23b4
movq -0x10(%rbp), %rdi
leaq 0x2db9(%rip), %rsi      # 0x513c
callq 0x47c5
cmpl $0x0, %eax
jne 0x23b2
leaq 0x2da8(%rip), %rdi      # 0x513c
callq 0x4747
movq %rax, %rdi
callq 0x43fa
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x44ef
jmp 0x23b4
jmp 0x23b6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %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
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x4747
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
callq 0x4747
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x246c
cmpl $-0x1, -0x1c(%rbp)
je 0x246c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x23c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24bb
cmpl $0x0, -0x20(%rbp)
jne 0x24a0
movq -0x10(%rbp), %rdi
callq 0x4747
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24bb
jmp 0x24a2
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: is_output_null
int		is_output_null(int output, char *str)
{
	if (output == 0)
	{
		free(str);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x24f7
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x24fe
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: read_finished
int		read_finished(char *str, char **line, int output, int i)
{
	str = append_next_lines(str, line, i, output);
	if (output == 0 && i != -1)
		return (1);
	else if (output == 0)
		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 %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x2430
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2552
cmpl $-0x1, -0x20(%rbp)
je 0x2552
movl $0x1, -0x4(%rbp)
jmp 0x256a
cmpl $0x0, -0x1c(%rbp)
jne 0x2561
movl $0x0, -0x4(%rbp)
jmp 0x256a
jmp 0x2563
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x48(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x25be
cmpq $0x0, 0x5abc(%rip)      # 0x8060
je 0x25be
movq 0x5ab3(%rip), %rdi      # 0x8060
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x268a
jmp 0x25c0
movl -0x8(%rbp), %edi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x1060
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
je 0x25e4
movb $0x1, %al
cmpl $0x0, -0x44(%rbp)
movb %al, -0x49(%rbp)
jg 0x25ee
cmpl $-0x1, -0x48(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x25f7
jmp 0x2671
movslq -0x44(%rbp), %rax
movb $0x0, -0x40(%rbp,%rax)
movq 0x5a59(%rip), %rdi      # 0x8060
leaq -0x40(%rbp), %rsi
callq 0x26a0
movq %rax, 0x5a49(%rip)      # 0x8060
movq 0x5a42(%rip), %rdi      # 0x8060
callq 0x27c0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
jl 0x264f
movq 0x5a2d(%rip), %rdi      # 0x8060
movq -0x10(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0x23c0
movq %rax, 0x5a1a(%rip)      # 0x8060
movl $0x1, -0x4(%rbp)
jmp 0x268a
movl -0x44(%rbp), %edi
movq 0x5a07(%rip), %rsi      # 0x8060
callq 0x24d0
cmpl $0x0, %eax
jne 0x266c
movl $0x0, -0x4(%rbp)
jmp 0x268a
jmp 0x25c0
movq 0x59e8(%rip), %rdi      # 0x8060
movq -0x10(%rbp), %rsi
movl -0x44(%rbp), %edx
movl -0x48(%rbp), %ecx
callq 0x2510
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26c1
movq $0x0, -0x30(%rbp)
jmp 0x26ce
movq -0x10(%rbp), %rdi
callq 0x4543
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4543
movq -0x40(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1070
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x270a
movq $0x0, -0x8(%rbp)
jmp 0x27b2
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x2748
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x271a
jmp 0x274a
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4543
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2795
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x274a
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/gnl/get_next_line_utils.c
// Function: check_line
int		check_line(char *str)
{
	int i;

	i = 0;
	while (str[i])
	{
		if (str[i] == '\n')
			return (i);
		i++;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2801
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x27f6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2808
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27cf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/get_index.c
// Function: comp_value
int		comp_value(t_list *l_a, t_data *this)
{
	t_list	*all;
	t_data	*comp;
	int		index;

	all = l_a;
	index = 0;
	while (all)
	{
		comp = all->content;
		if (this->value > comp->value)
			index++;
		all = all->next;
	}
	return (index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2862
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2854
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x282b
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2810
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2884
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29e1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x29ca
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x29ca
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29e8
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2998
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x20(%rbp)
je 0x2a5e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x2a50
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x2a50
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2a1c
cmpl $-0x1, -0x2c(%rbp)
je 0x2a78
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x41f0
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2a7f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x2970
cmpl $-0x1, %eax
je 0x2b78
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x2970
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x29f0
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
cmpl $0x1, %eax
jle 0x2b3b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x32c0
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x41f0
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x40f0
movq -0x8(%rbp), %rdi
callq 0x2c80
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x32c0
cmpl $-0x1, %eax
jne 0x2b73
movq -0x8(%rbp), %rdi
callq 0x2dc0
jmp 0x2aa2
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/check_sort_ps.c
// Function: check_sort_ps
int		check_sort_ps(t_lists *lists)
{
	int		value;
	t_list	*cursor;
	t_data	*this;
	t_data	*the_next;

	cursor = lists->list_a;
	while (cursor->next)
	{
		this = cursor->content;
		value = this->value;
		the_next = cursor->next->content;
		if (value > the_next->value)
			return (-1);
		cursor = cursor->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2ea3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2e95
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2eaa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e53
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/smaller_index.c
// Function: smaller
int		smaller(t_list *l)
{
	t_list		*cursor;
	t_data		*this;
	int			smaller;

	cursor = l;
	smaller = 2147483647;
	while (cursor)
	{
		this = cursor->content;
		if (this->index < smaller)
			smaller = this->index;
		cursor = cursor->next;
	}
	return (smaller);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0x2efd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2eef
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ec7
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/smaller_index.c
// Function: get_good_smaller
int		get_good_smaller(t_list *la, int smaller_a)
{
	t_list	*cursor;
	t_data	*this;
	int		ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2f6c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2f55
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f73
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2f2a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2f10
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x2feb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2fa4
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/bigger_index.c
// Function: bigger
int		bigger(t_list *l)
{
	t_list		*cursor;
	t_data		*this;
	int			bigger;

	cursor = l;
	bigger = 0;
	while (cursor)
	{
		this = cursor->content;
		if (this->index > bigger)
			bigger = this->index;
		cursor = cursor->next;
	}
	return (bigger);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x304d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x303f
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3017
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: first_in_chunk_index
int		first_in_chunk_index(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x30c5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jl 0x30b7
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jg 0x30b7
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x30cc
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3081
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: last_in_chunk_index
int		last_in_chunk_index(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;
	}
	return (index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x18(%rbp)
je 0x314a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jl 0x313c
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jg 0x313c
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3108
movl -0x24(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: between_index
int		between_index(t_list *lb, int idx)
{
	t_list	*cursor;
	t_data	*this;
	t_data	*next;

	cursor = lb;
	this = cursor->content;
	next = cursor->next->content;
	while (cursor->next)
	{
		this = cursor->content;
		next = cursor->next->content;
		if (idx < this->index && idx > next->index)
			return (next->index);
		cursor = cursor->next;
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x31d4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x31c6
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x31c6
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x31db
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x317d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
cmpl $0x1, %eax
jle 0x3258
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2eb0
cmpl -0x14(%rbp), %eax
jle 0x321f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
cmpl -0x14(%rbp), %eax
jge 0x3243
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
movl %eax, -0x4(%rbp)
jmp 0x32b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x3150
movl %eax, -0x4(%rbp)
jmp 0x32b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
cmpl $0x1, %eax
jne 0x32ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2eb0
cmpl -0x14(%rbp), %eax
jle 0x3285
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x32b6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
cmpl -0x14(%rbp), %eax
jge 0x32a9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
movl %eax, -0x4(%rbp)
jmp 0x32b6
jmp 0x32ab
jmp 0x32ad
jmp 0x32af
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x2970
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x29f0
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3331
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x3060
movl %eax, -0x14(%rbp)
jmp 0x3346
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
callq 0x30e0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x3393
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3393
movq -0x18(%rbp), %rdi
callq 0x2b80
jmp 0x342f
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x33b6
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x33b6
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x33b6
movq -0x18(%rbp), %rdi
callq 0x2d80
jmp 0x342d
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x33d1
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x33d1
movq -0x18(%rbp), %rdi
callq 0x2cc0
jmp 0x342b
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x33fd
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x33fd
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x33fd
movq -0x18(%rbp), %rdi
callq 0x2b80
movq -0x18(%rbp), %rdi
callq 0x2cc0
jmp 0x3429
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3427
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3427
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x3427
movq -0x18(%rbp), %rdi
callq 0x2b80
movq -0x18(%rbp), %rdi
callq 0x2d80
jmp 0x3429
jmp 0x342b
jmp 0x342d
jmp 0x342f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
cmpl $0x1, %eax
jne 0x3462
jmp 0x34f4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
cmpl $0x2, %eax
jne 0x348c
movq -0x8(%rbp), %rdi
callq 0x2e40
cmpl $0x0, %eax
je 0x348a
movq -0x8(%rbp), %rdi
callq 0x2b80
jmp 0x34f4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rcx
callq 0x3360
jmp 0x34f4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x352c
movq -0x8(%rbp), %rdi
callq 0x2c40
movq -0x8(%rbp), %rdi
callq 0x2c40
jmp 0x356b
cmpl $0x2, -0xc(%rbp)
jne 0x3569
movq -0x8(%rbp), %rdi
callq 0x2c40
movq -0x8(%rbp), %rdi
callq 0x2b80
cmpl $0x1, -0x10(%rbp)
jne 0x355e
movq -0x8(%rbp), %rdi
callq 0x2c40
movq -0x8(%rbp), %rdi
callq 0x2b80
jmp 0x3567
movq -0x8(%rbp), %rdi
callq 0x2c40
jmp 0x3569
jmp 0x356b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x3617
movq -0x8(%rbp), %rdi
callq 0x2cc0
movq -0x8(%rbp), %rdi
callq 0x2c40
cmpl $0x0, -0x10(%rbp)
jne 0x35cd
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2c40
jmp 0x3615
cmpl $0x1, -0x10(%rbp)
jne 0x35f9
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2c40
movq -0x8(%rbp), %rdi
callq 0x2b80
jmp 0x3613
cmpl $0x2, -0x10(%rbp)
jne 0x3611
movq -0x8(%rbp), %rdi
callq 0x3890
movq -0x8(%rbp), %rdi
callq 0x2d80
jmp 0x3613
jmp 0x3615
jmp 0x3617
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x4, -0xc(%rbp)
jne 0x36bc
movq -0x8(%rbp), %rdi
callq 0x2c40
cmpl $0x3, -0x10(%rbp)
jne 0x3656
movq -0x8(%rbp), %rdi
callq 0x3890
jmp 0x36ba
cmpl $0x2, -0x10(%rbp)
jne 0x3679
movq -0x8(%rbp), %rdi
callq 0x2cc0
movq -0x8(%rbp), %rdi
callq 0x3890
movq -0x8(%rbp), %rdi
callq 0x2d80
jmp 0x36b8
cmpl $0x1, -0x10(%rbp)
jne 0x369c
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2c40
movq -0x8(%rbp), %rdi
callq 0x2b80
jmp 0x36b6
cmpl $0x0, -0x10(%rbp)
jne 0x36b4
movq -0x8(%rbp), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x2c40
jmp 0x36b6
jmp 0x36b8
jmp 0x36ba
jmp 0x36bc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x36f0
movq -0x10(%rbp), %rdi
callq 0x2c40
jmp 0x3754
cmpl $0x1, -0x4(%rbp)
jne 0x370a
movq -0x10(%rbp), %rdi
callq 0x2c40
movq -0x10(%rbp), %rdi
callq 0x2b80
jmp 0x3752
cmpl $0x2, -0x4(%rbp)
jne 0x3736
movq -0x10(%rbp), %rdi
callq 0x2cc0
movq -0x10(%rbp), %rdi
callq 0x2c40
movq -0x10(%rbp), %rdi
callq 0x2d80
movq -0x10(%rbp), %rdi
callq 0x2d80
jmp 0x3750
cmpl $0x3, -0x4(%rbp)
jne 0x374e
movq -0x10(%rbp), %rdi
callq 0x2c40
movq -0x10(%rbp), %rdi
callq 0x2d80
jmp 0x3750
jmp 0x3752
jmp 0x3754
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x448a
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2e40
cmpl $0x0, %eax
je 0x387f
jmp 0x378f
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x3, %eax
jle 0x37aa
movq -0x8(%rbp), %rdi
callq 0x2c80
jmp 0x378f
movq -0x8(%rbp), %rdi
callq 0x3440
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
cmpl $0x2, %eax
jne 0x386d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3804
movq -0x8(%rbp), %rdi
callq 0x2bc0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x3500
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x3580
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x3620
jmp 0x387d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x36d0
jmp 0x387f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: init_chunks_h
void	init_chunks_h(t_chunk_h *ch, t_list *la)
{
	ch->chunk1 = ft_lstsize(la) / 7;
	ch->chunk2 = 2 * (ft_lstsize(la) / 7);
	ch->chunk3 = 3 * (ft_lstsize(la) / 7);
	ch->chunk4 = 4 * (ft_lstsize(la) / 7);
	ch->chunk5 = 5 * (ft_lstsize(la) / 7);
	ch->chunk6 = 6 * (ft_lstsize(la) / 7);
	ch->chunk7 = ft_lstsize(la) - 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
imull $0x5, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0x7, %ecx
cltd
idivl %ecx
imull $0x6, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl %eax, %ecx
subl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x3a7b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x41f0
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x3a35
jmp 0x3a06
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x3a21
movq -0x8(%rbp), %rdi
callq 0x2dc0
jmp 0x3a06
movq -0x8(%rbp), %rdi
callq 0x2c40
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a76
jmp 0x3a37
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x3a64
movq -0x8(%rbp), %rdi
callq 0x2d00
jmp 0x3a37
movq -0x8(%rbp), %rdi
callq 0x2c40
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x39ac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3000
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x41f0
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x3b08
jmp 0x3aec
cmpl $0x0, -0xc(%rbp)
jle 0x3b06
movq -0x8(%rbp), %rdi
callq 0x2dc0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3aec
jmp 0x3b3c
jmp 0x3b0a
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3b3a
movq -0x8(%rbp), %rdi
callq 0x2d00
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b0a
jmp 0x3b3c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)