LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/smaller_index.c
// Function: new_smaller
int		new_smaller(t_list *la, int smaller_a)
{
	int		i;
	t_list	*cursor;
	t_data	*this;
	int		new_smaller;

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33b1
movq 0x8(%r14), %rdi
cmpl $0x2, %eax
jl 0x245d
callq 0x2314
cmpl %ebx, %eax
jle 0x2499
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x24d4
callq 0x33b1
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x24d4
movq 0x8(%r14), %rdi
callq 0x2314
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ebx, %ecx
jg 0x24d4
movq 0x8(%r14), %rdi
callq 0x23a4
movl %eax, %ecx
movl $0x0, %eax
cmpl %ebx, %ecx
jge 0x24d4
movq 0x8(%r14), %rdi
jmp 0x24aa
movq 0x8(%r14), %rdi
callq 0x23a4
movq 0x8(%r14), %rdi
cmpl %ebx, %eax
jge 0x24b6
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23a4
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2456
movq (%rdi), %rcx
movq %rax, %rdi
cmpl %ebx, 0x4(%rcx)
jle 0x24b6
movq (%rdi), %rax
movl 0x4(%rax), %eax
cmpl %ebx, %eax
jge 0x24b6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: chose_index_to_push
int		chose_index_to_push(t_lists *l, int ch1, int ch2)
{
	int		idx_to_push;
	int		ra;
	int		rra;

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

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

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpl %esi, %edi
setle %al
cmpl %edx, %edi
setge %cl
orb %al, %cl
jne 0x2597
movq %rbx, %rdi
popq %rbx
jmp 0x21ac
cmpl %esi, %edi
setg %cl
cmpl %edx, %edi
setg %al
andb %cl, %al
xorb $0x1, %al
cmpl %edx, %esi
setge %cl
orb %al, %cl
jne 0x25b7
movq %rbx, %rdi
popq %rbx
jmp 0x2298
cmpl %edx, %edi
setle %cl
cmpl %esi, %edi
setge %r8b
orb %cl, %r8b
je 0x25d8
cmpl %edx, %esi
setle %cl
orb %al, %cl
jne 0x25e1
movq %rbx, %rdi
callq 0x21ac
movq %rbx, %rdi
popq %rbx
jmp 0x2240
cmpl %edx, %esi
jle 0x25f7
cmpl %esi, %edi
jge 0x25f7
cmpl %edx, %edi
jge 0x25f7
movq %rbx, %rdi
callq 0x21ac
jmp 0x25ae
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_three.c
// Function: sorting_three
void		sorting_three(t_lists *l)
{
	int		first;
	int		second;
	int		third;
	t_data	*this;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x33b1
cmpl $0x1, %eax
jne 0x260c
popq %rbx
retq
movq (%rbx), %rdi
callq 0x33b1
cmpl $0x2, %eax
jne 0x262e
movq %rbx, %rdi
callq 0x22f0
testl %eax, %eax
je 0x260a
movq %rbx, %rdi
popq %rbx
jmp 0x21ac
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %edi
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %esi
movq (%rax), %rax
movl 0x4(%rax), %edx
movq %rbx, %rcx
popq %rbx
jmp 0x257c
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_one
void	check_still_in_b_one(t_lists *l, int first, int second)
{
	if (first == 1)
	{
		write_pa(l);
		write_pa(l);
	}
	else if (first == 2)
	{
		write_pa(l);
		write_sa(l);
		if (second == 1)
		{
			write_pa(l);
			write_sa(l);
		}
		else
			write_pa(l);
	}
}

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jne 0x26f4
movl %edx, %ebp
movq %rdi, %rbx
callq 0x2240
movq %rbx, %rdi
callq 0x2203
cmpl $0x2, %ebp
je 0x2721
cmpl $0x1, %ebp
je 0x26fb
testl %ebp, %ebp
jne 0x26f4
movq %rbx, %rdi
callq 0x2298
movq %rbx, %rdi
callq 0x2298
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2203
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x2298
movq %rbx, %rdi
callq 0x2298
movq %rbx, %rdi
callq 0x2203
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21ac
movq %rbx, %rdi
callq 0x2904
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2298
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_three
void	check_still_in_b_three(t_lists *l, int first, int second)
{
	if (first == 4)
	{
		write_pa(l);
		if (second == 3)
			pa_ra(l);
		else if (second == 2)
		{
			write_rra(l);
			pa_ra(l);
			write_ra(l);
		}
		else if (second == 1)
		{
			write_ra(l);
			write_pa(l);
			write_sa(l);
		}
		else if (second == 0)
		{
			write_ra(l);
			write_pa(l);
		}
	}
}

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

// Assembly:
pushq %rbx
cmpl $0x3, %edi
ja 0x2827
movq %rsi, %rbx
movl %edi, %eax
leaq 0x19b3(%rip), %rcx      # 0x418c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x2203
movq %rbx, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x2203
movq %rbx, %rdi
callq 0x2298
jmp 0x280d
movq %rbx, %rdi
callq 0x2203
movq %rbx, %rdi
popq %rbx
jmp 0x2298
movq %rbx, %rdi
callq 0x2203
movq %rbx, %rdi
popq %rbx
jmp 0x21ac
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: sorting_five
void	sorting_five(t_lists *l)
{
	int		how_many_pb;
	t_data	*first_b;
	t_data	*sec_b;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x33b1
movl %eax, %ebp
movq %rbx, %rdi
callq 0x22f0
testl %eax, %eax
je 0x28e0
cmpl $0x4, %ebp
jl 0x2863
incl %ebp
movq %rbx, %rdi
callq 0x2220
decl %ebp
cmpl $0x4, %ebp
jg 0x2854
movq %rbx, %rdi
callq 0x25f9
movq 0x8(%rbx), %rdi
movq (%rdi), %r14
callq 0x33b1
cmpl $0x2, %eax
jne 0x28eb
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x4(%r14), %ecx
cmpl 0x4(%rax), %ecx
jge 0x2898
movq %rbx, %rdi
callq 0x21c9
movq 0x8(%rbx), %rax
movq (%rax), %r14
movq 0x8(%rax), %rax
movq (%rax), %r15
movl 0x4(%r14), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
callq 0x2654
movl 0x4(%r14), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
callq 0x26ae
movl 0x4(%r14), %esi
movl 0x4(%r15), %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2737
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r14), %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x27c7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: init_chunks_h
void	init_chunks_h(t_chunk_h *ch, t_list *la)
{
	ch->chunk1 = ft_lstsize(la) / 7;
	ch->chunk2 = 2 * (ft_lstsize(la) / 7);
	ch->chunk3 = 3 * (ft_lstsize(la) / 7);
	ch->chunk4 = 4 * (ft_lstsize(la) / 7);
	ch->chunk5 = 5 * (ft_lstsize(la) / 7);
	ch->chunk6 = 6 * (ft_lstsize(la) / 7);
	ch->chunk7 = ft_lstsize(la) - 2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
addl %eax, %eax
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
shrl $0x2, %eax
addl %ecx, %eax
shll $0x2, %eax
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
leal (%rax,%rax,4), %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x33b1
cltq
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x2, %eax
addl %ecx, %eax
addl %eax, %eax
leal (%rax,%rax,2), %eax
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x33b1
addl $-0x2, %eax
movl %eax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: refill_a_sorted
void	refill_a_sorted(t_lists *l)
{
	int		rb_nb;
	int		i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x33b1
testl %eax, %eax
jle 0x2ac4
movl %eax, %r14d
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x23a4
movq %r15, %rdi
movl %eax, %esi
callq 0x31b4
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x33b1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
jle 0x2a9b
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %ebp
jg 0x2aaf
decl %ebp
incl %ebp
movq %rbx, %rdi
callq 0x225d
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %ebp
jl 0x2a82
jmp 0x2aaf
cmpl $0x2, %ebp
jl 0x2aaf
movq %rbx, %rdi
callq 0x22b5
decl %ebp
cmpl $0x1, %ebp
jg 0x2aa0
movq %rbx, %rdi
callq 0x2203
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x2a45
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: bigger_on_top
void	bigger_on_top(t_lists *l)
{
	int		rb;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x23a4
movq %r14, %rdi
movl %eax, %esi
callq 0x31b4
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0x33b1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
jle 0x2b2c
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %ebp
jg 0x2b40
decl %ebp
movq %rbx, %rdi
callq 0x225d
incl %ebp
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %ebp
jl 0x2b13
jmp 0x2b40
cmpl $0x2, %ebp
jl 0x2b40
movq %rbx, %rdi
callq 0x22b5
decl %ebp
cmpl $0x1, %ebp
jg 0x2b31
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: sorting_hundred
void	sorting_hundred(t_lists *l)
{
	t_chunk_h	chunks;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
setle %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x2fb3
movl %ebp, %r12d
movq %rbx, %rdi
callq 0x22d2
leal -0x1(%r12), %ebp
leal -0x1(%r14), %r15d
cmpl $0x2, %r12d
jl 0x2fb6
cmpl $0x1, %r14d
movl %r15d, %r14d
jg 0x2f8e
jmp 0x2fb6
movl %r14d, %r15d
testl %ebp, %ebp
jle 0x2fcb
incl %ebp
movq %rbx, %rdi
callq 0x2298
decl %ebp
cmpl $0x1, %ebp
jg 0x2fbc
testl %r15d, %r15d
jle 0x2fe4
incl %r15d
movq %rbx, %rdi
callq 0x22b5
decl %r15d
cmpl $0x1, %r15d
jg 0x2fd3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: ranbrrbnb_hundred
void	ranbrrbnb_hundred(t_lists *l, int ra_nb, int rb_nb)
{
	int a;
	int b;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x300d
movl %esi, %ebp
incl %ebp
movq %r14, %rdi
callq 0x2298
decl %ebp
cmpl $0x1, %ebp
jg 0x2ffe
movq 0x8(%r14), %rdi
callq 0x33b1
cmpl %ebx, %eax
jle 0x3031
movq %r14, %rdi
callq 0x225d
incl %ebx
movq 0x8(%r14), %rdi
callq 0x33b1
cmpl %eax, %ebx
jl 0x301a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: rranbrbnb_hundred
void	rranbrbnb_hundred(t_lists *l, int rra_nb, int rb_nb)
{
	int a;
	int b;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x3056
movl %esi, %ebp
incl %ebp
movq %r14, %rdi
callq 0x2240
decl %ebp
cmpl $0x1, %ebp
jg 0x3047
testl %ebx, %ebx
jle 0x306b
incl %ebx
movq %r14, %rdi
callq 0x22b5
decl %ebx
cmpl $0x1, %ebx
jg 0x305c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: rranbrrbnb_hundred
void	rranbrrbnb_hundred(t_lists *l, int rra_nb, int rb_nb)
{
	int a;
	int b;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
testl %esi, %esi
jle 0x30b3
leal (%r15,%r14), %ebp
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %r15d
jge 0x30b3
movq %rbx, %rdi
callq 0x227a
leal -0x1(%r14), %eax
incl %r15d
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x3088
xorl %r14d, %r14d
jmp 0x30b6
movl %r15d, %ebp
testl %r14d, %r14d
jle 0x30db
incl %r14d
movq %rbx, %rdi
callq 0x2240
decl %r14d
cmpl $0x1, %r14d
jg 0x30be
jmp 0x30db
movq %rbx, %rdi
callq 0x225d
incl %ebp
movq 0x8(%rbx), %rdi
callq 0x33b1
cmpl %eax, %ebp
jl 0x30d1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: ra_or_rra_hundred
void	ra_or_rra_hundred(t_lists *l, int ra_nb, int rra_nb, int rb_nb)
{
	if (ra_nb < rra_nb)
	{
		if (rb_nb <= ft_lstsize(l->list_b) / 2)
			ranbrbnb_hundred(l, ra_nb, rb_nb);
		else if (rb_nb > ft_lstsize(l->list_b) / 2)
			ranbrrbnb_hundred(l, ra_nb, rb_nb);
	}
	else
	{
		if (rb_nb <= ft_lstsize(l->list_b) / 2)
			rranbrbnb_hundred(l, rra_nb, rb_nb);
		else if (rb_nb > ft_lstsize(l->list_b) / 2)
			rranbrrbnb_hundred(l, rra_nb, rb_nb);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x33b1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ebp, %r15d
jge 0x314c
cmpl %ebx, %ecx
jge 0x317c
movq 0x8(%r14), %rdi
callq 0x33b1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ebx, %ecx
jge 0x31a9
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2fed
cmpl %ebx, %ecx
jge 0x3193
movq 0x8(%r14), %rdi
callq 0x33b1
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ebx, %ecx
jge 0x31a9
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3070
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2f70
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3036
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/how_many_rotate.c
// Function: how_many_rotate
int		how_many_rotate(t_list *la, int index)
{
	t_list	*cursor;
	t_data	*this;
	int		ret;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpl $-0x1, %esi
jne 0x31cd
movq %rbx, %rdi
callq 0x23a4
movl %eax, %esi
xorl %eax, %eax
cmpl %esi, 0x4(%r14)
je 0x31ea
xorl %eax, %eax
incl %eax
movq (%rbx), %rcx
cmpl %esi, 0x4(%rcx)
je 0x31ea
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x31d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/main_ps.c
// Function: which_sort
void	which_sort(int ac, t_lists *l)
{
	if (ac <= 4 && ac > 1)
		sorting_three(l);
	if (ac > 4 && ac <= 6)
		sorting_five(l);
	if (ac > 6 && ac <= 251)
		sorting_hundred(l);
	if (ac > 251)
		sorting_five_hundred(l);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
leal -0x2(%r14), %eax
cmpl $0x2, %eax
ja 0x320f
movq %rbx, %rdi
callq 0x25f9
leal -0x5(%r14), %eax
cmpl $0x1, %eax
ja 0x3220
movq %rbx, %rdi
callq 0x2829
leal -0x7(%r14), %eax
cmpl $0xf4, %eax
ja 0x3233
movq %rbx, %rdi
callq 0x2b45
cmpl $0xfc, %r14d
jl 0x324b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e45
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/WalterLuong[P]push_swap/srcs/push_swap/main_ps.c
// Function: main
int		main(int ac, char **av)
{
	int		i;
	t_lists lists;

	i = 1;
	init_list(&lists);
	if (ac < 2)
		exit_success_ps(&lists);
	else
	{
		while (i < ac)
		{
			if (parsing_ac(av[i]) == -1)
				exit_failure_ps(&lists);
			if (check_existant(av, i) == 1)
				exit_failure_ps(&lists);
			if (is_an_int(av[i]) == -1)
				exit_failure_ps(&lists);
			ft_lstadd_back(&lists.list_a, fill_list_a(av[i]));
			i++;
		}
	}
	get_index(lists.list_a);
	if (check_sort_ps(&lists) != 0)
		which_sort(ac, &lists);
	exit_success_ps(&lists);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq %rsp, %rdi
callq 0x1268
cmpl $0x2, %ebx
jge 0x327c
movq %rsp, %rdi
callq 0x2007
jmp 0x32e8
movl %ebx, %r13d
movl $0x1, %r15d
movq %rsp, %r12
movq (%r14,%r15,8), %rdi
callq 0x12e5
cmpl $-0x1, %eax
jne 0x329e
movq %r12, %rdi
callq 0x1fce
movq %r14, %rdi
movl %r15d, %esi
callq 0x126f
cmpl $0x1, %eax
jne 0x32b6
movq %r12, %rdi
callq 0x1fce
movq (%r14,%r15,8), %rdi
callq 0x1314
cmpl $-0x1, %eax
jne 0x32cc
movq %r12, %rdi
callq 0x1fce
movq (%r14,%r15,8), %rdi
callq 0x132b
movq %r12, %rdi
movq %rax, %rsi
callq 0x3416
incq %r15
cmpq %r15, %r13
jne 0x3288
movq %rsp, %r14
movq (%r14), %rdi
callq 0x1f7f
movq %r14, %rdi
callq 0x22f0
testl %eax, %eax
je 0x3309
movq %rsp, %rsi
movl %ebx, %edi
callq 0x31f4
movq %rsp, %rdi
callq 0x2007
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/contents.c
// Function: randomContents
CONTENTS *randomContents(const size_t size) {
  CONTENTS *result;
  result = calloc(1, sizeof(CONTENTS));
  assert(result);

  result->body = (unsigned char*)malloc(size);
  assert(result->body);
  result->size = size;

  int fd = open("/dev/urandom", O_RDONLY);
  assert(fd >= 0);
  ssize_t ret = read(fd, result->body, result->size);
  assert(ret == result->size);
  close(fd);

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x21a0
testq %rax, %rax
je 0x3789
movq %rax, %rbx
movq %r14, %rdi
callq 0x2440
movq %rax, (%rbx)
testq %rax, %rax
je 0x37a8
movq %rax, %r15
movq %r14, 0x8(%rbx)
leaq 0x4b11(%rip), %rdi      # 0x8264
xorl %esi, %esi
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
js 0x37c7
movl %eax, %ebp
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2310
cmpq %r14, %rax
jne 0x37e6
movl %ebp, %edi
callq 0x2420
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b98(%rip), %rdi      # 0x8328
leaq 0x4b98(%rip), %rsi      # 0x832f
leaq 0x4b9c(%rip), %rcx      # 0x833a
movl $0x46, %edx
callq 0x2190
leaq 0x4bb2(%rip), %rdi      # 0x8361
leaq 0x4b79(%rip), %rsi      # 0x832f
leaq 0x4b7d(%rip), %rcx      # 0x833a
movl $0x49, %edx
callq 0x2190
leaq 0x4aa3(%rip), %rdi      # 0x8271
leaq 0x4b5a(%rip), %rsi      # 0x832f
leaq 0x4b5e(%rip), %rcx      # 0x833a
movl $0x4d, %edx
callq 0x2190
leaq 0x4b81(%rip), %rdi      # 0x836e
leaq 0x4b3b(%rip), %rsi      # 0x832f
leaq 0x4b3f(%rip), %rcx      # 0x833a
movl $0x4f, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/contents.c
// Function: getContents
CONTENTS *getContents(const char *url) {
  CONTENTS *result = NULL;

  FILE *f = fopen(url, "r");
  if (f) {
    result = calloc(1, sizeof(CONTENTS));
    assert(result);

    fseek(f, 0, SEEK_END);
    result->size = ftell(f);
    fseek(f, 0, SEEK_SET);

    result->body = (unsigned char *)malloc(result->size );
    assert(result->body);
    size_t readSize = fread(result->body, 1, result->size, f);
    assert(readSize == result->size);

    fclose(f);
  } else {
    result = getContentsUrl(url);
  }

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x4c51(%rip), %rsi      # 0x8465
callq 0x2290
movq %rax, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x21a0
movq %rax, %rbx
testq %r14, %r14
je 0x38a3
testq %rbx, %rbx
je 0x3955
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
movq %r15, %rdi
callq 0x2440
movq %rax, (%rbx)
testq %rax, %rax
je 0x3974
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2330
cmpq %r15, %rax
jne 0x3993
movq %r14, %rdi
callq 0x2240
jmp 0x394c
testq %rbx, %rbx
je 0x39b2
movl $0x3, %edi
callq 0x20b0
callq 0x22d0
movq %rax, %r14
movq %rax, %rdi
movl $0x2712, %esi           # imm = 0x2712
movq %r15, %rdx
xorl %eax, %eax
callq 0x2280
movl $0x1, %edx
movq %r14, %rdi
movl $0x34, %esi
xorl %eax, %eax
callq 0x2280
leaq 0x1f2(%rip), %rdx       # 0x3add
movq %r14, %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
xorl %eax, %eax
callq 0x2280
movq %r14, %rdi
movl $0x2711, %esi           # imm = 0x2711
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2280
leaq 0x4b3e(%rip), %rdx      # 0x8451
movq %r14, %rdi
movl $0x2722, %esi           # imm = 0x2722
xorl %eax, %eax
callq 0x2280
movq %r14, %rdi
callq 0x22e0
testl %eax, %eax
je 0x393f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x393b
callq 0x2438
xorl %ebx, %ebx
jmp 0x394c
movq %r14, %rdi
callq 0x22c0
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x49cc(%rip), %rdi      # 0x8328
leaq 0x49cc(%rip), %rsi      # 0x832f
leaq 0x4a18(%rip), %rcx      # 0x8382
movl $0x5b, %edx
callq 0x2190
leaq 0x49e6(%rip), %rdi      # 0x8361
leaq 0x49ad(%rip), %rsi      # 0x832f
leaq 0x49f9(%rip), %rcx      # 0x8382
movl $0x62, %edx
callq 0x2190
leaq 0x4a0c(%rip), %rdi      # 0x83a6
leaq 0x498e(%rip), %rsi      # 0x832f
leaq 0x49da(%rip), %rcx      # 0x8382
movl $0x64, %edx
callq 0x2190
leaq 0x496f(%rip), %rdi      # 0x8328
leaq 0x496f(%rip), %rsi      # 0x832f
leaq 0x4a63(%rip), %rcx      # 0x842a
movl $0x25, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/contents.c
// Function: destroyContents
int destroyContents(CONTENTS *file) {
  if (file != NULL) {
    if (file->body != NULL) {
      free(file->body);
    }
  }
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x39e8
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x39e8
pushq %rax
callq 0x2438
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/contents.c
// Function: cloneContents
CONTENTS* cloneContents(CONTENTS *source) {
  assert(source != NULL);

  CONTENTS *result = NULL;
  result = calloc(1, sizeof(CONTENTS));
  assert(result);
  result->body = (unsigned char*) malloc(source->size);
  memcpy(result->body, source->body, source->size);
  result->size = source->size;

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3a39
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x21a0
testq %rax, %rax
je 0x3a58
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2440
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x21e0
movq %r15, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x497f(%rip), %rdi      # 0x83bf
leaq 0x48e8(%rip), %rsi      # 0x832f
leaq 0x4980(%rip), %rcx      # 0x83ce
movl $0x79, %edx
callq 0x2190
leaq 0x48c9(%rip), %rdi      # 0x8328
leaq 0x48c9(%rip), %rsi      # 0x832f
leaq 0x4961(%rip), %rcx      # 0x83ce
movl $0x7d, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/contents.c
// Function: WriteMemoryCallback
static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb,
                                  void *userp) {
  size_t realsize = size * nmemb;
  CONTENTS *mem = (CONTENTS *)userp;

  unsigned char *ptr =
      (unsigned char *)realloc(mem->body, mem->size + realsize + 1);
  assert(ptr);

  mem->body = ptr;
  memcpy(&(mem->body[mem->size]), contents, realsize);
  mem->size += realsize;
  mem->body[mem->size] = 0;

  return realsize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r15
imulq %rdx, %rbx
movq (%rcx), %rdi
movq 0x8(%rcx), %rax
leaq (%rbx,%rax), %rsi
incq %rsi
callq 0x2448
testq %rax, %rax
je 0x3b3f
movq %rax, %r12
movq %rax, (%r14)
movq 0x8(%r14), %r13
movq %rax, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21e0
addq %rbx, %r13
movq %r13, 0x8(%r14)
movb $0x0, (%r12,%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x491d(%rip), %rdi      # 0x8463
leaq 0x47e2(%rip), %rsi      # 0x832f
leaq 0x4913(%rip), %rcx      # 0x8467
movl $0x16, %edx
callq 0x2190
nop
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/misc.c
// Function: timevalAdd
void timevalAdd(struct timeval *result, const struct timeval *x,
                const struct timeval *y) {
    result->tv_sec = x->tv_sec + y->tv_sec;
    result->tv_usec += x->tv_usec + y->tv_sec;
    if (result->tv_usec > 1000000) {
      result->tv_usec -= 1000000;
      result->tv_sec++;
    }
}

// Assembly:
movq (%rdx), %rax
addq (%rsi), %rax
movq %rax, (%rdi)
movq (%rdx), %rcx
addq 0x8(%rsi), %rcx
addq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdi)
cmpq $0xf4241, %rcx          # imm = 0xF4241
jl 0x3b9e
addq $-0xf4240, %rcx         # imm = 0xFFF0BDC0
movq %rcx, 0x8(%rdi)
incq %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/misc.c
// Function: timevalSubtract
int timevalSubtract(struct timeval *result, const struct timeval *x,
                            const struct timeval *ya) {
  struct timeval yb;
  memcpy(&yb, ya, sizeof(yb));
  struct timeval *y = &yb;

  /* Perform the carry for the later subtraction by updating y. */
  if (x->tv_usec < y->tv_usec) {
    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
    y->tv_usec -= 1000000 * nsec;
    y->tv_sec += nsec;
  }
  if (x->tv_usec - y->tv_usec > 1000000) {
    int nsec = (x->tv_usec - y->tv_usec) / 1000000;
    y->tv_usec += 1000000 * nsec;
    y->tv_sec -= nsec;
  }

  /* Compute the time remaining to wait.
     tv_usec is certainly positive. */
  result->tv_sec = x->tv_sec - y->tv_sec;
  result->tv_usec = x->tv_usec - y->tv_usec;

  /* Return 1 if result is negative. */
  return x->tv_sec < y->tv_sec;
}

// Assembly:
movq (%rdx), %rcx
movq 0x8(%rdx), %r9
movq 0x8(%rsi), %r8
movq %r9, %rax
movabsq $0x431bde82d7b634db, %r10 # imm = 0x431BDE82D7B634DB
subq %r8, %rax
jle 0x3c12
imulq %r10
movq %rdx, %rax
shrq $0x12, %rax
shrq $0x3f, %rdx
addl %edx, %eax
incl %eax
imull $0xf4240, %eax, %edx    # imm = 0xF4240
movslq %edx, %rdx
subq %rdx, %r9
cltq
addq %rax, %rcx
movq %r8, %rax
subq %r9, %rax
cmpq $0xf4241, %rax          # imm = 0xF4241
jl 0x3c42
mulq %r10
shrq $0x12, %rdx
movabsq $0xf424000000000, %rax  # imm = 0xF424000000000
imulq %rdx, %rax
sarq $0x20, %rax
addq %rax, %r9
movslq %edx, %rax
subq %rax, %rcx
movq (%rsi), %rax
subq %rcx, %rax
movq %rax, (%rdi)
subq %r9, %r8
movq %r8, 0x8(%rdi)
xorl %eax, %eax
cmpq %rcx, (%rsi)
setl %al
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/misc.c
// Function: timevalBeforeTimeout
int timevalBeforeTimeout(const struct timeval *timeout,
                          const struct timeval *x, const struct timeval *y) {
  struct timeval r;

  timevalSubtract(&r, x, y);

  if (r.tv_sec < timeout->tv_sec) {
    return 1;
  } else if (r.tv_usec < timeout->tv_usec) {
    return 1;
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3bd2
movq (%r14), %rcx
movl $0x1, %eax
cmpq (%rbx), %rcx
jl 0x3c8d
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x8(%rbx), %rcx
setl %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/misc.c
// Function: timevalBefore
int timevalBefore(const struct timeval *x, const struct timeval *y) {
  struct timeval e;

  e.tv_sec = 0;
  e.tv_usec = 0;

  return timevalBeforeTimeout(&e, x, y);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3bd2
movq 0x8(%rbx), %rcx
shrq $0x3f, %rcx
cmpq $0x0, (%rbx)
movl $0x1, %eax
cmovnsl %ecx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/misc.c
// Function: parseHumanSize
uintmax_t parseHumanSize (const char* s) {
  char *endp = (char *)s;
  int sh;
  errno = 0;

  uintmax_t x = strtoumax(s, &endp, 10);
  if (errno || endp == s) {
    errno = EINVAL;
    goto ERROR;
  }

  switch (*endp) {
  case 'k':
  case 'K':
    sh = 10;
    break;
  case 'M':
  case 'm':
    sh = 20;
    break;
  case 'g':
  case 'G':
    sh = 30;
    break;
  case 0:
    sh = 0;
    break;
  default:
    goto ERROR;
  }
  if (sh && endp[1]) {
    errno = EINVAL;
    goto ERROR;
  }

  if (x > SIZE_MAX>>sh) {
    errno = ERANGE;
    goto ERROR;
  }

  x <<= sh; 

  return x;
ERROR:
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
callq 0x2040
movq %rax, %rbx
movl $0x0, (%rax)
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2220
cmpl $0x0, (%rbx)
je 0x3d11
movl $0x16, (%rbx)
xorl %edx, %edx
movq %rdx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
cmpq %r14, %rsi
je 0x3cfc
movzbl (%rsi), %ecx
xorl %edx, %edx
leal -0x47(%rcx), %edi
cmpl $0x26, %edi
ja 0x3d66
movabsq $0x100000001, %r8       # imm = 0x100000001
btq %rdi, %r8
jb 0x3d70
movabsq $0x1000000010, %r8      # imm = 0x1000000010
btq %rdi, %r8
jb 0x3d5f
movabsq $0x4000000040, %r8      # imm = 0x4000000040
btq %rdi, %r8
jae 0x3d66
movl $0x14, %ecx
jmp 0x3d75
movl $0xa, %ecx
jmp 0x3d77
testl %ecx, %ecx
jne 0x3d04
movb $0x1, %dl
xorl %ecx, %ecx
jmp 0x3d77
movl $0x1e, %ecx
xorl %edx, %edx
testb %dl, %dl
jne 0x3d85
cmpb $0x0, 0x1(%rsi)
jne 0x3cfc
movq $-0x1, %rdx
shrq %cl, %rdx
cmpq %rdx, %rax
jbe 0x3d9f
movl $0x22, (%rbx)
jmp 0x3d02
shlq %cl, %rax
movq %rax, %rdx
jmp 0x3d04
nop
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: testAddRun
void testAddRun(TEST *t, CONTENTS* (*run)(const CONTENTS*)) {
  t->run = realloc(t->run, sizeof(run) * (t->runCount + 1));
  assert(t->run);

  t->run[t->runCount] = run;
  t->runCount ++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x20(%rbx), %esi
incl %esi
shlq $0x3, %rsi
callq 0x2448
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3e2f
movl 0x20(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x46d6(%rip), %rdi      # 0x850c
leaq 0x46b3(%rip), %rsi      # 0x84f0
leaq 0x46cf(%rip), %rcx      # 0x8513
movl $0x1f, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultDestory
void resultDestory(RESULT *result) {
  RESULT *fre;

  for (RESULT *re = result; re; ) {
    loopDestory(re->loops);

    fre = re;
    re = re->next;
    free(fre);
  }
  return;
}

// Assembly:
testq %rdi, %rdi
je 0x3eb4
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %r14
testq %r14, %r14
je 0x3e9b
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3e87
movq 0x28(%rdi), %r15
callq 0x2438
movq %r15, %rdi
testq %r15, %r15
jne 0x3e76
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x2438
movq %r15, %r14
testq %r15, %r15
jne 0x3e6e
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x2438
movq %r14, %rbx
testq %r14, %r14
jne 0x3e66
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: testRun
RESULT *testRun(TEST *t) {
  assert(t->run);
  assert(t->threads);

  pthread_t *pids = malloc(sizeof(pthread_t) * t->threads);
  assert(pids);

  for (unsigned int i = 0; i < t->threads; i ++) {
    pthread_create(pids+i, NULL, loopThread, t);
  }

  RESULT *headResult, *result, *newResult;
  headResult = result = NULL;

  for (unsigned int i = 0; i < t->threads; i ++) {
    LOOP* loops = NULL;
    pthread_join(pids[i], (void *)&loops);

    newResult = (RESULT *)calloc(1, sizeof(RESULT));
    assert(newResult);
    if (!headResult) headResult = newResult;
    if (result) result->next = newResult;
    result = newResult;

    result->loops = loops;
  }

  return headResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x3fb5
movq %rdi, %rbx
movl 0x10(%rdi), %edi
testq %rdi, %rdi
je 0x3fd4
shlq $0x3, %rdi
callq 0x2440
testq %rax, %rax
je 0x3ff3
movq %rax, %r14
cmpl $0x0, 0x10(%rbx)
je 0x3f21
xorl %r13d, %r13d
leaq 0x113(%rip), %r15       # 0x4012
movq %r14, %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x23e0
incq %r13
movl 0x10(%rbx), %eax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x3f02
cmpl $0x0, 0x10(%rbx)
je 0x3f81
xorl %r13d, %r13d
movq %rsp, %r12
xorl %ebp, %ebp
xorl %r15d, %r15d
movq $0x0, (%rsp)
movq (%r14,%r13,8), %rdi
movq %r12, %rsi
callq 0x2200
movl $0x1, %edi
movl $0x10, %esi
callq 0x21a0
testq %rax, %rax
je 0x3f96
testq %r15, %r15
cmoveq %rax, %r15
testq %rbp, %rbp
je 0x3f6a
movq %rax, 0x8(%rbp)
movq (%rsp), %rcx
movq %rcx, (%rax)
incq %r13
movl 0x10(%rbx), %ecx
movq %rax, %rbp
cmpq %rcx, %r13
jb 0x3f32
jmp 0x3f84
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45d7(%rip), %rdi      # 0x8574
leaq 0x454c(%rip), %rsi      # 0x84f0
leaq 0x45a1(%rip), %rcx      # 0x854c
movl $0x259, %edx            # imm = 0x259
callq 0x2190
leaq 0x4550(%rip), %rdi      # 0x850c
leaq 0x452d(%rip), %rsi      # 0x84f0
leaq 0x4582(%rip), %rcx      # 0x854c
movl $0x247, %edx            # imm = 0x247
callq 0x2190
leaq 0x4589(%rip), %rdi      # 0x8564
leaq 0x450e(%rip), %rsi      # 0x84f0
leaq 0x4563(%rip), %rcx      # 0x854c
movl $0x248, %edx            # imm = 0x248
callq 0x2190
leaq 0x4575(%rip), %rdi      # 0x856f
leaq 0x44ef(%rip), %rsi      # 0x84f0
leaq 0x4544(%rip), %rcx      # 0x854c
movl $0x24b, %edx            # imm = 0x24B
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultAvgIntervalByRun
static double resultAvgIntervalByRun(const RESULT* results, const unsigned int run) {
  struct timeval t;
  unsigned long total = 0;
  unsigned long loops = 0;
  unsigned int id = 0;

  for (const RESULT* r = results; r; r = r->next) {
    total += loopTotalTime(r->loops, run, &t);
    loops += resultThreadLoops(results, id);
  }

  return (double)total / (double)loops;
}

// Assembly:
testq %rdi, %rdi
je 0x4ce0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq %rdi, %rbp
xorl %r12d, %r12d
movq (%rbp), %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x4eb1
addq %rax, %r13
movq %r14, %rdi
xorl %esi, %esi
callq 0x4f3c
addq %rax, %r12
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x4c64
movq %r13, %xmm1
movq 0x3818(%rip), %xmm2     # 0x84b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x381c(%rip), %xmm3     # 0x84c0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r12, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x37f8(%rip), %xmm0     # 0x84e0
retq