LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/push_swap.c
// Function: main
int	main (int argc, char **argv)
{
	t_stack	stack;
	t_aux	aux;

	if (argc == 1)
		return (0);
	argv = &argv[1];
	argc--;
	if (argc == 1)
		argv = check_string(&argc, argv);
	check_args(argc, argv);
	init_stacks(&stack);
	init(&stack, &aux, argc, argv);
	lets_sort(&stack, &aux);
	reduce_instructions(&stack.instr);
	ft_lstiter(stack.instr, &ft_putstr);
	clear(&stack, &aux);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1188
movl $0x0, -0x4(%rbp)
jmp 0x121b
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11b4
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1230
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12a0
leaq -0x28(%rbp), %rdi
callq 0x12e0
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1f20
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1990
leaq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x2600
movq -0x18(%rbp), %rdi
leaq 0x286e(%rip), %rsi      # 0x3a70
callq 0x37d0
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/push_swap.c
// Function: check_string
static char	**check_string(int *argc, char **argv)
{
	int	i;

	i = 0;
	if (!(argv[0][0]))
		exit(0);
	argv = ft_split(argv[0], ' ');
	while (argv[i] != NULL)
		i++;
	*argc = i;
	return (argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
jne 0x125a
xorl %edi, %edi
callq 0x1050
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x3340
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1289
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x126f
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/push_swap.c
// Function: check_args
static void	check_args(int argc, char **argv)
{
	int	i;

	i = 0;
	while (i < argc)
	{
		check_if_arg_are_integer(argv, i);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x12d5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1310
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12b6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/push_swap.c
// Function: check_if_arg_are_integer
static void	check_if_arg_are_integer(char **argv, int i)
{
	int		j;
	double	number;

	j = 0;
	if (argv[i][j] == '-')
	{
		j++;
		if (!argv[i][j])
			return_error();
	}
	while (argv[i][j])
	{
		if (!(ft_isdigit(argv[i][j])))
			return_error();
		j++;
	}
	number = ft_atoi(argv[i]);
	if (number > INT_MAX || number < INT_MIN)
		return_error();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x1365
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1363
callq 0x1d40
jmp 0x1365
jmp 0x1367
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x13ab
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x3310
cmpl $0x0, %eax
jne 0x13a0
callq 0x1d40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1367
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x31f0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x2c3a(%rip), %xmm1     # 0x4008
ucomisd %xmm1, %xmm0
ja 0x13e3
movsd 0x2c34(%rip), %xmm0     # 0x4010
ucomisd -0x18(%rbp), %xmm0
jbe 0x13e8
callq 0x1d40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/operations.c
// Function: swap
void	swap(t_dlist **stack, t_list **instr, char id)
{
	t_dlist	*first;
	t_dlist	*second;

	if (*stack == NULL)
		return ;
	first = *stack;
	second = first->next;
	if (second == NULL)
		return ;
	first->next = second->next;
	first->previous = second;
	if (second->next)
		second->next->previous = first;
	second->next = first;
	second->previous = NULL;
	*stack = second;
	if (id == 'a')
		ft_lstadd_back(instr, ft_lstnew("sa\n"));
	else
		ft_lstadd_back(instr, ft_lstnew("sb\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1414
jmp 0x14dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1437
jmp 0x14dc
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x146e
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jne 0x14bc
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x2b6f(%rip), %rdi      # 0x4018
callq 0x36b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
jmp 0x14dc
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x2b51(%rip), %rdi      # 0x401c
callq 0x36b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/operations.c
// Function: push
void	push(t_dlist **origin_stack, t_dlist **dest_stack,
		t_list **instr, char id)
{
	t_dlist	*origin;
	t_dlist	*dest;

	if (*origin_stack == NULL)
		return ;
	origin = *origin_stack;
	dest = *dest_stack;
	if (origin->next == NULL)
		*origin_stack = NULL;
	else
	{
		*origin_stack = origin->next;
		origin->next->previous = NULL;
	}
	if (dest == NULL)
		return (init_empty_stack(origin, instr, dest_stack, id));
	dest->previous = origin;
	origin->next = dest;
	*dest_stack = dest->previous;
	if (id == 'a')
		ft_lstadd_back(instr, ft_lstnew("pa\n"));
	else
		ft_lstadd_back(instr, ft_lstnew("pb\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1518
jmp 0x15f5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1546
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x1565
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x1583
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsbl -0x19(%rbp), %ecx
callq 0x1600
jmp 0x15f5
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jne 0x15d5
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x2a5e(%rip), %rdi      # 0x4020
callq 0x36b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
jmp 0x15f5
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x2a40(%rip), %rdi      # 0x4024
callq 0x36b0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/operations.c
// Function: init_empty_stack
static void	init_empty_stack(t_dlist *dest, t_list **instr,
		t_dlist **dest_stack, char id)
{
	dest->next = NULL;
	dest->previous = NULL;
	*dest_stack = dest;
	if (id == 'a')
		ft_lstadd_back(instr, ft_lstnew("pa\n"));
	else
		ft_lstadd_back(instr, ft_lstnew("pb\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jne 0x1667
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x29cc(%rip), %rdi      # 0x4020
callq 0x36b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
jmp 0x1687
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x29ae(%rip), %rdi      # 0x4024
callq 0x36b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/operations.c
// Function: rotate
void	rotate(t_dlist **stack, t_list **instr, char id)
{
	t_dlist	*first;
	t_dlist	*last;

	if (*stack == NULL)
		return ;
	first = *stack;
	last = *stack;
	if (last->next == NULL)
		return ;
	first->next->previous = NULL;
	*stack = first->next;
	while (last->next != NULL)
		last = last->next;
	last->next = first;
	first->previous = last;
	first->next = NULL;
	if (id == 'a')
		ft_lstadd_back(instr, ft_lstnew("ra\n"));
	else
		ft_lstadd_back(instr, ft_lstnew("rb\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x16b4
jmp 0x1781
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16da
jmp 0x1781
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1712
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x16f9
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jne 0x1761
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x28db(%rip), %rdi      # 0x4029
callq 0x36b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
jmp 0x1781
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x28be(%rip), %rdi      # 0x402e
callq 0x36b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/operations.c
// Function: reverse_rotate
void	reverse_rotate(t_dlist **stack, t_list **instr, char id)
{
	t_dlist	*first;
	t_dlist	*last;

	if (*stack == NULL)
		return ;
	first = *stack;
	last = *stack;
	while (last->next != NULL)
		last = last->next;
	first->previous = last;
	last->next = first;
	last->previous->next = NULL;
	last->previous = NULL;
	*stack = last;
	if (id == 'a')
		ft_lstadd_back(instr, ft_lstnew("rra\n"));
	else
		ft_lstadd_back(instr, ft_lstnew("rrb\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17b4
jmp 0x186d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x17e3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x17ca
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jne 0x184d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x27ee(%rip), %rdi      # 0x4028
callq 0x36b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
jmp 0x186d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x27d1(%rip), %rdi      # 0x402d
callq 0x36b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3710
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort.c
// Function: debug
void	debug(t_dlist *stack_a, t_dlist *stack_b)
{
	ft_putendl("stack_a");
	ft_dlstiter(stack_a, &ft_putnbr);
	ft_putendl("stack_b");
	ft_dlstiter(stack_b, &ft_putnbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x279b(%rip), %rdi      # 0x4032
callq 0x3ac0
movq -0x8(%rbp), %rdi
leaq 0x2249(%rip), %rsi      # 0x3af0
callq 0x3970
leaq 0x2787(%rip), %rdi      # 0x403a
callq 0x3ac0
movq -0x10(%rbp), %rdi
leaq 0x222d(%rip), %rsi      # 0x3af0
callq 0x3970
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort.c
// Function: is_sorted
int	is_sorted(t_dlist *stack)
{
	if (stack)
	{
		while (stack->next != NULL)
		{
			if (stack->content > stack->next->content)
				return (0);
			stack = stack->next;
		}
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1917
jmp 0x18e1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1915
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jle 0x1907
movl $0x0, -0x4(%rbp)
jmp 0x191e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x18e1
jmp 0x1917
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort.c
// Function: is_full
int	is_full(t_dlist *stack, int total_numbers)
{
	int	numbers_in_stack;

	numbers_in_stack = 0;
	while (stack->next != NULL)
	{
		numbers_in_stack++;
		stack = stack->next;
	}
	numbers_in_stack++;
	if (numbers_in_stack == total_numbers)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1964
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1942
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x197e
movl $0x1, -0x4(%rbp)
jmp 0x1985
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort.c
// Function: lets_sort
void	lets_sort(t_stack *stack, t_aux *aux)
{
	if (is_sorted(stack->a) && is_full(stack->a, aux->total_num))
		return ;
	if (ft_dlstsize(stack->a) <= 5)
		small_sort(stack, aux, ft_dlstsize(stack->a));
	else
	{
		send_half_to_b(stack, aux);
		return_half_to_a(stack, aux, aux->b.higher_index);
	}
	lets_sort(stack, aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x18d0
cmpl $0x0, %eax
je 0x19cb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1930
cmpl $0x0, %eax
je 0x19cb
jmp 0x1a37
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3870
cmpl $0x5, %eax
jg 0x1a09
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3870
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl %eax, %edx
callq 0x29d0
jmp 0x1a2a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edx
callq 0x2520
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1990
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort_aux.c
// Function: rewind
void	rewind(t_dlist **stack_to_rewind)
{
	t_dlist	*stack;

	stack = *stack_to_rewind;
	while (stack->previous != NULL)
		stack = stack->previous;
	*stack_to_rewind = stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1a9c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1a83
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort_aux.c
// Function: fast_forward
void	fast_forward(t_dlist **stack_to_fast_forward)
{
	t_dlist	*stack;

	stack = *stack_to_fast_forward;
	while (stack->next != NULL)
		stack = stack->next;
	*stack_to_fast_forward = stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1adc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1ac3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/sort_aux.c
// Function: order_a
void	order_a(t_stack *stack, t_aux *aux)
{
	if (stack->a->index == 0)
		rotate(&stack->a, &stack->instr, 'a');
	while (((stack->a->index + 1) == (stack->a->next->index))
		&& ((stack->a->index - 1) == last_num_index(stack->a)))
		rotate(&stack->a, &stack->instr, 'a');
	if (((stack->a->index - 1) == last_num_index(stack->a)))
		rotate(&stack->a, &stack->instr, 'a');
	aux->a.next_index_to_sort = last_num_index(stack->a) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1b53
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
jmp 0x1b55
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x1ba0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1af0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1ba9
jmp 0x1bc1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
jmp 0x1b55
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1af0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x1bfc
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1af0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/quick_sort.c
// Function: quick_sort
void	quick_sort(int *array, int left, int right)
{
	int	index_pivot;

	if (left < right)
	{
		index_pivot = partition(array, left, right);
		quick_sort(array, left, index_pivot - 1);
		quick_sort(array, index_pivot + 1, right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1c70
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1c80
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
subl $0x1, %edx
callq 0x1c20
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x1c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/quick_sort.c
// Function: partition
static int	partition(int *array, int left, int right)
{
	int	i;
	int	j;
	int	pivot;
	int	temp;

	pivot = array[left];
	i = left;
	j = left + 1;
	while (j <= right)
	{
		if (array[j] < pivot)
		{
			i++;
			temp = array[j];
			array[j] = array[i];
			array[i] = temp;
		}
		j++;
	}
	temp = array[left];
	array[left] = array[i];
	array[i] = temp;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x1d09
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1cfe
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1cab
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/system.c
// Function: clear
void	clear(t_stack *stack, t_aux *aux)
{
	ft_dlstclear(&stack->a);
	ft_dlstclear(&stack->b);
	ft_lstclear(&stack->instr, &free);
	free(aux->ordered_array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3910
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3910
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq 0x523b(%rip), %rsi      # 0x6fd0
callq 0x3770
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/choose_rotation.c
// Function: reverse_rotation_is_quicker
int	reverse_rotation_is_quicker(t_dlist *stack, int target_number)
{
	int	rotation_steps;
	int	reverse_rotation_steps;

	rotation_steps = calculate_rotation_steps(stack, target_number, 0);
	while (stack->next != NULL)
		stack = stack->next;
	reverse_rotation_steps = calculate_rr_steps(stack, target_number, 0);
	if (reverse_rotation_steps < rotation_steps)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x1e20
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1de9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1dd0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x1ea0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1e0b
movl $0x1, -0x4(%rbp)
jmp 0x1e12
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/choose_rotation.c
// Function: calculate_rotation_steps
static int	calculate_rotation_steps(t_dlist *stack,
		int target_number, int steps)
{
	if (!stack)
		return (INT_MAX);
	if (stack->index == target_number)
		return (steps);
	if (!stack->next)
		return (INT_MAX);
	stack = stack->next;
	return (calculate_rotation_steps(stack, target_number, (steps + 1)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e42
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x1e8b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1e56
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e8b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e6a
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x1e8b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
callq 0x1e20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/choose_rotation.c
// Function: calculate_rr_steps
static int	calculate_rr_steps(t_dlist *stack,
		int target_number, int steps)
{
	if (!stack)
		return (INT_MAX);
	if (stack->index == target_number)
		return (steps);
	if (!stack->previous)
		return (INT_MAX);
	stack = stack->previous;
	return (calculate_rr_steps(stack, target_number, (steps + 1)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ec2
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x1f0b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1ed6
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f0b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1eea
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jmp 0x1f0b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
callq 0x1ea0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/init.c
// Function: init_aux
static void	init_aux(t_dlist *stack_a, t_aux *aux, int argc)
{
	ft_memset(aux, 0, sizeof(*aux));
	aux->total_num = argc;
	aux->ordered_array = fill_ordered_array(stack_a, aux->total_num);
	aux->a.higher_index = aux->total_num - 1;
	aux->a.next_index_to_sort = 0;
	aux->a.mid_index = find_mid_index(aux->a.higher_index,
			aux->a.next_index_to_sort);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3190
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x1a40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/init.c
// Function: fill_stack_indexes
static void	fill_stack_indexes(t_stack *stack, t_aux *aux)
{
	if (stack->a->next == NULL)
	{
		stack->a->index = find_index(stack, aux, 0);
		rewind(&stack->a);
		return ;
	}
	stack->a->index = find_index(stack, aux, 0);
	stack->a = stack->a->next;
	fill_stack_indexes(stack, aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2044
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x1a70
jmp 0x207e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/init.c
// Function: fill_ordered_array
static int	*fill_ordered_array(t_dlist *stack_a, int total)
{
	int	*ordered_array;
	int	i;

	ordered_array = (int *)malloc((total) * sizeof(int));
	if (!ordered_array)
		return_error();
	i = 0;
	while (i < (total))
	{
		ordered_array[i] = stack_a->content;
		i++;
		stack_a = stack_a->next;
	}
	quick_sort(ordered_array, 0, (total - 1));
	return (ordered_array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1040
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x20bc
callq 0x1d40
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x20f3
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x20c3
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x1c20
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/init_stack_a.c
// Function: init_stack_a
void	init_stack_a(int argc, char **argv, t_dlist	**stack_a)
{
	int	number;
	int	i;

	i = 0;
	number = (int)ft_atoi(argv[i]);
	*stack_a = ft_dlstnew(number);
	while (i < (argc - 1))
	{
		i++;
		number = (int)ft_atoi(argv[i]);
		if (is_repeated(*stack_a, number))
			return_error();
		else
			ft_dlstadd_back(stack_a, ft_dlstnew(number));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x31f0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x3820
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x221b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x31f0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x2230
cmpl $0x0, %eax
je 0x21fd
callq 0x1d40
jmp 0x2219
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x3820
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x38b0
jmp 0x21b4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/init_stack_a.c
// Function: is_repeated
static int	is_repeated(t_dlist *lst, int number)
{
	t_dlist	*aux;

	if (lst == NULL)
		return (0);
	aux = lst;
	while (aux != NULL)
	{
		if ((int)aux->content == number)
			return (1);
		aux = aux->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x224b
movl $0x0, -0x4(%rbp)
jmp 0x2283
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x227c
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x226e
movl $0x1, -0x4(%rbp)
jmp 0x2283
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2253
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/send_to_b.c
// Function: any_small_in_stack_a
int	any_small_in_stack_a(t_dlist *stack_a, t_aux *aux)
{
	while (stack_a != NULL)
	{
		if (stack_a->index <= aux->a.mid_index)
			if (stack_a->index >= aux->a.next_index_to_sort)
				return (1);
		stack_a = stack_a->next;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x22dc
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x22ce
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x22cc
movl $0x1, -0x4(%rbp)
jmp 0x22e3
jmp 0x22ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x229c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/send_to_b.c
// Function: send_half_to_b
void	send_half_to_b(t_stack *stack, t_aux *aux)
{
	int		size_a;

	init_values(stack, aux, &size_a);
	if ((aux->a.higher_index - aux->a.next_index_to_sort) < LAST_CHUNCK)
		while (stack->a->index > 0)
			send_to_b(stack, aux);
	else
		send_smallers_to_b(stack, aux, size_a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2360
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
cmpl $0xa, %eax
jge 0x2344
jmp 0x2326
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2342
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23c0
jmp 0x2326
jmp 0x2354
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2440
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/send_to_b.c
// Function: init_values
static void	init_values(t_stack *stack, t_aux *aux, int *size_a)
{
	*size_a = ft_dlstsize(stack->a);
	aux->b.higher_index = INT_MIN;
	aux->b.lower_index = INT_MAX;
	aux->a.mid_index = find_mid_index(aux->a.higher_index,
			aux->a.next_index_to_sort);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3870
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x80000000, 0x1c(%rax) # imm = 0x80000000
movq -0x10(%rbp), %rax
movl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x1a40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/send_to_b.c
// Function: send_to_b
static void	send_to_b(t_stack *stack, t_aux *aux)
{
	push(&stack->a, &stack->b, &stack->instr, 'b');
	if (stack->b->index > aux->b.higher_index)
		aux->b.higher_index = stack->b->index;
	if (stack->b->index < aux->b.lower_index)
		aux->b.lower_index = stack->b->index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x62, %ecx
callq 0x14f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x2414
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x243a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/send_to_b.c
// Function: send_smallers_to_b
static void	send_smallers_to_b(t_stack *stack, t_aux *aux, int size_a)
{
	int		rotations;
	int		i;

	i = 0;
	rotations = 0;
	while ((i < size_a) && (any_small_in_stack_a(stack->a, aux)))
	{
		if (stack->a->index <= aux->a.mid_index)
			send_to_b(stack, aux);
		else
		{
			rotate(&stack->a, &stack->instr, 'a');
			rotations++;
		}
		i++;
	}
	if (aux->a.next_index_to_sort)
	{
		i = 0;
		while (i < rotations)
		{
			reverse_rotate(&stack->a, &stack->instr, 'a');
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0x2487
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2290
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x2490
jmp 0x24dc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x24b2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23c0
jmp 0x24d1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2461
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x2518
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2516
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1790
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x24ed
jmp 0x2518
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a.c
// Function: return_half_to_a
void	return_half_to_a(t_stack *stack, t_aux *aux, int limit)
{
	int	size_b;

	size_b = ft_dlstsize(stack->b);
	if (size_b < 50)
	{
		finish_sorting(stack, aux);
		return ;
	}
	start_sorting(stack, aux);
	resend_to_b(stack, aux, limit);
	return_half_to_a(stack, aux, limit);
}

// 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
movq 0x8(%rax), %rdi
callq 0x3870
movl %eax, -0x18(%rbp)
cmpl $0x32, -0x18(%rbp)
jge 0x2558
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dd0
jmp 0x2585
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3090
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2590
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2520
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/reduce_instructions.c
// Function: reduce_instructions
void	reduce_instructions(t_list **instructions)
{
	t_list	*instr;

	instr = *instructions;
	while (instr)
	{
		if (is_reducible(instr->content))
			if (instr->next)
				if (next_is_a_match(instr->content, instr->next->content))
					replace_instructions(&instr, instr->content);
		instr = instr->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2678
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2680
cmpl $0x0, %eax
je 0x266a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2668
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
callq 0x26e0
cmpl $0x0, %eax
je 0x2666
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x10(%rbp), %rdi
callq 0x2880
jmp 0x2668
jmp 0x266a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2617
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/reduce_instructions.c
// Function: next_is_a_match
static int	next_is_a_match(char *id, char *id_next)
{
	if ((ft_strnequ(id, "rra", 3)) && (ft_strnequ(id_next, "rrb", 3)))
		return (1);
	if ((ft_strnequ(id, "ra", 2)) && (ft_strnequ(id_next, "rb", 2)))
		return (1);
	if ((ft_strnequ(id, "sa", 2)) && (ft_strnequ(id_next, "sb", 2)))
		return (1);
	if ((ft_strnequ(id, "rrb", 3)) && (ft_strnequ(id_next, "rra", 3)))
		return (1);
	if ((ft_strnequ(id, "rb", 2)) && (ft_strnequ(id_next, "ra", 2)))
		return (1);
	if ((ft_strnequ(id, "sb", 2)) && (ft_strnequ(id_next, "sa", 2)))
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1954(%rip), %rsi      # 0x404f
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x2730
movq -0x18(%rbp), %rdi
leaq 0x193e(%rip), %rsi      # 0x4053
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x2730
movl $0x1, -0x4(%rbp)
jmp 0x2871
movq -0x10(%rbp), %rdi
leaq 0x1915(%rip), %rsi      # 0x4050
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x2770
movq -0x18(%rbp), %rdi
leaq 0x18ff(%rip), %rsi      # 0x4054
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x2770
movl $0x1, -0x4(%rbp)
jmp 0x2871
movq -0x10(%rbp), %rdi
leaq 0x18dc(%rip), %rsi      # 0x4057
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x27b0
movq -0x18(%rbp), %rdi
leaq 0x18c5(%rip), %rsi      # 0x405a
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x27b0
movl $0x1, -0x4(%rbp)
jmp 0x2871
movq -0x10(%rbp), %rdi
leaq 0x1898(%rip), %rsi      # 0x4053
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x27f0
movq -0x18(%rbp), %rdi
leaq 0x187a(%rip), %rsi      # 0x404f
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x27f0
movl $0x1, -0x4(%rbp)
jmp 0x2871
movq -0x10(%rbp), %rdi
leaq 0x1859(%rip), %rsi      # 0x4054
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x282d
movq -0x18(%rbp), %rdi
leaq 0x183b(%rip), %rsi      # 0x4050
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x282d
movl $0x1, -0x4(%rbp)
jmp 0x2871
movq -0x10(%rbp), %rdi
leaq 0x1822(%rip), %rsi      # 0x405a
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x286a
movq -0x18(%rbp), %rdi
leaq 0x1805(%rip), %rsi      # 0x4057
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x286a
movl $0x1, -0x4(%rbp)
jmp 0x2871
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/reduce_instructions.c
// Function: replace_instructions
static void	replace_instructions(t_list **instr, char *id)
{
	if ((ft_strnequ(id, "rra", 3)) || (ft_strnequ(id, "rrb", 3)))
		replace(instr, "rrr\n");
	if ((ft_strnequ(id, "ra", 2)) || (ft_strnequ(id, "rb", 2)))
		replace(instr, "rr\n");
	if ((ft_strnequ(id, "sa", 2)) || (ft_strnequ(id, "sb", 2)))
		replace(instr, "ss\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x17b4(%rip), %rsi      # 0x404f
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
jne 0x28c4
movq -0x10(%rbp), %rdi
leaq 0x179e(%rip), %rsi      # 0x4053
movl $0x3, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x28d4
movq -0x8(%rbp), %rdi
leaq 0x178e(%rip), %rsi      # 0x405d
callq 0x2970
movq -0x10(%rbp), %rdi
leaq 0x1771(%rip), %rsi      # 0x4050
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
jne 0x2908
movq -0x10(%rbp), %rdi
leaq 0x175b(%rip), %rsi      # 0x4054
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x2918
movq -0x8(%rbp), %rdi
leaq 0x174b(%rip), %rsi      # 0x405e
callq 0x2970
movq -0x10(%rbp), %rdi
leaq 0x1734(%rip), %rsi      # 0x4057
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
jne 0x294c
movq -0x10(%rbp), %rdi
leaq 0x171d(%rip), %rsi      # 0x405a
movl $0x2, %edx
callq 0x3b70
cmpl $0x0, %eax
je 0x295c
movq -0x8(%rbp), %rdi
leaq 0x170b(%rip), %rsi      # 0x4062
callq 0x2970
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/reduce_instructions.c
// Function: replace
static void	replace(t_list **instr, char *content)
{
	t_list	*new_node;
	t_list	*orphan_node;

	new_node = *instr;
	new_node->content = content;
	orphan_node = new_node->next;
	new_node->next = new_node->next->next;
	free(orphan_node);
	*instr = new_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/small_sort.c
// Function: small_sort
void	small_sort(t_stack *stack, t_aux *aux, int total_numbers)
{
	int	first;
	int	second;
	int	last;

	(void)aux;
	if (is_sorted(stack->a) && is_full(stack->a, total_numbers))
		return ;
	if (ft_dlstsize(stack->a) == 2)
	{
		swap(&stack->a, &stack->instr, 'a');
		return ;
	}
	if (ft_dlstsize(stack->a) == 3)
	{
		define_numbers(&first, &second, &last, stack->a);
		sort_three(stack, &first, &second, &last);
		return_to_a(stack);
	}
	else
		send_to_b(stack, aux, total_numbers);
	small_sort(stack, aux, total_numbers);
}

// 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
movq (%rax), %rdi
callq 0x18d0
cmpl $0x0, %eax
je 0x2a0d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x1930
cmpl $0x0, %eax
je 0x2a0d
jmp 0x2a9f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3870
cmpl $0x2, %eax
jne 0x2a36
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x13f0
jmp 0x2a9f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3870
cmpl $0x3, %eax
jne 0x2a7f
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2ab0
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x2b10
movq -0x8(%rbp), %rdi
callq 0x2c70
jmp 0x2a8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x29d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/small_sort.c
// Function: define_numbers
static void	define_numbers(int *first, int *second, int *last, t_dlist *stack)
{
	*first = stack->content;
	*second = stack->next->content;
	while (stack->next != NULL)
		stack = stack->next;
	*last = stack->content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2af9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2ae0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)