LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x24(%rbp), %rdi
callq 0x38c0
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
xorl %esi, %esi
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
callq 0x3a90
movq -0x8(%rbp), %rdi
callq 0x3990
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0x5, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0x6, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0x7, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, %ecx
shll $0x3, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0x9, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0xa, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0xb, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0xc, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0xd, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl $0xf, %ecx
cltd
idivl %ecx
imull $0xe, %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rdi
callq 0x448a
movl %eax, %ecx
subl $0x2, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x44(%rbp), %rdi
callq 0x3bf0
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %edx
xorl %esi, %esi
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x40(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl -0x38(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2a90
movq -0x8(%rbp), %rdi
callq 0x3990
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jle 0x3ee3
cmpl $0x0, -0x18(%rbp)
setg %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3eec
jmp 0x3f09
movq -0x8(%rbp), %rdi
callq 0x2e00
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ece
jmp 0x3f0b
cmpl $0x0, -0x14(%rbp)
jle 0x3f25
movq -0x8(%rbp), %rdi
callq 0x2d80
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f0b
jmp 0x3f27
cmpl $0x0, -0x18(%rbp)
jle 0x3f41
movq -0x8(%rbp), %rdi
callq 0x2dc0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f27
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x3f88
movq -0x8(%rbp), %rdi
callq 0x2d80
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f6e
jmp 0x3f8a
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3fba
movq -0x8(%rbp), %rdi
callq 0x2d00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f8a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x3ff8
movq -0x8(%rbp), %rdi
callq 0x2cc0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3fde
jmp 0x3ffa
cmpl $0x0, -0x18(%rbp)
jle 0x4014
movq -0x8(%rbp), %rdi
callq 0x2dc0
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ffa
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jle 0x4069
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4072
jmp 0x408f
movq -0x8(%rbp), %rdi
callq 0x2d40
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x403e
jmp 0x4091
cmpl $0x0, -0x14(%rbp)
jle 0x40ab
movq -0x8(%rbp), %rdi
callq 0x2cc0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4091
jmp 0x40ad
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x40dd
movq -0x8(%rbp), %rdi
callq 0x2d00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x40ad
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred_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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4179
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x4142
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3eb0
jmp 0x4177
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jle 0x4175
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3f50
jmp 0x4177
jmp 0x41e5
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jg 0x41ae
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x3fc0
jmp 0x41e3
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x448a
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jle 0x41e1
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x4020
jmp 0x41e3
jmp 0x41e5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x422b
movq -0x8(%rbp), %rdi
callq 0x3000
movl %eax, -0xc(%rbp)
jmp 0x422d
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x25(%rbp)
je 0x4249
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x4252
jmp 0x4274
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x422d
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jg 0x42a4
cmpl $0x1, -0x4(%rbp)
jle 0x42a4
movq -0x10(%rbp), %rdi
callq 0x3440
cmpl $0x4, -0x4(%rbp)
jle 0x42b9
cmpl $0x6, -0x4(%rbp)
jg 0x42b9
movq -0x10(%rbp), %rdi
callq 0x3760
cmpl $0x6, -0x4(%rbp)
jle 0x42d1
cmpl $0xfb, -0x4(%rbp)
jg 0x42d1
movq -0x10(%rbp), %rdi
callq 0x3b50
cmpl $0xfb, -0x4(%rbp)
jle 0x42e3
movq -0x10(%rbp), %rdi
callq 0x3da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12c0
cmpl $0x2, -0x8(%rbp)
jge 0x432a
leaq -0x28(%rbp), %rdi
callq 0x2950
jmp 0x43c5
jmp 0x432c
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x43c3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x13c0
cmpl $-0x1, %eax
jne 0x4357
leaq -0x28(%rbp), %rdi
callq 0x2900
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x12f0
cmpl $0x1, %eax
jne 0x4371
leaq -0x28(%rbp), %rdi
callq 0x2900
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1460
cmpl $-0x1, %eax
jne 0x4390
leaq -0x28(%rbp), %rdi
callq 0x2900
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x14b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x44ef
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x432c
jmp 0x43c5
movq -0x28(%rbp), %rdi
callq 0x2870
leaq -0x28(%rbp), %rdi
callq 0x2e40
cmpl $0x0, %eax
je 0x43e8
movl -0x8(%rbp), %edi
leaq -0x28(%rbp), %rsi
callq 0x4280
leaq -0x28(%rbp), %rdi
callq 0x2950
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/aes_bench.c
// Function: init
static void init() {
  int fd = open("/dev/urandom", O_RDONLY);
  assert(fd >= 0);

  ssize_t ret;

  ret = read(fd, key, keyLength);
  assert(ret == keyLength);

  ret = read(fd, iv, sizeof(iv));
  assert(ret == sizeof(iv));

  if (cipherMode == cipherModeGCM || cipherMode == cipherModeCCM) {
    ret = read(fd, aad, sizeof(aad));
    assert(ret == sizeof(aad));
  }

  close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x8661(%rip), %rdi      # 0xc3c0
xorl %esi, %esi
movb $0x0, %al
callq 0x21c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x3d73
jmp 0x3d92
leaq 0x8653(%rip), %rdi      # 0xc3cd
leaq 0x84b1(%rip), %rsi      # 0xc232
movl $0x26, %edx
leaq 0x8648(%rip), %rcx      # 0xc3d5
callq 0x21a0
movl -0x4(%rbp), %edi
movl 0xc4d5(%rip), %eax      # 0x10270
movl %eax, %edx
leaq 0xc4dc(%rip), %rsi      # 0x10280
callq 0x2340
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc4b9(%rip), %ecx      # 0x10270
cmpq %rcx, %rax
jne 0x3dbe
jmp 0x3ddd
leaq 0x861c(%rip), %rdi      # 0xc3e1
leaq 0x8466(%rip), %rsi      # 0xc232
movl $0x2b, %edx
leaq 0x85fd(%rip), %rcx      # 0xc3d5
callq 0x21a0
movl -0x4(%rbp), %edi
leaq 0xc4b9(%rip), %rsi      # 0x102a0
movl $0x10, %edx
callq 0x2340
movq %rax, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
jne 0x3dfe
jmp 0x3e1d
leaq 0x85ed(%rip), %rdi      # 0xc3f2
leaq 0x8426(%rip), %rsi      # 0xc232
movl $0x2e, %edx
leaq 0x85bd(%rip), %rcx      # 0xc3d5
callq 0x21a0
cmpl $0x10, 0xc450(%rip)     # 0x10274
je 0x3e2f
cmpl $0x20, 0xc447(%rip)     # 0x10274
jne 0x3e71
movl -0x4(%rbp), %edi
leaq 0xc477(%rip), %rsi      # 0x102b0
movl $0x20, %edx
callq 0x2340
movq %rax, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jne 0x3e50
jmp 0x3e6f
leaq 0x85ad(%rip), %rdi      # 0xc404
leaq 0x83d4(%rip), %rsi      # 0xc232
movl $0x32, %edx
leaq 0x856b(%rip), %rcx      # 0xc3d5
callq 0x21a0
jmp 0x3e71
movl -0x4(%rbp), %edi
callq 0x2440
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ea8
jmp 0x3ec7
leaq 0x85d5(%rip), %rdi      # 0xc484
leaq 0x85d5(%rip), %rsi      # 0xc48b
movl $0x46, %edx
leaq 0x85d4(%rip), %rcx      # 0xc496
callq 0x21a0
movq -0x8(%rbp), %rdi
callq 0x2460
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ee6
jmp 0x3f05
leaq 0x85d0(%rip), %rdi      # 0xc4bd
leaq 0x8597(%rip), %rsi      # 0xc48b
movl $0x49, %edx
leaq 0x8596(%rip), %rcx      # 0xc496
callq 0x21a0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x84a8(%rip), %rdi      # 0xc3c0
xorl %esi, %esi
movb $0x0, %al
callq 0x21c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3f2c
jmp 0x3f4b
leaq 0x849a(%rip), %rdi      # 0xc3cd
leaq 0x8551(%rip), %rsi      # 0xc48b
movl $0x4d, %edx
leaq 0x8550(%rip), %rcx      # 0xc496
callq 0x21a0
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x2340
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x3f76
jmp 0x3f95
leaq 0x854d(%rip), %rdi      # 0xc4ca
leaq 0x8507(%rip), %rsi      # 0xc48b
movl $0x4f, %edx
leaq 0x8506(%rip), %rcx      # 0xc496
callq 0x21a0
movl -0x14(%rbp), %edi
callq 0x2440
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x85f2(%rip), %rsi      # 0xc5c1
callq 0x22b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x40f0
movl $0x1, %edi
movl $0x10, %esi
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3fff
jmp 0x401e
leaq 0x847e(%rip), %rdi      # 0xc484
leaq 0x847e(%rip), %rsi      # 0xc48b
movl $0x5b, %edx
leaq 0x84c5(%rip), %rcx      # 0xc4de
callq 0x21a0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2290
movq -0x18(%rbp), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2460
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4076
jmp 0x4095
leaq 0x8440(%rip), %rdi      # 0xc4bd
leaq 0x8407(%rip), %rsi      # 0xc48b
movl $0x62, %edx
leaq 0x844e(%rip), %rcx      # 0xc4de
callq 0x21a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2370
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x40c6
jmp 0x40e5
leaq 0x8435(%rip), %rdi      # 0xc502
leaq 0x83b7(%rip), %rsi      # 0xc48b
movl $0x64, %edx
leaq 0x83fe(%rip), %rcx      # 0xc4de
callq 0x21a0
movq -0x18(%rbp), %rdi
callq 0x2260
jmp 0x40fd
movq -0x8(%rbp), %rdi
callq 0x4110
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/contents.c
// Function: getContentsUrl
static CONTENTS *getContentsUrl(const char *url) {
  CURL *curl_handle;
  CURLcode res;

  CONTENTS *result = calloc(1, sizeof(CONTENTS));
  assert(result);

  curl_global_init(CURL_GLOBAL_ALL);

  curl_handle = curl_easy_init();

  curl_easy_setopt(curl_handle, CURLOPT_URL, url);

  curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1L);

  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);

  curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)result);

  curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

  res = curl_easy_perform(curl_handle);

  if (res != CURLE_OK) {
    destroyContents(result);
    return NULL;
  }

  curl_easy_cleanup(curl_handle);

  curl_global_cleanup();

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x21b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4138
jmp 0x4157
leaq 0x8345(%rip), %rdi      # 0xc484
leaq 0x8345(%rip), %rsi      # 0xc48b
movl $0x25, %edx
leaq 0x8434(%rip), %rcx      # 0xc586
callq 0x21a0
movl $0x3, %edi
callq 0x20b0
callq 0x22f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2712, %esi           # imm = 0x2712
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
movl $0x34, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
movl $0x4e2b, %esi           # imm = 0x4E2B
leaq 0x23d(%rip), %rdx       # 0x43e0
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x2711, %esi           # imm = 0x2711
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
movl $0x2722, %esi           # imm = 0x2722
leaq 0x83df(%rip), %rdx      # 0xc5ad
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rdi
callq 0x2300
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x41fa
movq -0x28(%rbp), %rdi
callq 0x4220
movq $0x0, -0x8(%rbp)
jmp 0x4210
movq -0x18(%rbp), %rdi
callq 0x22e0
callq 0x20d0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/contents.c
// Function: destroyContents
int destroyContents(CONTENTS *file) {
  if (file != NULL) {
    if (file->body != NULL) {
      free(file->body);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x424b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4249
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2458
jmp 0x424b
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4275
jmp 0x4294
leaq 0x829f(%rip), %rdi      # 0xc51b
leaq 0x8208(%rip), %rsi      # 0xc48b
movl $0x79, %edx
leaq 0x829b(%rip), %rcx      # 0xc52a
callq 0x21a0
movq $0x0, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x21b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42b8
jmp 0x42d7
leaq 0x81c5(%rip), %rdi      # 0xc484
leaq 0x81c5(%rip), %rsi      # 0xc48b
movl $0x7d, %edx
leaq 0x8258(%rip), %rcx      # 0xc52a
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2460
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x21f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x2468
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4436
jmp 0x4455
leaq 0x8182(%rip), %rdi      # 0xc5bf
leaq 0x8047(%rip), %rsi      # 0xc48b
movl $0x16, %edx
leaq 0x8173(%rip), %rcx      # 0xc5c3
callq 0x21a0
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x21f0
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0xf4240, 0x8(%rax)     # imm = 0xF4240
jle 0x453f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0xf4240, %rcx          # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4605
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
addq $0x1, %rax
movl %eax, -0x34(%rbp)
imull $0xf4240, -0x34(%rbp), %eax # imm = 0xF4240
movslq %eax, %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movslq -0x34(%rbp), %rcx
movq -0x30(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jle 0x4661
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
subq 0x8(%rcx), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movl %eax, -0x38(%rbp)
imull $0xf4240, -0x38(%rbp), %eax # imm = 0xF4240
movslq %eax, %rcx
movq -0x30(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movslq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4580
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x46eb
movl $0x1, -0x4(%rbp)
jmp 0x470b
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4702
movl $0x1, -0x4(%rbp)
jmp 0x470b
jmp 0x4704
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x46b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x2040
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x2240
movq %rax, -0x28(%rbp)
callq 0x2040
cmpl $0x0, (%rax)
jne 0x47a9
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x47b9
callq 0x2040
movl $0x16, (%rax)
jmp 0x488b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x4820
jmp 0x47c9
movl -0x2c(%rbp), %eax
subl $0x47, %eax
je 0x4817
jmp 0x47d3
movl -0x2c(%rbp), %eax
subl $0x4b, %eax
je 0x4805
jmp 0x47dd
movl -0x2c(%rbp), %eax
subl $0x4d, %eax
je 0x480e
jmp 0x47e7
movl -0x2c(%rbp), %eax
subl $0x67, %eax
je 0x4817
jmp 0x47f1
movl -0x2c(%rbp), %eax
subl $0x6b, %eax
je 0x4805
jmp 0x47fb
movl -0x2c(%rbp), %eax
subl $0x6d, %eax
je 0x480e
jmp 0x4829
movl $0xa, -0x1c(%rbp)
jmp 0x482b
movl $0x14, -0x1c(%rbp)
jmp 0x482b
movl $0x1e, -0x1c(%rbp)
jmp 0x482b
movl $0x0, -0x1c(%rbp)
jmp 0x482b
jmp 0x488b
cmpl $0x0, -0x1c(%rbp)
je 0x484b
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x484b
callq 0x2040
movl $0x16, (%rax)
jmp 0x488b
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq $-0x1, %rdx
shrq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x4871
callq 0x2040
movl $0x22, (%rax)
jmp 0x488b
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4893
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x2468
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4987
jmp 0x49a6
leaq 0x7cb6(%rip), %rdi      # 0xc644
leaq 0x7c93(%rip), %rsi      # 0xc628
movl $0x1f, %edx
leaq 0x7caa(%rip), %rcx      # 0xc64b
callq 0x21a0
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4a66
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x4a70
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2458
jmp 0x4a34
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopDestory
static void loopDestory(LOOP *loops) {
  LOOP *fl;

  for (LOOP *l = loops; l; ) {
    runDestory(l->runs);

    fl = l;
    l = l->next;
    free(fl);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ab6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x54f0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2458
jmp 0x4a84
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4ad9
jmp 0x4af8
leaq 0x7b64(%rip), %rdi      # 0xc644
leaq 0x7b41(%rip), %rsi      # 0xc628
movl $0x247, %edx            # imm = 0x247
leaq 0x7b91(%rip), %rcx      # 0xc684
callq 0x21a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4b04
jmp 0x4b23
leaq 0x7b91(%rip), %rdi      # 0xc69c
leaq 0x7b16(%rip), %rsi      # 0xc628
movl $0x248, %edx            # imm = 0x248
leaq 0x7b66(%rip), %rcx      # 0xc684
callq 0x21a0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2460
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4b42
jmp 0x4b61
leaq 0x7b5e(%rip), %rdi      # 0xc6a7
leaq 0x7ad8(%rip), %rsi      # 0xc628
movl $0x24b, %edx            # imm = 0x24B
leaq 0x7b28(%rip), %rcx      # 0xc684
callq 0x21a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x4ba1
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0xdf(%rip), %rdx        # 0x4c70
callq 0x2410
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b68
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x4c62
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2210
movl $0x1, %edi
movl $0x10, %esi
callq 0x21b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4c00
jmp 0x4c1f
leaq 0x7aa5(%rip), %rdi      # 0xc6ac
leaq 0x7a1a(%rip), %rsi      # 0xc628
movl $0x259, %edx            # imm = 0x259
leaq 0x7a6a(%rip), %rcx      # 0xc684
callq 0x21a0
cmpq $0x0, -0x20(%rbp)
jne 0x4c2e
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4c41
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4bb8
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: printResult
void printResult(const RESULT *r, int verbose, int formated) {
  cJSON *json = NULL;
  if (verbose) {
    json = resultToJSONVerbose(r);
  } else {
    json = resultToJSON(r);
  }
  assert(json);

  char *jsonString = NULL;
  if (formated) {
    jsonString = cJSON_Print(json);
  } else {
    jsonString = cJSON_PrintUnformatted(json);
  }
  assert(jsonString);

  printf("%s\n", jsonString);

  cJSON_Delete(json);
  free(jsonString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4f2f
movq -0x8(%rbp), %rdi
callq 0x4fe0
movq %rax, -0x18(%rbp)
jmp 0x4f3c
movq -0x8(%rbp), %rdi
callq 0x5070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4f45
jmp 0x4f64
leaq 0x776a(%rip), %rdi      # 0xc6b6
leaq 0x76d5(%rip), %rsi      # 0xc628
movl $0x26b, %edx            # imm = 0x26B
leaq 0x775c(%rip), %rcx      # 0xc6bb
callq 0x21a0
movq $0x0, -0x20(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x4f81
movq -0x18(%rbp), %rdi
callq 0x6f90
movq %rax, -0x20(%rbp)
jmp 0x4f8e
movq -0x18(%rbp), %rdi
callq 0x7160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4f97
jmp 0x4fb6
leaq 0x7748(%rip), %rdi      # 0xc6e6
leaq 0x7683(%rip), %rsi      # 0xc628
movl $0x273, %edx            # imm = 0x273
leaq 0x770a(%rip), %rcx      # 0xc6bb
callq 0x21a0
movq -0x20(%rbp), %rsi
leaq 0x7730(%rip), %rdi      # 0xc6f1
movb $0x0, %al
callq 0x2050
movq -0x18(%rbp), %rdi
callq 0x67e0
movq -0x20(%rbp), %rdi
callq 0x2458
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: resultToJSONVerbose
static cJSON *resultToJSONVerbose(const RESULT *results) {
  cJSON *resultsJSON = cJSON_CreateArray();
  assert(resultsJSON);

  for (const RESULT *re = results; re; re = re->next) {
    cJSON_AddItemToArray(resultsJSON, loopsToJSONVerbose(re->loops));
  }

  return resultsJSON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ffe
jmp 0x501d
leaq 0x7711(%rip), %rdi      # 0xc716
leaq 0x761c(%rip), %rsi      # 0xc628
movl $0x1f0, %edx            # imm = 0x1F0
leaq 0x770a(%rip), %rcx      # 0xc722
callq 0x21a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x505a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5530
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x7810
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5025
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: runDestory
static void runDestory(RUN *runs) {
  RUN *fru;

  for (RUN *ru = runs; ru; ) {
      fru = ru;
      ru = ru->next;
      free(fru);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x552a
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2458
jmp 0x5504
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/benchmark.c
// Function: loopsToJSONVerbose
static cJSON *loopsToJSONVerbose(const LOOP* loops) {
  cJSON *loopsJSON = cJSON_CreateArray();
  assert(loopsJSON);

  for (const LOOP *l = loops; l; l = l->next) {
    cJSON *loop = cJSON_CreateObject();
    assert(loop);

    cJSON_AddBoolToObject(loop, "correct", l->correct);
    cJSON_AddItemToObject(loop, "runs", runsToJSONVerbose(l->runs));

    cJSON_AddItemToArray(loopsJSON, loop);
  }

  return loopsJSON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x554e
jmp 0x556d
leaq 0x71f8(%rip), %rdi      # 0xc74d
leaq 0x70cc(%rip), %rsi      # 0xc628
movl $0x1df, %edx            # imm = 0x1DF
leaq 0x71ef(%rip), %rcx      # 0xc757
callq 0x21a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x560d
callq 0x81a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5592
jmp 0x55b1
leaq 0x71e6(%rip), %rdi      # 0xc77f
leaq 0x7088(%rip), %rsi      # 0xc628
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x71ab(%rip), %rcx      # 0xc757
callq 0x21a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x71c1(%rip), %rsi      # 0xc784
callq 0x7d90
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5620
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x71a2(%rip), %rsi      # 0xc78c
callq 0x78d0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7810
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5575
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)