LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2204
movq %r14, %rdi
movl %eax, %esi
callq 0x2d28
movl %eax, %r14d
leal -0x1(%r14), %ebp
movq 0x8(%rbx), %rdi
callq 0x2f03
pushq $0x2
popq %rcx
cltd
idivl %ecx
cmpl %eax, %r14d
jg 0x2870
testl %ebp, %ebp
jle 0x287d
movq %rbx, %rdi
callq 0x2145
decl %ebp
jmp 0x2856
movq %rbx, %rdi
callq 0x20f9
incl %ebp
movq 0x8(%rbx), %rdi
callq 0x2f03
cmpl %eax, %ebp
jl 0x2866
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2710
movl (%r14), %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x4(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x8(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0xc(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x10(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x14(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x18(%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1f99
movq %rbx, %rdi
callq 0x281e
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2791
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five_hundred.c
// Function: init_chunks_fh
void	init_chunks_fh(t_chunk_fh *ch, t_list *la)
{
	ch->chunk1 = ft_lstsize(la) / 15;
	ch->chunk2 = 2 * (ft_lstsize(la) / 15);
	ch->chunk3 = 3 * (ft_lstsize(la) / 15);
	ch->chunk4 = 4 * (ft_lstsize(la) / 15);
	ch->chunk5 = 5 * (ft_lstsize(la) / 15);
	ch->chunk6 = 6 * (ft_lstsize(la) / 15);
	ch->chunk7 = 7 * (ft_lstsize(la) / 15);
	ch->chunk8 = 8 * (ft_lstsize(la) / 15);
	ch->chunk9 = 9 * (ft_lstsize(la) / 15);
	ch->chunk10 = 10 * (ft_lstsize(la) / 15);
	ch->chunk11 = 11 * (ft_lstsize(la) / 15);
	ch->chunk12 = 12 * (ft_lstsize(la) / 15);
	ch->chunk13 = 13 * (ft_lstsize(la) / 15);
	ch->chunk14 = 14 * (ft_lstsize(la) / 15);
	ch->chunk15 = ft_lstsize(la) - 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f03
pushq $0xf
popq %rbp
cltd
idivl %ebp
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
addl %eax, %eax
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
leal (%rax,%rax,2), %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
shll $0x2, %eax
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
leal (%rax,%rax,4), %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0x6, %eax, %eax
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0x7, %eax, %eax
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
shll $0x3, %eax
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
leal (%rax,%rax,8), %eax
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0xa, %eax, %eax
movl %eax, 0x24(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0xb, %eax, %eax
movl %eax, 0x28(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0xc, %eax, %eax
movl %eax, 0x2c(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0xd, %eax, %eax
movl %eax, 0x30(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0xe, %eax, %eax
movl %eax, 0x34(%rbx)
movq %r14, %rdi
callq 0x2f03
addl $-0x2, %eax
movl %eax, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x292c
movl (%r14), %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x4(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x8(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0xc(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x10(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x14(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x18(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x1c(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x20(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x24(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x28(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x2c(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x30(%r14), %ebp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1f99
movl 0x34(%r14), %r15d
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x1f99
movl 0x38(%r14), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1f99
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2791
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %ebp, %ebp
jle 0x2b8b
testl %ebx, %ebx
jle 0x2b8b
movq %r14, %rdi
callq 0x215e
decl %ebp
decl %ebx
jmp 0x2b6b
movq %r14, %rdi
callq 0x212c
decl %ebp
testl %ebp, %ebp
jg 0x2b81
jmp 0x2b9b
movq %r14, %rdi
callq 0x2145
decl %ebx
testl %ebx, %ebx
jg 0x2b91
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %r14
testl %ebp, %ebp
jle 0x2bc9
movq %r14, %rdi
callq 0x212c
decl %ebp
jmp 0x2baf
movq %r14, %rdi
callq 0x20f9
incl %ebx
movq 0x8(%r14), %rdi
callq 0x2f03
cmpl %eax, %ebx
jl 0x2bbf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %esi, %ebp
movq %rdi, %r14
testl %ebp, %ebp
jle 0x2c00
movq %r14, %rdi
callq 0x20e0
decl %ebp
jmp 0x2be6
movq %r14, %rdi
callq 0x2145
decl %ebx
testl %ebx, %ebx
jg 0x2bf6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_utils.c
// Function: rranbrrbnb_hundred
void	rranbrrbnb_hundred(t_lists *l, int rra_nb, int rb_nb)
{
	int a;
	int b;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
sarl $0x1f, %r15d
andl %esi, %r15d
testl %ebp, %ebp
jle 0x2c50
movq 0x8(%r14), %rdi
callq 0x2f03
cmpl %eax, %ebx
jge 0x2c40
movq %r14, %rdi
callq 0x2112
decl %ebp
incl %ebx
jmp 0x2c21
movl %ebp, %r15d
jmp 0x2c50
movq %r14, %rdi
callq 0x20e0
decl %r15d
testl %r15d, %r15d
jg 0x2c45
jmp 0x2c61
movq %r14, %rdi
callq 0x20f9
incl %ebx
movq 0x8(%r14), %rdi
callq 0x2f03
cmpl %eax, %ebx
jl 0x2c57
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x2f03
pushq $0x2
popq %r12
cltd
idivl %r12d
cmpl %ebp, %r15d
jge 0x2ccb
cmpl %ebx, %eax
jge 0x2cf4
movq 0x8(%r14), %rdi
callq 0x2f03
cltd
idivl %r12d
cmpl %ebx, %eax
jge 0x2d1d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ba4
cmpl %ebx, %eax
jge 0x2d09
movq 0x8(%r14), %rdi
callq 0x2f03
cltd
idivl %r12d
cmpl %ebx, %eax
jge 0x2d1d
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2c09
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2b60
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2bdb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2d41
movq %rbx, %rdi
callq 0x2204
movl %eax, %esi
xorl %eax, %eax
cmpl %esi, 0x4(%r14)
je 0x2d59
testq %rbx, %rbx
je 0x2d59
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
incl %eax
jmp 0x2d43
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x2(%rdi), %eax
cmpl $0x2, %eax
ja 0x2d74
movq %rsi, %rdi
jmp 0x23f5
leal -0x5(%rdi), %eax
cmpl $0x1, %eax
ja 0x2d84
movq %rsi, %rdi
jmp 0x2625
leal -0x7(%rdi), %eax
cmpl $0xf4, %eax
ja 0x2d96
movq %rsi, %rdi
jmp 0x2882
cmpl $0xfc, %edi
jl 0x2da6
movq %rsi, %rdi
jmp 0x2a35
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1250
cmpl $0x2, %ebx
jge 0x2e07
movq %rsp, %rdi
callq 0x1f19
movq %rsp, %r14
movq (%r14), %rdi
callq 0x1e9b
movq %r14, %rdi
callq 0x2178
testl %eax, %eax
je 0x2def
movq %rsp, %rsi
movl %ebx, %edi
callq 0x2d64
movq %rsp, %rdi
callq 0x1f19
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %ebx, %r13d
pushq $0x1
popq %r15
movq %rsp, %r12
cmpq %r15, %r13
je 0x2dce
movq (%r14,%r15,8), %rdi
callq 0x12d0
cmpl $-0x1, %eax
jne 0x2e2c
movq %r12, %rdi
callq 0x1ee2
movq %r14, %rdi
movl %r15d, %esi
callq 0x1257
cmpl $0x1, %eax
jne 0x2e44
movq %r12, %rdi
callq 0x1ee2
movq (%r14,%r15,8), %rdi
callq 0x1300
cmpl $-0x1, %eax
jne 0x2e5a
movq %r12, %rdi
callq 0x1ee2
movq (%r14,%r15,8), %rdi
callq 0x1317
movq %r12, %rdi
movq %rax, %rsi
callq 0x2f68
incq %r15
jmp 0x2e11
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x21a0
testq %rax, %rax
je 0x366d
movq %rax, %rbx
movq %r14, %rdi
callq 0x2430
movq %rax, (%rbx)
testq %rax, %rax
je 0x3686
movq %rax, %r15
movq %r14, 0x8(%rbx)
leaq 0x3c2d(%rip), %rdi      # 0x7264
xorl %esi, %esi
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
js 0x369f
movl %eax, %ebp
movl %eax, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2300
cmpq %r14, %rax
jne 0x36b8
movl %ebp, %edi
callq 0x2410
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cb4(%rip), %rdi      # 0x7328
leaq 0x3cb4(%rip), %rsi      # 0x732f
leaq 0x3cb8(%rip), %rcx      # 0x733a
pushq $0x46
jmp 0x36cf
leaq 0x3cd4(%rip), %rdi      # 0x7361
leaq 0x3c9b(%rip), %rsi      # 0x732f
leaq 0x3c9f(%rip), %rcx      # 0x733a
pushq $0x49
jmp 0x36cf
leaq 0x3bcb(%rip), %rdi      # 0x7271
leaq 0x3c82(%rip), %rsi      # 0x732f
leaq 0x3c86(%rip), %rcx      # 0x733a
pushq $0x4d
jmp 0x36cf
leaq 0x3caf(%rip), %rdi      # 0x736e
leaq 0x3c69(%rip), %rsi      # 0x732f
leaq 0x3c6d(%rip), %rcx      # 0x733a
pushq $0x4f
popq %rdx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/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 0x3d81(%rip), %rsi      # 0x7465
callq 0x2280
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x21a0
movq %rax, %rbx
testq %r14, %r14
je 0x376b
testq %rbx, %rbx
je 0x3812
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2260
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2260
movq %r15, %rdi
callq 0x2430
movq %rax, (%rbx)
testq %rax, %rax
je 0x382b
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2320
cmpq %r15, %rax
jne 0x3844
movq %r14, %rdi
callq 0x2230
jmp 0x3809
testq %rbx, %rbx
je 0x385d
pushq $0x3
popq %rdi
callq 0x20b0
callq 0x22c0
movq %rax, %r14
movq %rax, %rdi
movl $0x2712, %esi           # imm = 0x2712
movq %r15, %rdx
xorl %eax, %eax
callq 0x2270
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2270
leaq 0x1c6(%rip), %rdx       # 0x3973
movq %r14, %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
xorl %eax, %eax
callq 0x2270
movq %r14, %rdi
movl $0x2711, %esi           # imm = 0x2711
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x3c7c(%rip), %rdx      # 0x7451
movq %r14, %rdi
movl $0x2722, %esi           # imm = 0x2722
xorl %eax, %eax
callq 0x2270
movq %r14, %rdi
callq 0x22d0
testl %eax, %eax
je 0x37fc
movq %rbx, %rdi
callq 0x387a
xorl %ebx, %ebx
jmp 0x3809
movq %r14, %rdi
callq 0x22b0
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3b0f(%rip), %rdi      # 0x7328
leaq 0x3b0f(%rip), %rsi      # 0x732f
leaq 0x3b5b(%rip), %rcx      # 0x7382
pushq $0x5b
jmp 0x3874
leaq 0x3b2f(%rip), %rdi      # 0x7361
leaq 0x3af6(%rip), %rsi      # 0x732f
leaq 0x3b42(%rip), %rcx      # 0x7382
pushq $0x62
jmp 0x3874
leaq 0x3b5b(%rip), %rdi      # 0x73a6
leaq 0x3add(%rip), %rsi      # 0x732f
leaq 0x3b29(%rip), %rcx      # 0x7382
pushq $0x64
jmp 0x3874
leaq 0x3ac4(%rip), %rdi      # 0x7328
leaq 0x3ac4(%rip), %rsi      # 0x732f
leaq 0x3bb8(%rip), %rcx      # 0x742a
pushq $0x25
popq %rdx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/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 0x388c
pushq %rax
movq (%rdi), %rdi
callq 0x2428
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x38d9
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x21a0
testq %rax, %rax
je 0x38f2
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x2430
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x21d0
movq %r15, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3adf(%rip), %rdi      # 0x73bf
leaq 0x3a48(%rip), %rsi      # 0x732f
leaq 0x3ae0(%rip), %rcx      # 0x73ce
pushq $0x79
jmp 0x3909
leaq 0x3a2f(%rip), %rdi      # 0x7328
leaq 0x3a2f(%rip), %rsi      # 0x732f
leaq 0x3ac7(%rip), %rcx      # 0x73ce
pushq $0x7d
popq %rdx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/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 0x2438
testq %rax, %rax
je 0x39d5
movq %rax, %r12
movq %rax, (%r14)
movq 0x8(%r14), %r13
movq %rax, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21d0
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 0x3a87(%rip), %rdi      # 0x7463
leaq 0x394c(%rip), %rsi      # 0x732f
leaq 0x3a7d(%rip), %rcx      # 0x7467
pushq $0x16
popq %rdx
callq 0x2190
nop
// File: /workspace/github_c_makefile_star2_O2/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
subq %r8, %rax
jle 0x3a6c
movl $0xf4240, %r10d         # imm = 0xF4240
cqto
idivq %r10
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 0x3aa5
movl $0xf4240, %r10d         # imm = 0xF4240
xorl %edx, %edx
divq %r10
movabsq $0xf424000000000, %rdx  # imm = 0xF424000000000
imulq %rax, %rdx
sarq $0x20, %rdx
addq %r9, %rdx
cltq
subq %rax, %rcx
subq %rdx, %r8
movq %r8, %rax
movq (%rsi), %rdx
subq %rcx, %rdx
movq %rdx, (%rdi)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
cmpq %rcx, (%rsi)
setl %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a3b
movq (%r14), %rax
cmpq (%rbx), %rax
jge 0x3adf
pushq $0x1
popq %rax
jmp 0x3aed
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_O2/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
andl $0x0, (%rax)
pushq $0xa
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
cmpl $0x0, (%rbx)
je 0x3b56
movl $0x16, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x3b44
movzbl (%rdx), %ecx
leal -0x47(%rcx), %esi
cmpl $0x26, %esi
ja 0x3ba3
movabsq $0x100000001, %rdi      # imm = 0x100000001
btq %rsi, %rdi
jb 0x3ba9
movabsq $0x1000000010, %rdi     # imm = 0x1000000010
btq %rsi, %rdi
jb 0x3b9f
movabsq $0x4000000040, %rdi     # imm = 0x4000000040
btq %rsi, %rdi
jae 0x3ba3
pushq $0x14
jmp 0x3bab
pushq $0xa
jmp 0x3bab
testl %ecx, %ecx
jne 0x3b4a
jmp 0x3bb2
pushq $0x1e
popq %rcx
cmpb $0x0, 0x1(%rdx)
jne 0x3b44
pushq $-0x1
popq %rdx
shrq %cl, %rdx
cmpq %rdx, %rax
jbe 0x3bc5
movl $0x22, (%rbx)
jmp 0x3b4a
shlq %cl, %rax
jmp 0x3b4c
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2438
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x3c41
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 0x38bc(%rip), %rdi      # 0x7504
leaq 0x3899(%rip), %rsi      # 0x74e8
leaq 0x38b5(%rip), %rcx      # 0x750b
pushq $0x1f
popq %rdx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x3cb6
movq (%rbx), %r14
testq %r14, %r14
je 0x3ca5
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3c94
movq 0x28(%rdi), %r15
callq 0x2428
movq %r15, %rdi
jmp 0x3c81
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x2428
movq %r15, %r14
jmp 0x3c79
movq 0x8(%rbx), %r14
movq %rbx, %rdi
callq 0x2428
movq %r14, %rbx
jmp 0x3c71
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3db1
movq %rdi, %rbx
movl 0x10(%rdi), %r13d
testq %r13, %r13
je 0x3dd0
leaq (,%r13,8), %rdi
callq 0x2430
testq %rax, %rax
je 0x3def
movq %rax, %r14
xorl %ebp, %ebp
leaq 0x10a(%rip), %r15       # 0x3e0e
movq %rax, %r12
movl %r13d, %eax
cmpq %rax, %rbp
jae 0x3d2c
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x23d0
incq %rbp
movl 0x10(%rbx), %r13d
addq $0x8, %r12
jmp 0x3d07
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r15d, %r15d
movl %r13d, %eax
cmpq %rax, %r12
jae 0x3d80
andq $0x0, (%rsp)
movq (%r14,%r12,8), %rdi
movq %rsp, %rsi
callq 0x21f0
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x21a0
testq %rax, %rax
je 0x3d92
testq %rbp, %rbp
cmoveq %rax, %rbp
testq %r15, %r15
je 0x3d6d
movq %rax, 0x8(%r15)
movq (%rsp), %rcx
movq %rcx, (%rax)
incq %r12
movl 0x10(%rbx), %r13d
movq %rax, %r15
jmp 0x3d34
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x37d3(%rip), %rdi      # 0x756c
leaq 0x3748(%rip), %rsi      # 0x74e8
leaq 0x379d(%rip), %rcx      # 0x7544
movl $0x259, %edx            # imm = 0x259
callq 0x2190
leaq 0x374c(%rip), %rdi      # 0x7504
leaq 0x3729(%rip), %rsi      # 0x74e8
leaq 0x377e(%rip), %rcx      # 0x7544
movl $0x247, %edx            # imm = 0x247
callq 0x2190
leaq 0x3785(%rip), %rdi      # 0x755c
leaq 0x370a(%rip), %rsi      # 0x74e8
leaq 0x375f(%rip), %rcx      # 0x7544
movl $0x248, %edx            # imm = 0x248
callq 0x2190
leaq 0x3771(%rip), %rdi      # 0x7567
leaq 0x36eb(%rip), %rsi      # 0x74e8
leaq 0x3740(%rip), %rcx      # 0x7544
movl $0x24b, %edx            # imm = 0x24B
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultThreads
static unsigned int resultThreads(const RESULT* result) {
  unsigned int count = 0;
  for (const RESULT *re = result; re; re = re->next) {
    count ++;
  }
  return count;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x4897
incl %eax
movq 0x8(%rdi), %rdi
jmp 0x488a
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultTotalLoops
static unsigned long resultTotalLoops(const RESULT* result) {
  unsigned long total = 0;
  for (const RESULT *re = result; re; re = re->next) {
    total += getLoops(re->loops);
  }
  return total;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x48b7
movq (%r14), %rdi
callq 0x4ae9
addq %rax, %rbx
movq 0x8(%r14), %r14
jmp 0x48a1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movq %rdi, %rbp
testq %rbp, %rbp
je 0x4935
movq (%rbp), %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x4afa
addq %rax, %r13
movq %r14, %rdi
xorl %esi, %esi
callq 0x4bbf
addq %rax, %r12
movq 0x8(%rbp), %rbp
jmp 0x490c
movq %r13, %xmm1
movq 0x2b6e(%rip), %xmm2     # 0x74b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2b72(%rip), %xmm3     # 0x74c0
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
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultStdevIntervalByRun
static double resultStdevIntervalByRun(const RESULT* results, unsigned int run) {
  unsigned long avg = resultAvgIntervalByRun(results, run);
  unsigned long sumPow = 0;
  unsigned long loops = 0;
  unsigned int id = 0;

  for (const RESULT* r = results; r; r = r->next) {
    sumPow += loopSumPow(r->loops, run, avg);
    loops += resultThreadLoops(results, id);
    id++;
  }

  return sqrt((double)sumPow/(double)loops);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r12
callq 0x48eb
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2b2a(%rip), %xmm0     # 0x74e0
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
xorl %eax, %eax
xorl %ebp, %ebp
movq %r12, 0x8(%rsp)
testq %r12, %r12
je 0x4a50
movl %ebp, 0x4(%rsp)
movq %r14, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq (%r12), %rbp
xorl %r14d, %r14d
testq %rbp, %rbp
je 0x4a21
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq (%rbp), %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x4b54
movq %r15, %rdi
callq 0x39f4
subq %r13, %rax
imulq %rax, %rax
addq %rax, %r14
movq 0x10(%rbp), %rbp
jmp 0x49ec
movq 0x10(%rsp), %rax
addq %r14, %rax
movq %rax, %r14
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %ebp
movl %ebp, %esi
callq 0x4bbf
movq 0x18(%rsp), %rcx
addq %rax, %rcx
movq %rcx, %rax
incl %ebp
movq 0x8(%r12), %r12
jmp 0x49d2
movq %r14, %xmm0
movq 0x2a53(%rip), %xmm1     # 0x74b0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2a57(%rip), %xmm2     # 0x74c0
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rax, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
sqrtsd %xmm3, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runOutputSample
static size_t *runOutputSample(const RUN* runs) {
  size_t *samples = NULL;
  unsigned int count = 0;

  for (const RUN* r = runs; r; r = r->next) {
    samples = (size_t*)realloc(samples, sizeof(size_t) * (count + 1));
    samples[count] = r->outputBytes;
    count ++;
  }

  return samples;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x4ae3
leal 0x1(%r14), %r15d
leaq (,%r15,8), %rsi
movq %rax, %rdi
callq 0x2438
movq 0x20(%rbx), %rcx
movl %r14d, %edx
movq %rcx, (%rax,%rdx,8)
movq 0x28(%rbx), %rbx
movl %r15d, %r14d
jmp 0x4ab6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: getLoops
static unsigned long getLoops(const LOOP* loop) {
  unsigned long count = 0;
  for (const LOOP *l = loop; l; l = l->next) {
    count ++;
  }
  return count;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x4af9
incq %rax
movq 0x10(%rdi), %rdi
jmp 0x4aeb
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopTotalTime
static unsigned long loopTotalTime(const LOOP* loops, const unsigned int run, 
                          struct timeval *totalTime) {
  assert(totalTime);
  totalTime->tv_sec = 0;
  totalTime->tv_usec = 0;

  for (const LOOP* l = loops; l; l = l->next) {
    runTotalTime(l->runs, run, totalTime);
  }

  return timevalToUsec(totalTime);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x4b35
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
testq %r14, %r14
je 0x4b29
movq (%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x4b54
movq 0x10(%r14), %r14
jmp 0x4b11
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x39f4
leaq 0x2c14(%rip), %rdi      # 0x7750
leaq 0x29a5(%rip), %rsi      # 0x74e8
leaq 0x2c10(%rip), %rcx      # 0x775a
movl $0xbc, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runTotalTime
static void runTotalTime(RUN* runs, unsigned int run, struct timeval *time) {
  assert(time);
  unsigned int id = 0;
  for (RUN *r = runs; r; r = r->next) {
    if (run == ~0 || run == id) timevalAddAdd(time, &(r->interval));
    id ++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x4ba0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
testq %r14, %r14
je 0x4b95
cmpl $-0x1, %ebp
sete %al
subl $0x1, %r15d
setb %cl
orb %al, %cl
testb $0x1, %cl
je 0x4b8f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a33
movq 0x28(%r14), %r14
jmp 0x4b6b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ad8(%rip), %rdi      # 0x767f
leaq 0x293a(%rip), %rsi      # 0x74e8
leaq 0x2bf5(%rip), %rcx      # 0x77aa
movl $0xb2, %edx
callq 0x2190
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultThreadLoops
static unsigned long resultThreadLoops(const RESULT* result, const unsigned int thread) {
  unsigned int currentThread = 0;

  for (const RESULT *re = result; re; re = re->next) {
    if (currentThread == thread) {
      return getLoops(re->loops);
    }

    currentThread ++;
  }
  assert(0);
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x4bd9
subl $0x1, %esi
jb 0x4bd0
movq 0x8(%rdi), %rdi
jmp 0x4bc0
movq (%rdi), %rdi
popq %rax
jmp 0x4ae9
leaq 0x2697(%rip), %rdi      # 0x7277
leaq 0x2901(%rip), %rsi      # 0x74e8
leaq 0x2ce7(%rip), %rcx      # 0x78d5
pushq $0x65
popq %rdx
callq 0x2190
nop
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_Delete
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
{
    cJSON *next = NULL;
    while (item != NULL)
    {
        next = item->next;
        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
        {
            cJSON_Delete(item->child);
        }
        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
        {
            global_hooks.deallocate(item->valuestring);
        }
        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
        {
            global_hooks.deallocate(item->string);
        }
        global_hooks.deallocate(item);
        item = next;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x4d2e
movq (%rbx), %r14
movl 0x18(%rbx), %eax
btl $0x8, %eax
jb 0x4cf3
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x4cf3
callq 0x4cca
movl 0x18(%rbx), %eax
btl $0x8, %eax
jb 0x4d0b
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4d0b
callq *0x6520(%rip)           # 0xb228
movl 0x18(%rbx), %eax
btl $0x9, %eax
jb 0x4d20
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4d20
callq *0x6508(%rip)           # 0xb228
movq %rbx, %rdi
callq *0x64ff(%rip)           # 0xb228
movq %r14, %rbx
jmp 0x4cd1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: buffer_skip_whitespace
static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL))
    {
        return NULL;
    }

    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
    {
       buffer->offset++;
    }

    if (buffer->offset == buffer->length)
    {
        buffer->offset--;
    }

    return buffer;
}

// Assembly:
testq %rdi, %rdi
je 0x536c
movq %rdi, %rax
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x536c
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rsi
cmpq %rcx, %rsi
jae 0x536f
cmpb $0x20, (%rdx,%rsi)
ja 0x536f
incq %rsi
movq %rsi, 0x10(%rax)
jmp 0x5358
xorl %eax, %eax
retq
cmpq %rsi, %rcx
jne 0x536e
decq %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: print
static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
{
    static const size_t default_buffer_size = 256;
    printbuffer buffer[1];
    unsigned char *printed = NULL;

    memset(buffer, 0, sizeof(buffer));

    /* create buffer */
    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
    buffer->length = default_buffer_size;
    buffer->format = format;
    buffer->hooks = *hooks;
    if (buffer->buffer == NULL)
    {
        goto fail;
    }

    /* print the value */
    if (!print_value(item, buffer))
    {
        goto fail;
    }
    update_offset(buffer);

    /* check if reallocate is available */
    if (hooks->reallocate != NULL)
    {
        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
        if (printed == NULL) {
            goto fail;
        }
        buffer->buffer = NULL;
    }
    else /* otherwise copy the JSON over to a new buffer */
    {
        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
        if (printed == NULL)
        {
            goto fail;
        }
        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
        printed[buffer->offset] = '\0'; /* just to be sure */

        /* free the buffer */
        hooks->deallocate(buffer->buffer);
    }

    return printed;

fail:
    if (buffer->buffer != NULL)
    {
        hooks->deallocate(buffer->buffer);
    }

    if (printed != NULL)
    {
        hooks->deallocate(printed);
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x100, %edi            # imm = 0x100
callq *0x5e73(%rip)           # 0xb220
movq %rax, (%rsp)
movq $0x100, 0x8(%rsp)       # imm = 0x100
movl %ebp, 0x24(%rsp)
movups 0x5e5b(%rip), %xmm0     # 0xb220
movups %xmm0, 0x28(%rsp)
movq 0x5e5f(%rip), %rcx      # 0xb230
movq %rcx, 0x38(%rsp)
testq %rax, %rax
je 0x5462
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5500
testl %eax, %eax
je 0x5462
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x6958
movq 0x5e30(%rip), %rax      # 0xb230
movq 0x10(%rbx), %rsi
incq %rsi
testq %rax, %rax
je 0x541c
movq (%rsp), %rdi
callq *%rax
movq %rax, %rbx
testq %rax, %rax
jne 0x5473
jmp 0x5462
movq %rsi, %rdi
callq *0x5dfb(%rip)           # 0xb220
testq %rax, %rax
je 0x5462
movq %rax, %rbx
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
incq %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %rbx, %rdi
callq 0x21d0
movq 0x10(%rsp), %rax
movb $0x0, (%rbx,%rax)
movq (%rsp), %rdi
callq *0x5dc8(%rip)           # 0xb228
jmp 0x5473
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5471
callq *0x5db7(%rip)           # 0xb228
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_PrintBuffered
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if (prebuffer < 0)
    {
        return NULL;
    }

    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
    if (!p.buffer)
    {
        return NULL;
    }

    p.length = (size_t)prebuffer;
    p.offset = 0;
    p.noalloc = false;
    p.format = fmt;
    p.hooks = global_hooks;

    if (!print_value(item, &p))
    {
        global_hooks.deallocate(p.buffer);
        return NULL;
    }

    return (char*)p.buffer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
andq $0x0, 0x18(%rsp)
testl %esi, %esi
js 0x54f5
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %r14d
movq %r14, %rdi
callq *0x5d79(%rip)           # 0xb220
movq %rax, (%rsp)
testq %rax, %rax
je 0x54f5
movq %rsp, %rsi
movq %r14, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
andl $0x0, 0x20(%rsi)
movl %ebp, 0x24(%rsi)
movups 0x5d56(%rip), %xmm0     # 0xb220
movups %xmm0, 0x28(%rsi)
movq 0x5d5b(%rip), %rax      # 0xb230
movq %rax, 0x38(%rsi)
movq %rbx, %rdi
callq 0x5500
testl %eax, %eax
je 0x54eb
movq (%rsp), %rax
jmp 0x54f7
movq (%rsp), %rdi
callq *0x5d33(%rip)           # 0xb228
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: cJSON_PrintPreallocated
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buf, const int len, const cJSON_bool fmt)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if ((len < 0) || (buf == NULL))
    {
        return false;
    }

    p.buffer = (unsigned char*)buf;
    p.length = (size_t)len;
    p.offset = 0;
    p.noalloc = true;
    p.format = fmt;
    p.hooks = global_hooks;

    return print_value(item, &p);
}

// Assembly:
subq $0x48, %rsp
andq $0x0, 0x20(%rsp)
testl %edx, %edx
sets %r8b
testq %rsi, %rsi
sete %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0x59b2
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl %edx, %edx
movq %rdx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movl $0x1, 0x20(%rax)
movl %ecx, 0x24(%rax)
movups 0x5885(%rip), %xmm0     # 0xb220
movups %xmm0, 0x28(%rax)
movq 0x588a(%rip), %rcx      # 0xb230
movq %rcx, 0x38(%rax)
movq %rax, %rsi
callq 0x5500
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/tomcatzh[P]RealityBenchmark/external/cJSON.c
// Function: get_object_item
static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
    cJSON *current_element = NULL;

    if ((object == NULL) || (name == NULL))
    {
        return NULL;
    }

    current_element = object->child;
    if (case_sensitive)
    {
        while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
        {
            current_element = current_element->next;
        }
    }
    else
    {
        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
        {
            current_element = current_element->next;
        }
    }

    if ((current_element == NULL) || (current_element->string == NULL)) {
        return NULL;
    }

    return current_element;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x5a1c
xorl %ebx, %ebx
jmp 0x5a95
movq %rsi, %r14
movq 0x10(%rdi), %rbx
testl %edx, %edx
je 0x5a7f
testq %rbx, %rbx
je 0x5a18
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x5a8b
movq %r14, %rdi
movq %r15, %rsi
callq 0x22f0
testl %eax, %eax
je 0x5a86
movq (%rbx), %rbx
jmp 0x5a27
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x5a7c
cmpq %r14, %r15
je 0x5a8e
callq 0x2070
movq (%rax), %rax
xorl %ecx, %ecx
movzbl (%r14,%rcx), %edx
movl (%rax,%rdx,4), %esi
movzbl (%r15,%rcx), %edi
cmpl (%rax,%rdi,4), %esi
jne 0x5a7c
testb %dl, %dl
je 0x5a86
incq %rcx
jmp 0x5a61
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x5a49
jmp 0x5a18
movq %r15, %r14
jmp 0x5a8e
xorl %r14d, %r14d
testq %r14, %r14
cmoveq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq