LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/small_sort.c
// Function: sort_three
static void	sort_three(t_stack *stack, int *first, int *second, int *last)
{
	if (is_sorted(stack->a))
		return ;
	if ((*first > *second && *last > *second && *first < *last)
		|| (*first > *second && *last < *second && *first > *last)
		|| (*first < *second && *last < *second && *first < *last))
		swap(&stack->a, &stack->instr, 'a');
	define_numbers(first, second, last, stack->a);
	if (*first > *second && *last > *second && *first > *last)
		rotate(&stack->a, &stack->instr, 'a');
	if (*first < *second && *last < *second && *first > *last)
		reverse_rotate(&stack->a, &stack->instr, 'a');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x18d0
cmpl $0x0, %eax
je 0x2b3e
jmp 0x2c6a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2b68
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2b68
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2bbc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2b92
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2b92
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x2bbc
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2bd2
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2bd2
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2bd2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x13f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
callq 0x2ab0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2c2a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2c2a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2c2a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2c6a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2c6a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x2c6a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1790
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/small_sort.c
// Function: return_to_a
static void	return_to_a(t_stack *stack)
{
	if (!stack->b)
		return ;
	if (stack->b->next)
		if (stack->b->index < stack->b->next->index)
			swap(&stack->b, &stack->instr, 'b');
	push(&stack->b, &stack->a, &stack->instr, 'a');
	if (stack->a->index > stack->a->next->index)
		swap(&stack->a, &stack->instr, 'a');
	return_to_a(stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2c8c
jmp 0x2d2a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x2cd3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2cd1
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x62, %edx
callq 0x13f0
jmp 0x2cd3
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x61, %ecx
callq 0x14f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jle 0x2d21
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x13f0
movq -0x8(%rbp), %rdi
callq 0x2c70
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/small_sort.c
// Function: send_to_b
static void	send_to_b(t_stack *stack, t_aux *aux, int total_numbers)
{
	if (ft_dlstsize(stack->a) == 3)
		return ;
	if ((stack->a->index == 0) || (stack->a->index == 1))
	{
		aux->a.higher_index--;
		push(&stack->a, &stack->b, &stack->instr, 'b');
	}
	else
		rotate(&stack->a, &stack->instr, 'a');
	send_to_b(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 0x3870
cmpl $0x3, %eax
jne 0x2d56
jmp 0x2dc3
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x2d70
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x4(%rax)
jne 0x2d9d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x62, %ecx
callq 0x14f0
jmp 0x2db3
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2d30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a_sorting.c
// Function: finish_sorting
void	finish_sorting(t_stack *stack, t_aux *aux)
{
	int	size_b;

	size_b = ft_dlstsize(stack->b);
	define_b_values(stack, aux);
	if (size_b == 0)
	{
		order_a(stack, aux);
		return ;
	}
	else if (size_b == 1)
		push(&stack->b, &stack->a, &stack->instr, 'a');
	else if (stack->b->index == aux->a.next_index_to_sort)
		send_next_smaller_to_a(stack, aux);
	else if (stack->b->index == aux->b.higher_index)
		send_next_bigger_to_a(stack, aux);
	else if (reverse_rotation_is_quicker(stack->b, aux->a.next_index_to_sort))
		reverse_rotate(&stack->b, &stack->instr, 'b');
	else
		rotate(&stack->b, &stack->instr, 'b');
	finish_sorting(stack, aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3870
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ef0
cmpl $0x0, -0x14(%rbp)
jne 0x2e15
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b20
jmp 0x2ee8
cmpl $0x1, -0x14(%rbp)
jne 0x2e3e
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x61, %ecx
callq 0x14f0
jmp 0x2ed9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x2e61
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2fa0
jmp 0x2ed7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x2e84
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3010
jmp 0x2ed5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x1db0
cmpl $0x0, %eax
je 0x2eb9
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x62, %edx
callq 0x1790
jmp 0x2ed3
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x62, %edx
callq 0x1690
jmp 0x2ed5
jmp 0x2ed7
jmp 0x2ed9
jmp 0x2edb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dd0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a_sorting.c
// Function: define_b_values
static void	define_b_values(t_stack *stack, t_aux *aux)
{
	t_dlist	*stack_b;

	stack_b = stack->b;
	aux->b.higher_index = INT_MIN;
	aux->b.lower_index = INT_MAX;
	while (stack_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;
		stack_b = stack_b->next;
	}
	aux->b.mid_index = find_mid_index(aux->b.higher_index, aux->b.lower_index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x80000000, 0x1c(%rax) # imm = 0x80000000
movq -0x10(%rbp), %rax
movl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
cmpq $0x0, -0x18(%rbp)
je 0x2f73
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x2f47
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2f65
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2f22
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x1a40
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a_sorting.c
// Function: send_next_smaller_to_a
static void	send_next_smaller_to_a(t_stack *stack, t_aux *aux)
{
	push(&stack->b, &stack->a, &stack->instr, 'a');
	rotate(&stack->a, &stack->instr, 'a');
	aux->a.next_index_to_sort++;
	aux->b.lower_index++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x61, %ecx
callq 0x14f0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a_sorting.c
// Function: send_next_bigger_to_a
static void	send_next_bigger_to_a(t_stack *stack, t_aux *aux)
{
	push(&stack->b, &stack->a, &stack->instr, 'a');
	aux->b.higher_index--;
	if (stack->a->index == aux->a.next_index_to_sort)
	{
		rotate(&stack->a, &stack->instr, 'a');
		aux->a.next_index_to_sort++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x61, %ecx
callq 0x14f0
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x3081
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x61, %edx
callq 0x1690
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/./source/return_to_a_sorting.c
// Function: start_sorting
void	start_sorting(t_stack *stack, t_aux *aux)
{
	int	size_b;

	size_b = ft_dlstsize(stack->b);
	define_b_values(stack, aux);
	if (size_b == 0)
		return ;
	if ((stack->b->index > aux->b.mid_index) || (size_b == 1))
		push(&stack->b, &stack->a, &stack->instr, 'a');
	else if (stack->b->index == aux->a.next_index_to_sort)
		send_next_smaller_to_a(stack, aux);
	else if (reverse_rotation_is_quicker(stack->b, aux->a.next_index_to_sort))
		reverse_rotate(&stack->b, &stack->instr, 'b');
	else
		rotate(&stack->b, &stack->instr, 'b');
	start_sorting(stack, aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3870
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ef0
cmpl $0x0, -0x14(%rbp)
jne 0x30c8
jmp 0x3185
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jg 0x30e2
cmpl $0x1, -0x14(%rbp)
jne 0x3102
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movl $0x61, %ecx
callq 0x14f0
jmp 0x3178
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x3125
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2fa0
jmp 0x3176
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x1db0
cmpl $0x0, %eax
je 0x315a
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x62, %edx
callq 0x1790
jmp 0x3174
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x62, %edx
callq 0x1690
jmp 0x3176
jmp 0x3178
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3090
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *s, int c, size_t n)
{
	size_t	i;
	char	cc;
	char	*pointer_aux;

	i = 0;
	cc = (char)c;
	pointer_aux = (char *)s;
	while (i < n)
	{
		pointer_aux[i] = cc;
		i++;
	}
	return ((void *)s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x31db
movb -0x21(%rbp), %dl
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x31b5
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_atoi.c
// Function: ft_atoi
double	ft_atoi(const char *nptr)
{
	double	number;
	int		sign;

	number = 0;
	sign = 1;
	while (atoi_isspace(*nptr))
		nptr++;
	if (*nptr == '-' || *nptr == '+')
	{
		if (*nptr == '-')
			sign *= -1;
		nptr++;
	}
	while (ft_isdigit(*nptr))
	{
		number *= 10;
		number += (*nptr - '0');
		nptr++;
	}
	number *= sign;
	return (number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x32d0
cmpl $0x0, %eax
je 0x322a
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x320b
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3242
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x3261
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3255
imull $-0x1, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3263
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x3310
cmpl $0x0, %eax
je 0x32ac
movsd 0xdec(%rip), %xmm0      # 0x4068
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3263
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_atoi.c
// Function: atoi_isspace
static int	atoi_isspace(int c)
{
	if (c == ' ' || c == '\v' || c == '\n'
		|| c == '\t' || c == '\r' || c == '\f')
	{
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
je 0x32fb
cmpl $0xb, -0x8(%rbp)
je 0x32fb
cmpl $0xa, -0x8(%rbp)
je 0x32fb
cmpl $0x9, -0x8(%rbp)
je 0x32fb
cmpl $0xd, -0x8(%rbp)
je 0x32fb
cmpl $0xc, -0x8(%rbp)
jne 0x3304
movl $0x1, -0x4(%rbp)
jmp 0x330b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_split.c
// Function: ft_split
char	**ft_split(char const *s, char c)
{
	char		**str_array;
	t_split		split;

	split.words = word_count(s, c);
	str_array = (char **)malloc((split.words + 1) * sizeof(char *));
	if (!(str_array) || (!s))
		return (NULL);
	split.i = 0;
	split.i_array = 0;
	while (s[split.i] != '\0')
	{
		if (s[split.i] != c)
		{
			split.sub_length = sub_len(&s[split.i], c);
			str_array[split.i_array] = ft_substr(s, split.i, split.sub_length);
			if (!(str_array[split.i_array]))
				return (free_str_array(str_array));
			split.i_array++;
			split.i += split.sub_length - 1;
		}
		split.i++;
	}
	str_array[split.i_array] = NULL;
	return (str_array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3470
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x1040
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3386
cmpq $0x0, -0x10(%rbp)
jne 0x3393
movq $0x0, -0x8(%rbp)
jmp 0x3466
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x344e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x343d
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3590
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq -0x40(%rbp), %rdx
callq 0x3c20
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3421
movq -0x20(%rbp), %rdi
callq 0x3600
movq %rax, -0x8(%rbp)
jmp 0x3466
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
subq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x33a3
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_split.c
// Function: word_count
static size_t	word_count(char const *s, char c)
{
	size_t		words_count;
	size_t		i;

	if (!s)
		return (0);
	words_count = 0;
	i = 0;
	while (s[i] != '\0')
	{
		while (s[i] == c && (s[i] != '\0'))
		{
			i++;
		}
		if ((s[i] != c) && (s[i] != '\0'))
		{
			words_count++;
			while ((s[i] != c) && (s[i] != '\0'))
			{
				i++;
			}
		}
	}
	return (words_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3492
movq $0x0, -0x8(%rbp)
jmp 0x3583
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x357b
jmp 0x34b9
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jne 0x34e7
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x34f0
jmp 0x34fe
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x34b9
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x3576
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3576
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x2a(%rbp)
je 0x355d
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x3566
jmp 0x3574
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x352f
jmp 0x3576
jmp 0x34a2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_split.c
// Function: sub_len
static size_t	sub_len(char const *s, char c)
{
	size_t		length;

	length = 0;
	while ((s[length] != '\0') && (s[length] != c))
	{
		length++;
	}
	return (length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x35d4
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x35dd
jmp 0x35eb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x35a6
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_split.c
// Function: free_str_array
static char	**free_str_array(char **str_array)
{
	size_t	i;

	i = 0;
	while (str_array[i])
	{
		free(str_array[i]);
		i++;
	}
	free(str_array);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3642
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3614
movq -0x8(%rbp), %rdi
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_putstr_fd.c
// Function: ft_putstr_fd
void	ft_putstr_fd(char *s, int fd)
{
	if (!s)
		return ;
	while (*s != '\0')
	{
		ft_putchar_fd(*s, fd);
		s++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3678
jmp 0x36a5
jmp 0x367a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x36a5
movq -0x8(%rbp), %rax
movb (%rax), %al
movl -0xc(%rbp), %esi
movsbl %al, %edi
callq 0x3d20
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x367a
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void *content)
{
	t_list	*pointer;

	pointer = (t_list *)malloc(sizeof(t_list));
	if (!pointer)
		return (NULL);
	pointer->content = content;
	pointer->next = NULL;
	return (pointer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1040
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x36db
movq $0x0, -0x8(%rbp)
jmp 0x36fa
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_lstadd_back.c
// Function: ft_lstadd_back
void	ft_lstadd_back(t_list **lst, t_list *new)
{
	t_list	*aux;

	if (new == NULL)
		return ;
	if (*lst == NULL)
	{
		*lst = new;
		return ;
	}
	aux = ft_lstlast(*lst);
	aux->next = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3729
jmp 0x375c
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3740
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x375c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3d50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_lstclear.c
// Function: ft_lstclear
void	ft_lstclear(t_list **lst, void (*del)(void *))
{
	t_list	*aux;
	t_list	*temp;

	aux = *lst;
	if (aux == NULL)
		return ;
	while (aux != NULL)
	{
		temp = aux->next;
		del(aux);
		aux = temp;
	}
	*lst = NULL;
}

// 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)
cmpq $0x0, -0x18(%rbp)
jne 0x3794
jmp 0x37c8
jmp 0x3796
cmpq $0x0, -0x18(%rbp)
je 0x37bd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3796
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_lstiter.c
// Function: ft_lstiter
void	ft_lstiter(t_list *lst, void (*f)(const char *))
{
	t_list	*aux;

	if (lst == NULL)
		return ;
	aux = lst;
	while (aux != NULL)
	{
		f(aux->content);
		aux = aux->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x37e9
jmp 0x3813
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3813
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x37f1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstnew.c
// Function: ft_dlstnew
t_dlist	*ft_dlstnew(int content)
{
	t_dlist	*pointer;

	pointer = (t_dlist *)malloc(sizeof(t_dlist));
	if (!(pointer))
		return_error();
	pointer->content = content;
	pointer->next = NULL;
	pointer->previous = NULL;
	return (pointer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x1040
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3845
callq 0x1d40
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstsize.c
// Function: ft_dlstsize
int	ft_dlstsize(t_dlist *lst)
{
	t_dlist	*aux;
	int		size;

	aux = lst;
	size = 0;
	while (aux != NULL)
	{
		size++;
		aux = aux->next;
	}
	return (size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38a5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3887
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstadd_back.c
// Function: ft_dlstadd_back
void	ft_dlstadd_back(t_dlist **lst, t_dlist *new)
{
	t_dlist	*aux;

	if (new == NULL)
		return ;
	if (*lst == NULL)
	{
		*lst = new;
		return ;
	}
	aux = ft_dlstlast(*lst);
	aux->next = new;
	new->previous = aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x38c9
jmp 0x3908
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x38e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3908
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3da0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstclear.c
// Function: ft_dlstclear
void	ft_dlstclear(t_dlist **lst)
{
	t_dlist	*aux;
	t_dlist	*temp;

	aux = *lst;
	if (aux == NULL)
		return ;
	while (aux != NULL)
	{
		temp = aux->next;
		free(aux);
		aux = temp;
	}
	*lst = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3930
jmp 0x3963
jmp 0x3932
cmpq $0x0, -0x10(%rbp)
je 0x3958
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3932
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstiter.c
// Function: ft_dlstiter
void	ft_dlstiter(t_dlist *lst, void (*f)(int))
{
	t_dlist	*aux;

	if (lst == NULL)
		return ;
	aux = lst;
	while (aux != NULL)
	{
		f(aux->content);
		ft_putchar('\n');
		aux = aux->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3989
jmp 0x39bc
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x39bc
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edi
callq *%rax
movl $0xa, %edi
callq 0x3a40
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3991
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstiter.c
// Function: ft_dlstiter_reverse
void	ft_dlstiter_reverse(t_dlist *lst, void (*f)(int))
{
	t_dlist	*aux;

	if (lst == NULL)
		return ;
	aux = lst;
	while (aux->next != NULL)
		aux = aux->next;
	while (aux != NULL)
	{
		f(aux->content);
		ft_putchar('\n');
		aux = aux->previous;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x39e9
jmp 0x3a37
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a0a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x39f1
jmp 0x3a0c
cmpq $0x0, -0x18(%rbp)
je 0x3a37
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edi
callq *%rax
movl $0xa, %edi
callq 0x3a40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3a0c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_putstr.c
// Function: ft_putstr
void	ft_putstr(char const *s)
{
	if (!s)
		return ;
	while (*s != '\0')
	{
		ft_putchar(*s);
		s++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3a85
jmp 0x3aad
jmp 0x3a87
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3aad
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x3a40
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3a87
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_putnbr.c
// Function: ft_putnbr
void	ft_putnbr(int nb)
{
	unsigned int	number;

	if (nb < 0)
	{
		number = nb * -1;
		ft_putchar('-');
	}
	else
	{
		number = nb;
	}
	if (number / 10 < 1)
	{
		ft_putchar(number + '0');
	}
	else
	{
		ft_putnbr(number / 10);
		ft_putnbr(number % 10);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x3b14
imull $-0x1, -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x2d, %edi
callq 0x3a40
jmp 0x3b1a
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x1, %eax
jae 0x3b3b
movl -0x8(%rbp), %eax
addl $0x30, %eax
movsbl %al, %edi
callq 0x3a40
jmp 0x3b61
movl -0x8(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %edi
callq 0x3af0
movl -0x8(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %edi
callq 0x3af0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_strnequ.c
// Function: ft_strnequ
int	ft_strnequ(char const *s1, char const *s2, size_t n)
{
	size_t	i;

	if (!s1 || !s2)
		return (0);
	i = 0;
	while ((s1[i] != '\0' || s2[i] != '\0') && i < n)
	{
		if (s1[i] != s2[i])
		{
			return (0);
		}
		i++;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b8e
cmpq $0x0, -0x18(%rbp)
jne 0x3b9a
movl $0x0, -0x4(%rbp)
jmp 0x3c1a
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3bc9
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x3bd7
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3be0
jmp 0x3c13
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3c05
movl $0x0, -0x4(%rbp)
jmp 0x3c1a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3ba2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	size_t	i;
	char	*new_string;

	if (!s)
		return (NULL);
	new_string = (char *)malloc((len + 1) * sizeof(char));
	if (new_string == NULL)
		return (NULL);
	i = 0;
	while ((i < len) && ((start + i) < ft_strlen(s)) && (s[start + i] != '\0'))
	{
		new_string[i] = s[start + i];
		i++;
	}
	new_string[i] = '\0';
	return (new_string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c47
movq $0x0, -0x8(%rbp)
jmp 0x3d08
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3c70
movq $0x0, -0x8(%rbp)
jmp 0x3d08
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x3cc4
movl -0x14(%rbp), %eax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3df0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jae 0x3cc4
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3ccd
jmp 0x3cf4
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3c78
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_lstlast.c
// Function: ft_lstlast
t_list	*ft_lstlast(t_list *lst)
{
	t_list	*aux;

	if (lst == NULL)
		return (lst);
	aux = lst;
	while (aux->next != NULL)
	{
		aux = aux->next;
	}
	return (aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d69
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d92
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d8a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3d71
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_dlstlast.c
// Function: ft_dlstlast
t_dlist	*ft_dlstlast(t_dlist *lst)
{
	t_dlist	*aux;

	if (lst == NULL)
		return (lst);
	aux = lst;
	while (aux->next != NULL)
	{
		aux = aux->next;
	}
	return (aux);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3db9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3de2
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3dda
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3dc1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/paulahemsi[P]push_swap/libraries/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t	length;

	length = 0;
	while (s[length] != '\0')
	{
		length++;
	}
	return (length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3e1f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e00
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/silo.cpp
// Function: silo_get_text_width(nk_handle, float, char const*, int)
float silo_get_text_width(nk_handle handle, float height, const char *text, int len)
{
	int w, h;
	pango_layout_set_attributes(layout, nullptr);
	pango_layout_set_text(layout, text, len);
	pango_layout_get_pixel_size(layout, &w, &h);
	return w;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x4f461(%rip), %rdi     # 0x532c0
xorl %eax, %eax
movl %eax, %esi
callq 0x2100
movq 0x4f451(%rip), %rdi     # 0x532c0
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x2030
movq 0x4f43c(%rip), %rdi     # 0x532c0
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x2180
cvtsi2ssl 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/silo.cpp
// Function: silo_set_font(char const*)
void silo_set_font(const char* fdsc)
{
	PangoFontDescription* font_desc = pango_font_description_from_string(fdsc);
	pango_layout_set_font_description(layout, nullptr);   // pango will silently not make a copy if 
							      // the new fontdesc matches the old one
							      // whether by pointer or deep compare.
							      // this makes sure the old one is deleted
							      // in favor of a new copy
	pango_layout_set_font_description(layout, font_desc);
	pango_font_map_load_font(font_map, context, font_desc);  // most examples do this, but does not appear
							      // to actually be necessary? There's not much
							      // info out there getting detailed on Pango.

	pango_font_description_free(font_desc); 	      // no longer needed, pango makes a copy
	return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2070
movq %rax, 0x8(%rsp)
movq 0x4f401(%rip), %rdi     # 0x532c0
xorl %eax, %eax
movl %eax, %esi
callq 0x20f0
movq 0x4f3f1(%rip), %rdi     # 0x532c0
movq 0x8(%rsp), %rsi
callq 0x20f0
movq 0x4f3e8(%rip), %rdi     # 0x532c8
movq 0x4f3e9(%rip), %rsi     # 0x532d0
movq 0x8(%rsp), %rdx
callq 0x21d0
movq 0x8(%rsp), %rdi
callq 0x22f0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/silo.cpp
// Function: silo_get_font_height()
int silo_get_font_height()
{
	int w, h;
	pango_layout_set_attributes(layout, nullptr);
	pango_layout_set_text(layout, "Hello", 5);
	pango_layout_get_pixel_size(layout, &w, &h);
	return h;
}

// Assembly:
pushq %rax
movq 0x4f3b8(%rip), %rdi     # 0x532c0
xorl %eax, %eax
movl %eax, %esi
callq 0x2100
movq 0x4f3a8(%rip), %rdi     # 0x532c0
leaq 0x411da(%rip), %rsi     # 0x450f9
movl $0x5, %edx
callq 0x2030
movq 0x4f390(%rip), %rdi     # 0x532c0
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0x2180
movl (%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/silo.cpp
// Function: silo_init()
void silo_init()
{
	font_map = pango_cairo_font_map_get_default(); // pango-owned, don't delete
	context = pango_font_map_create_context(font_map);
	layout = pango_layout_new(context);

	silo_set_font("sans 15");
	return;
}

// Assembly:
pushq %rax
callq 0x2200
movq %rax, 0x4f36b(%rip)     # 0x532c8
movq 0x4f364(%rip), %rdi     # 0x532c8
callq 0x2290
movq %rax, 0x4f360(%rip)     # 0x532d0
movq 0x4f359(%rip), %rdi     # 0x532d0
callq 0x21a0
movq %rax, 0x4f33d(%rip)     # 0x532c0
leaq 0x41175(%rip), %rdi     # 0x450ff
callq 0x3ea0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_str_append_str_utf8
NK_API int
nk_str_append_str_utf8(struct nk_str *str, const char *text)
{
    int runes = 0;
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

    glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
    while (unicode != '\0' && glyph_len) {
        glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
        byte_len += glyph_len;
        num_runes++;
    }
    nk_str_append_text_char(str, text, byte_len);
    return runes;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x92ae
cmpq $0x0, 0x20(%rsp)
jne 0x92bb
movl $0x0, 0x34(%rsp)
jmp 0x9356
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rax
addq %rax, %rdi
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x7840
movl %eax, 0x18(%rsp)
movl %eax, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x92f8
cmpl $0x0, 0x10(%rsp)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x9302
jmp 0x933b
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rax
addq %rax, %rdi
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x7840
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x92df
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x18(%rsp), %edx
callq 0x9070
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_str_insert_str_utf8
NK_API int
nk_str_insert_str_utf8(struct nk_str *str, int pos, const char *text)
{
    int runes = 0;
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

    glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
    while (unicode != '\0' && glyph_len) {
        glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
        byte_len += glyph_len;
        num_runes++;
    }
    nk_str_insert_at_rune(str, pos, text, byte_len);
    return runes;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x9d42
cmpq $0x0, 0x18(%rsp)
jne 0x9d4f
movl $0x0, 0x34(%rsp)
jmp 0x9dee
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x7840
movl %eax, 0x10(%rsp)
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4(%rsp)
movb %al, 0x3(%rsp)
je 0x9d8c
cmpl $0x0, 0x8(%rsp)
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x9d96
jmp 0x9dcf
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rax
addq %rax, %rdi
leaq 0x4(%rsp), %rsi
movl $0x4, %edx
callq 0x7840
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9d73
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x10(%rsp), %ecx
callq 0x97c0
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_input_button
NK_API void
nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, int down)
{
    struct nk_mouse_button *btn;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.buttons[id].down == down) return;

    btn = &in->mouse.buttons[id];
    btn->clicked_pos.x = (float)x;
    btn->clicked_pos.y = (float)y;
    btn->down = down;
    btn->clicked++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xd0c4
jmp 0xd0e3
leaq 0x3b454(%rip), %rdi     # 0x4851f
leaq 0x382e1(%rip), %rsi     # 0x453b3
movl $0x36b5, %edx           # imm = 0x36B5
leaq 0x3939f(%rip), %rcx     # 0x4647d
callq 0x20a0
cmpq $0x0, 0x20(%rsp)
jne 0xd0ed
jmp 0xd168
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl 0x10(%rsp), %eax
jne 0xd115
jmp 0xd168
movq (%rsp), %rax
addq $0x104, %rax            # imm = 0x104
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cvtsi2ssl 0x18(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0x8(%rax)
cvtsi2ssl 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, 0xc(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_input_has_mouse_click_down_in_rect
NK_API int
nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, int down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return nk_input_has_mouse_click_in_rect(i, id, b) && (btn->down == down);
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x44(%rsp)
movlpd %xmm1, 0x4c(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xd4ff
movl $0x0, 0x54(%rsp)
jmp 0xd569
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
shlq $0x4, %rcx
leaq 0x104(%rax,%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movups 0x44(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xd410
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0xd55c
movq 0x28(%rsp), %rax
movl (%rax), %eax
cmpl 0x30(%rsp), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_input_is_mouse_click_down_in_rect
NK_API int
nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, int down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return (nk_input_has_mouse_click_down_in_rect(i, id, b, down) &&
            btn->clicked) ? nk_true : nk_false;
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x44(%rsp)
movlpd %xmm1, 0x4c(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xd65f
movl $0x0, 0x54(%rsp)
jmp 0xd6d3
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
shlq $0x4, %rcx
leaq 0x104(%rax,%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movups 0x44(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movl 0x30(%rsp), %edx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xd4d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0xd6be
movq 0x28(%rsp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)