LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo.c
// Function: ft_process_sort
int			ft_process_sort(t_stack *s)
{
	int		ret_a;
	int		ret_b;

	if (s->size_a < 4)
		ft_three_a(s);
	while (!ft_reposition(s, &ret_a, &ret_b, 1))
	{
		ft_divide_b_stack(s, &ret_a, &ret_b);
		ft_reposition(s, &ret_a, &ret_b, 0);
		ft_divide_a_stack(s, &ret_a, &ret_b);
		ft_process_sort(s);
	}
	while (s->size_b)
		ft_cmd(ft_exec_push, s, "pa");
	ft_reposition(s, &ret_a, &ret_b, 1);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x3, 0x20(%rdi)
ja 0x17fd
movq %rbx, %rdi
callq 0x26d4
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20e2
testl %eax, %eax
jne 0x1998
leaq 0x4(%rsp), %r14
movq %rsp, %r15
leaq 0x13f3(%rip), %r12      # 0x2c1c
leaq 0x27e9(%rip), %r13      # 0x4019
cmpq $0x3, 0x28(%rbx)
ja 0x183f
movq %rbx, %rdi
callq 0x2818
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x20e2
movq 0x28(%rbx), %rsi
cmpq $0x4, %rsi
jb 0x1957
cmpl $0x0, (%rsp)
jne 0x1957
movq 0x8(%rbx), %rdi
callq 0x2236
movq 0x28(%rbx), %rsi
cmpq $0x4, %rsi
jb 0x1941
movslq %eax, %rbp
movq 0x8(%rbx), %rdi
movq %rbp, %rdx
movl $0x1, %ecx
callq 0x26a8
testl %eax, %eax
je 0x1941
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movl $0x1, %edx
callq 0x1f60
testl %eax, %eax
jne 0x1941
movq 0x8(%rbx), %rax
movq 0x28(%rbx), %rcx
cmpq %rbp, -0x8(%rax,%rcx,8)
jge 0x18fa
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x235a
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x1910
movq (%rbx), %rdi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x1910
movq %r12, %rdi
movq %rbx, %rsi
leaq 0x271d(%rip), %rdx      # 0x4015
jmp 0x190b
leaq 0x1285(%rip), %rdi      # 0x2b86
movq %rbx, %rsi
leaq 0x271d(%rip), %rdx      # 0x4028
callq 0x235a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x20e2
movq 0x28(%rbx), %rsi
cmpq $0x3, %rsi
ja 0x1881
jmp 0x1941
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x235a
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x1933
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x20e2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x19eb
movq %rbx, %rdi
callq 0x17e0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x20e2
testl %eax, %eax
je 0x1830
cmpq $0x0, 0x28(%rbx)
je 0x19c2
leaq 0x11e0(%rip), %r14      # 0x2b86
leaq 0x267b(%rip), %r15      # 0x4028
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x235a
cmpq $0x0, 0x28(%rbx)
jne 0x19ad
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x20e2
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo.c
// Function: ft_divide_a_stack
static void	ft_divide_a_stack(t_stack *s, int *ret_a, int *ret_b)
{
	long	pivot;

	if (s->size_a < 4)
		ft_three_a(s);
	ft_reposition(s, ret_a, ret_b, 0);
	if (s->size_a < 4 || *ret_a)
		return ;
	pivot = ft_med_stack(s->a, s->size_a);
	while (s->size_a > 3 && ft_over_pivot(s->a, s->size_a, pivot, 0)
			&& !ft_is_good(s->a, s->size_a, 0))
		ft_loop_divide_a(s, ret_a, ret_b, pivot);
	ft_reposition(s, ret_a, ret_b, 1);
	ft_divide_a_stack(s, ret_a, ret_b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1216(%rip), %rbp      # 0x2c1c
leaq 0x260c(%rip), %r12      # 0x4019
cmpq $0x3, 0x20(%r15)
ja 0x1a1c
movq %r15, %rdi
callq 0x26d4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x20e2
movq 0x20(%r15), %rsi
cmpq $0x4, %rsi
jb 0x1b68
cmpl $0x0, (%r14)
jne 0x1b68
movq (%r15), %rdi
callq 0x229b
movq 0x20(%r15), %rsi
cmpq $0x4, %rsi
jb 0x1b50
movslq %eax, %r13
movq (%r15), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x26a8
testl %eax, %eax
je 0x1b50
movq (%r15), %rdi
movq 0x20(%r15), %rsi
xorl %edx, %edx
callq 0x1f60
testl %eax, %eax
jne 0x1b50
movq (%r15), %rcx
movq 0x20(%r15), %rdx
movq -0x8(%rcx,%rdx,8), %rax
cmpq %r13, %rax
jge 0x1ad5
cmpq -0x10(%rcx,%rdx,8), %rax
jle 0x1ad5
leaq 0x102d(%rip), %rdi      # 0x2ad4
movq %r15, %rsi
leaq 0x2559(%rip), %rdx      # 0x400a
callq 0x235a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x20e2
movq 0x20(%r15), %rsi
cmpq $0x3, %rsi
ja 0x1a5d
jmp 0x1b50
cmpq %r13, %rax
jge 0x1b11
leaq 0x10a5(%rip), %rdi      # 0x2b86
movq %r15, %rsi
leaq 0x2540(%rip), %rdx      # 0x402b
callq 0x235a
movq 0x8(%r15), %rdi
movq 0x28(%r15), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
jne 0x1ab6
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x1aeb
movq %rbp, %rdi
movq %r15, %rsi
leaq 0x24f7(%rip), %rdx      # 0x4015
callq 0x235a
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x1ab6
movq 0x8(%r15), %rdi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x1ab6
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x1ab1
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x20e2
jmp 0x1a0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo500.c
// Function: ft_divide_a_stack500
static void	ft_divide_a_stack500(t_stack *s, int *ret_a, int *ret_b)
{
	long	pivot;

	if (s->size_a < 4)
		ft_three_a(s);
	ft_reposition(s, ret_a, ret_b, 0);
	if (s->size_a < 4 || *ret_a)
		return ;
	pivot = ft_med_stack(s->a, s->size_a);
	if (ft_is_the_smallest(s->a, s->size_a, pivot))
		return ;
	while (s->size_a > 3 && ft_over_pivot(s->a, s->size_a, pivot, 0)
			&& !ft_is_good(s->a, s->size_a, 0))
		ft_loop_divide_a(s, ret_a, ret_b, pivot);
	ft_divide_a_stack500(s, ret_a, ret_b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xce6(%rip), %r12       # 0x2ad4
leaq 0x2215(%rip), %rbp      # 0x400a
cmpq $0x3, 0x20(%r15)
ja 0x1e04
movq %r15, %rdi
callq 0x26d4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x20e2
movq 0x20(%r15), %rsi
cmpq $0x4, %rsi
jb 0x1f50
cmpl $0x0, (%r14)
jne 0x1f50
movq (%r15), %rdi
callq 0x229b
movslq %eax, %r13
movq (%r15), %rdi
movq 0x20(%r15), %rsi
movq %r13, %rdx
callq 0x2217
testl %eax, %eax
jne 0x1f50
movq 0x20(%r15), %rsi
cmpq $0x4, %rsi
jb 0x1df5
movq (%r15), %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x26a8
testl %eax, %eax
je 0x1df5
movq (%r15), %rdi
movq 0x20(%r15), %rsi
xorl %edx, %edx
callq 0x1f60
testl %eax, %eax
jne 0x1df5
movq 0x28(%r15), %rax
cmpq $0x2, %rax
jb 0x1ea8
movq 0x8(%r15), %rcx
movq -0x8(%rcx,%rax,8), %rdx
cmpq -0x10(%rcx,%rax,8), %rdx
jge 0x1ea8
movq %r12, %rdi
movq %r15, %rsi
leaq 0x2167(%rip), %rdx      # 0x400d
jmp 0x1f25
movq (%r15), %rcx
movq 0x20(%r15), %rdx
movq -0x8(%rcx,%rdx,8), %rax
cmpq %r13, %rax
jge 0x1ecb
cmpq -0x10(%rcx,%rdx,8), %rax
jle 0x1ecb
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
jmp 0x1f25
cmpq %r13, %rax
jge 0x1ee3
leaq 0xcaf(%rip), %rdi       # 0x2b86
movq %r15, %rsi
leaq 0x214a(%rip), %rdx      # 0x402b
jmp 0x1f25
leaq 0xd32(%rip), %rdi       # 0x2c1c
movq %r15, %rsi
leaq 0x2121(%rip), %rdx      # 0x4015
callq 0x235a
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x1f2a
movq 0x8(%r15), %rdi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x1f2a
leaq 0xd01(%rip), %rdi       # 0x2c1c
movq %r15, %rsi
leaq 0x20f4(%rip), %rdx      # 0x4019
callq 0x235a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
callq 0x20e2
movq 0x20(%r15), %rsi
cmpq $0x3, %rsi
ja 0x1e58
jmp 0x1df5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_is_good
int			ft_is_good(long *tab, size_t size, int which)
{
	size_t		i;

	i = 0;
	while (i + 1 < size)
	{
		if ((which == 0 && tab[i] < tab[i + 1])
				|| (which == 1 && tab[i] > tab[i + 1]))
			return (FALSE);
		i++;
	}
	return (TRUE);
}

// Assembly:
movl $0x1, %eax
cmpq $0x2, %rsi
jb 0x1f9c
movl $0x1, %ecx
cmpl $0x1, %edx
je 0x1f89
testl %edx, %edx
jne 0x1f94
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jl 0x1f9d
cmpl $0x1, %edx
jne 0x1f94
movq -0x8(%rdi,%rcx,8), %r8
cmpq (%rdi,%rcx,8), %r8
jg 0x1f9d
incq %rcx
cmpq %rcx, %rsi
jne 0x1f70
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_check_ok
int			ft_check_ok(t_stack *s, int which)
{
	int		rot;
	size_t	size;

	size = (which == 1) ? s->size_b : s->size_a;
	if ((which == 1 && s->size_b == 0)
			|| (which == 0 && s->size_a == 0))
		return (-1);
	if ((rot = ft_check_rotate(which ? s->b : s->a, size, which)))
		return (rot);
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
movq 0x20(%rdi,%rax,8), %r14
jne 0x1fca
cmpq $0x0, 0x28(%rdi)
je 0x20b2
testl %ebx, %ebx
je 0x1fd7
addq $0x8, %rdi
movq %r14, %rax
jmp 0x1fe4
cmpq $0x0, 0x20(%rdi)
je 0x20b2
xorl %eax, %eax
xorl %r15d, %r15d
cmpl $0x1, %ebx
movq %r14, %rcx
cmoveq %r15, %rcx
movq (%rdi), %rdx
movq %rdx, (%rsp)
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq (,%r14,8), %rbp
movq %rbp, %rdi
callq 0x1070
movl $0x0, %r12d
testq %rax, %rax
je 0x2037
movq %rax, %r13
testq %r14, %r14
je 0x2034
movq %r13, %rdi
movq (%rsp), %rsi
movq %rbp, %rdx
callq 0x1060
movq %r13, %r12
testq %r12, %r12
je 0x20d0
xorl %ecx, %ecx
cmpl $0x1, %ebx
movq %r12, %rax
cmoveq %rcx, %rax
testl %ebx, %ebx
movq %rax, 0x8(%rsp)
movq %r12, %rax
cmoveq %rcx, %rax
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x20a5
cmpl $0x1, %ebx
leaq 0x1fab(%rip), %rax      # 0x4019
leaq 0x1fa0(%rip), %r13      # 0x4015
cmoveq %rax, %r13
xorl %r15d, %r15d
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1f60
testl %eax, %eax
jne 0x20ba
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2c1c
incq %r15
cmpq %r15, %r14
jne 0x2081
movq %r12, %rdi
callq 0x1030
xorl %r15d, %r15d
jmp 0x20d0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x20d0
movq %r12, %rdi
callq 0x1030
xorl %eax, %eax
cmpq $0x1, %r15
sbbl %eax, %eax
orl %r15d, %eax
movq %rax, %r15
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_order.c
// Function: ft_reposition
int			ft_reposition(t_stack *s, int *ret_a, int *ret_b, int exec)
{
	int		rot_a;
	int		rot_b;

	rot_a = 0;
	rot_b = 0;
	*ret_a = ft_check_ok(s, 0);
	*ret_b = ft_check_ok(s, 1);
	if (*ret_a > 0 && exec)
		rot_a = *ret_a;
	if (*ret_b > 0 && exec)
		rot_b = *ret_b;
	while (rot_a-- > 0 && rot_b-- > 0)
		ft_cmd(ft_exec_rotate, s, "rr");
	while (rot_a-- > 0)
		ft_cmd(ft_exec_rotate, s, "ra");
	while (rot_b-- > 0)
		ft_cmd(ft_exec_rotate, s, "rb");
	return (*ret_a && *ret_b ? TRUE : FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x1fa0
movl %eax, (%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x1fa0
movl %eax, (%r12)
movq %r14, 0x8(%rsp)
movl (%r14), %r14d
testl %r14d, %r14d
cmovlel %ebx, %r14d
testl %eax, %eax
cmovgl %eax, %ebx
testl %ebp, %ebp
cmovel %ebp, %r14d
cmovel %ebp, %ebx
movl %r14d, %ebp
subl $0x1, %ebp
movq %r12, 0x10(%rsp)
jb 0x217b
leaq 0xad3(%rip), %rbp       # 0x2c1c
leaq 0x1ed2(%rip), %r13      # 0x4022
movl %ebx, %r12d
testl %ebx, %ebx
jle 0x216f
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x235a
leal -0x1(%r12), %ebx
decl %r14d
jg 0x2150
decl %r14d
movl %r14d, %ebp
decl %r12d
movl %r12d, %ebx
movq 0x8(%rsp), %r14
testl %ebp, %ebp
jle 0x21a9
incl %ebp
leaq 0xa8f(%rip), %r12       # 0x2c1c
leaq 0x1e81(%rip), %r13      # 0x4015
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x235a
decl %ebp
cmpl $0x1, %ebp
jg 0x2194
testl %ebx, %ebx
jle 0x21d2
incl %ebx
leaq 0xa66(%rip), %r12       # 0x2c1c
leaq 0x1e5c(%rip), %r13      # 0x4019
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x235a
decl %ebx
cmpl $0x1, %ebx
jg 0x21bd
cmpl $0x0, (%r14)
je 0x21e7
xorl %eax, %eax
movq 0x10(%rsp), %rcx
cmpl $0x0, (%rcx)
setne %al
jmp 0x21e9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_third
int		ft_third(long *tab, int size)
{
	long	*cpy;
	int		i;
	int		ret;

	i = 0;
	if (!(cpy = (long *)malloc(sizeof(long) * size)))
		return (tab[size - 1]);
	while (i < size)
	{
		cpy[i] = tab[i];
		i++;
	}
	ft_insertsort_long(cpy, size);
	ret = cpy[size - 1];
	free(cpy);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %rbx
leaq (,%rbx,8), %rdi
callq 0x1070
testq %rax, %rax
je 0x2289
movq %rax, %r14
testl %ebp, %ebp
jle 0x226f
movl %ebp, %edx
shlq $0x3, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3545
movq -0x8(%r14,%rbx,8), %rbx
movq %r14, %rdi
callq 0x1030
jmp 0x228e
movq -0x8(%r15,%rbx,8), %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_med_stack
int		ft_med_stack(long *tab, int size)
{
	long	*cpy;
	int		i;
	int		ret;
	int		tmp_size;

	i = -1;
	if (!(cpy = (long *)malloc(sizeof(long) * size)))
		return (tab[size - 1]);
	while (++i < size)
	{
		cpy[i] = tab[i];
	}
	ft_insertsort_long(cpy, size);
	tmp_size = size;
	if (size >= 300)
		size = size / 4 + size % 4;
	else if (size >= 12)
		size = size / 3 + size % 3;
	else
		size = size / 2;
	if (tmp_size < size)
		size = tmp_size - 1;
	ret = size > 0 ? cpy[size] : cpy[0];
	free(cpy);
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r12
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x1070
testq %rax, %rax
je 0x22fc
movq %rax, %rbx
testl %r14d, %r14d
jle 0x22d8
movl %r14d, %edx
shlq $0x3, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1060
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3545
cmpl $0x12c, %r14d           # imm = 0x12C
jl 0x2303
movl %r14d, %eax
shrl $0x2, %eax
leal (%rax,%rax,2), %ecx
movl %r14d, %eax
subl %ecx, %eax
jmp 0x232e
movq -0x8(%r12,%r15,8), %r14
jmp 0x234b
cmpl $0xc, %r14d
jl 0x2323
movl %r14d, %eax
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
imulq %rax, %rcx
shrq $0x20, %rcx
andl $-0x2, %ecx
movl %r14d, %eax
subl %ecx, %eax
jmp 0x232e
movl %r14d, %eax
shrl $0x1f, %eax
addl %r14d, %eax
sarl %eax
leal -0x1(%r14), %ecx
cmpl %r14d, %eax
cmovlel %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
movq (%rbx,%rax,8), %r14
movq %rbx, %rdi
callq 0x1030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_post_process
int			ft_post_process(t_stack *s, char **buf, char **tab)
{
	int		i;

	i = 0;
	if (ft_strequ(tab[i], "pa") && ft_strequ(tab[i + 1], "pa"))
		i = ft_reduce_push(s, buf, tab, 0);
	else if (ft_strequ(tab[i], "pb") && ft_strequ(tab[i + 1], "pb"))
		i = ft_reduce_push(s, buf, tab, 0);
	else if ((ft_strequ(tab[i], "ra") || ft_strequ(tab[i], "rra"))
			&& ft_strequ(tab[i], tab[i + 1]))
		i = ft_reduce_rotate(s, buf, tab, 0);
	else if ((ft_strequ(tab[i], "rb") || ft_strequ(tab[i], "rrb"))
			&& ft_strequ(tab[i], tab[i + 1]))
		i = ft_reduce_rotate(s, buf, tab, 1);
	return (i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
leaq 0x1c6c(%rip), %rsi      # 0x4028
callq 0x3070
testl %eax, %eax
je 0x23d9
movq 0x8(%rbx), %rdi
leaq 0x1c58(%rip), %rsi      # 0x4028
callq 0x3070
testl %eax, %eax
jne 0x2400
movq (%rbx), %rdi
leaq 0x1c48(%rip), %rsi      # 0x402b
callq 0x3070
testl %eax, %eax
je 0x2413
movq 0x8(%rbx), %rdi
leaq 0x1c34(%rip), %rsi      # 0x402b
callq 0x3070
testl %eax, %eax
je 0x2413
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x24ac
movq (%rbx), %rdi
leaq 0x1bf8(%rip), %rsi      # 0x4015
callq 0x3070
testl %eax, %eax
jne 0x2439
movq (%rbx), %rdi
leaq 0x1be4(%rip), %rsi      # 0x4014
callq 0x3070
testl %eax, %eax
je 0x2456
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3070
testl %eax, %eax
je 0x2456
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
jmp 0x249a
movq (%rbx), %rdi
leaq 0x1bb9(%rip), %rsi      # 0x4019
callq 0x3070
testl %eax, %eax
jne 0x247c
movq (%rbx), %rdi
leaq 0x1ba5(%rip), %rsi      # 0x4018
callq 0x3070
testl %eax, %eax
je 0x24a4
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3070
testl %eax, %eax
je 0x24a4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x25b5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_reduce_push
static int	ft_reduce_push(t_stack *s, char **buf, char **tab, int which)
{
	int		i;
	int		tmp;

	tmp = 0;
	i = ft_how_push(tab, which, &tmp);
	while (tmp > 0)
	{
		*buf = ft_strjoinfree(*buf, which ? "pb\n" : "pa\n", FIRST);
		tmp--;
		s->size_a = which ? s->size_a - 1 : s->size_a + 1;
		s->size_b = which ? s->size_b + 1 : s->size_b - 1;
	}
	while (tmp < 0)
	{
		*buf = ft_strjoinfree(*buf, which ? "pa\n" : "pb\n", FIRST);
		tmp++;
		s->size_a = which ? s->size_a + 1 : s->size_a - 1;
		s->size_b = which ? s->size_b - 1 : s->size_b + 1;
	}
	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rdi
leaq 0x1b5e(%rip), %rsi      # 0x4028
callq 0x3070
xorl %r13d, %r13d
testl %eax, %eax
je 0x24f6
leaq 0x1b4b(%rip), %r12      # 0x4028
movq 0x8(%r15,%r13,8), %rdi
incq %r13
movq %r12, %rsi
callq 0x3070
testl %eax, %eax
jne 0x24dd
movl %r13d, %ebp
jmp 0x24f8
xorl %ebp, %ebp
movl %ebp, %r12d
movq (%r15,%r12,8), %rdi
leaq 0x1b25(%rip), %rsi      # 0x402b
callq 0x3070
testl %eax, %eax
je 0x2542
movq %r12, (%rsp)
leaq (%r15,%r12,8), %r12
addq $0x8, %r12
xorl %ebp, %ebp
leaq 0x1b07(%rip), %r15      # 0x402b
movq (%r12,%rbp,8), %rdi
movq %r15, %rsi
callq 0x3070
incq %rbp
testl %eax, %eax
jne 0x2524
movq (%rsp), %rax
addl %ebp, %eax
subl %ebp, %r13d
movl %eax, %ebp
testl %r13d, %r13d
jle 0x2578
incl %r13d
leaq 0x1ae1(%rip), %r15      # 0x4032
movq (%rbx), %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3149
movq %rax, (%rbx)
incq 0x20(%r14)
decq 0x28(%r14)
decl %r13d
cmpl $0x1, %r13d
jg 0x2551
xorl %r13d, %r13d
testl %r13d, %r13d
jns 0x25a4
leaq 0x1aaa(%rip), %r15      # 0x402e
movq (%rbx), %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x3149
movq %rax, (%rbx)
decq 0x20(%r14)
incq 0x28(%r14)
incl %r13d
jne 0x2584
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_reduce_rotate
static int	ft_reduce_rotate(t_stack *s, char **buf, char **tab, int which)
{
	int		i;
	int		tmp;
	char	*str;

	i = 0;
	str = tab[i];
	while (ft_strequ(tab[i], tab[i + 1]))
		i++;
	tmp = ++i;
	if ((which && tmp > (int)s->size_b / 2)
			|| (!which && tmp > (int)s->size_a / 2))
		tmp = which ? tmp - s->size_b : tmp - s->size_a;
	if (tmp >= 0)
		i = 0;
	while (tmp < 0)
	{
		if (which)
			*buf = ft_strjoinfree(*buf, ft_strequ(str, "rb")
					? "rrb\n" : "rb\n", FIRST);
		else
			*buf = ft_strjoinfree(*buf, ft_strequ(str, "ra")
					? "rra\n" : "ra\n", FIRST);
		tmp++;
	}
	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movq (%rdx), %r15
xorl %ebp, %ebp
movq (%r13,%rbp,8), %rdi
movq 0x8(%r13,%rbp,8), %rsi
incq %rbp
callq 0x3070
testl %eax, %eax
jne 0x25d0
leaq -0x1(%rbp), %rax
testl %ebx, %ebx
je 0x2603
movl 0x28(%r12), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl $0x28, %ecx
jmp 0x2616
movl 0x20(%r12), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl $0x20, %ecx
cmpl %eax, %edx
jle 0x261e
movl %ebp, %ecx
jmp 0x2626
movl (%r12,%rcx), %eax
movl %ebp, %ecx
subl %eax, %ecx
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
jns 0x2690
movl 0x4(%rsp), %r13d
movq (%r14), %r12
movq %r15, %rdi
testl %ebx, %ebx
je 0x265d
leaq 0x19d5(%rip), %rsi      # 0x4019
callq 0x3070
leaq 0x19e7(%rip), %rsi      # 0x4037
testl %eax, %eax
je 0x267b
leaq 0x19db(%rip), %rsi      # 0x4036
jmp 0x267b
leaq 0x19b1(%rip), %rsi      # 0x4015
callq 0x3070
leaq 0x19cc(%rip), %rsi      # 0x403c
testl %eax, %eax
je 0x267b
leaq 0x19c0(%rip), %rsi      # 0x403b
movq %r12, %rdi
movl $0x1, %edx
callq 0x3149
movq %rax, (%r14)
incl %r13d
jne 0x2633
movl 0x4(%rsp), %eax
sarl $0x1f, %eax
andl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_over_pivot
int			ft_over_pivot(long *tab, size_t size, long pivot, int which)
{
	size_t		i;

	i = 0;
	while (i < size)
	{
		if ((!which && tab[i] < pivot) || (which && tab[i] >= pivot))
			return (TRUE);
		i++;
	}
	return (FALSE);
}

// Assembly:
testq %rsi, %rsi
je 0x26cb
xorl %eax, %eax
movq (%rdi,%rax,8), %r8
testl %ecx, %ecx
je 0x26be
cmpq %rdx, %r8
jl 0x26c3
jmp 0x26ce
cmpq %rdx, %r8
jl 0x26ce
incq %rax
cmpq %rax, %rsi
jne 0x26af
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_three_a
void		ft_three_a(t_stack *s)
{
	if (s->size_a <= 1 || ft_is_good(s->a, s->size_a, 0))
		return ;
	else if (s->size_a == 2)
	{
		if (s->a[s->size_a - 1] > s->a[s->size_a - 2])
			ft_cmd(ft_exec_swap, s, "sa");
	}
	else
		ft_three_a_extend(s);
}

// Assembly:
pushq %rbx
movq 0x20(%rdi), %rsi
cmpq $0x2, %rsi
jb 0x26f0
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %edx, %edx
callq 0x1f60
testl %eax, %eax
je 0x26f2
popq %rbx
retq
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x270d
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jle 0x26f0
jmp 0x27db
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x2734
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x27eb
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x2771
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x2771
leaq 0x4b7(%rip), %rdi       # 0x2c1c
leaq 0x18a9(%rip), %rdx      # 0x4015
jmp 0x280f
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x27b3
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x27b3
leaq 0x47a(%rip), %rdi       # 0x2c1c
leaq 0x186b(%rip), %rdx      # 0x4014
movq %rbx, %rsi
callq 0x235a
jmp 0x27db
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
jne 0x2801
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
movq (%rdi), %rdx
callq 0x21f8
testl %eax, %eax
je 0x2801
leaq 0x2f2(%rip), %rdi       # 0x2ad4
leaq 0x1821(%rip), %rdx      # 0x400a
jmp 0x280f
leaq 0x2e2(%rip), %rdi       # 0x2ad4
leaq 0x1811(%rip), %rdx      # 0x400a
movq %rbx, %rsi
callq 0x235a
leaq 0x414(%rip), %rdi       # 0x2c1c
leaq 0x1805(%rip), %rdx      # 0x4014
movq %rbx, %rsi
popq %rbx
jmp 0x235a
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/srcs_push_swap/ft_algo_tool.c
// Function: ft_three_b
void		ft_three_b(t_stack *s)
{
	if (s->size_b <= 1 || ft_is_good(s->b, s->size_b, 1))
		return ;
	else if (s->size_b == 2)
	{
		if (s->b[s->size_b - 1] < s->b[s->size_b - 2])
			ft_cmd(ft_exec_swap, s, "sb");
	}
	else
		ft_three_b_extend(s);
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rsi
cmpq $0x2, %rsi
jb 0x2838
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %edx
callq 0x1f60
testl %eax, %eax
je 0x283a
popq %rbx
retq
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
cmpq $0x2, %rsi
jne 0x2856
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
jge 0x2838
jmp 0x292b
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x287e
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x293b
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x28bd
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x28bd
leaq 0x36b(%rip), %rdi       # 0x2c1c
leaq 0x1761(%rip), %rdx      # 0x4019
jmp 0x295f
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
je 0x2901
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x10(%rdi,%rsi,8), %rdx
callq 0x2217
testl %eax, %eax
je 0x2901
leaq 0x32c(%rip), %rdi       # 0x2c1c
leaq 0x1721(%rip), %rdx      # 0x4018
movq %rbx, %rsi
callq 0x235a
jmp 0x292b
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq -0x8(%rdi,%rsi,8), %rdx
callq 0x21f8
testl %eax, %eax
jne 0x2951
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq (%rdi), %rdx
callq 0x2217
testl %eax, %eax
je 0x2951
leaq 0x1a2(%rip), %rdi       # 0x2ad4
leaq 0x16d4(%rip), %rdx      # 0x400d
jmp 0x295f
leaq 0x192(%rip), %rdi       # 0x2ad4
leaq 0x16c4(%rip), %rdx      # 0x400d
movq %rbx, %rsi
callq 0x235a
leaq 0x2c4(%rip), %rdi       # 0x2c1c
leaq 0x16b9(%rip), %rdx      # 0x4018
movq %rbx, %rsi
popq %rbx
jmp 0x235a
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insertsort_integer
void		ft_insertsort_integer(int *tab, size_t size)
{
	size_t	i;
	size_t	j;

	if (!tab)
		return ;
	i = 0;
	while (++i < size)
	{
		j = 0;
		while (j < i)
		{
			if (tab[i] < tab[j++])
				ft_insert_elem(tab, i, j);
		}
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
jne 0x3544
pushq %rbx
leaq 0x4(%rdi), %rax
movl $0x1, %ecx
movq %rcx, %rdx
xorl %r8d, %r8d
cmpq $0x1, %rdx
movl $0x0, %r9d
sbbq %rdx, %r9
movl (%rdi,%rcx,4), %r10d
cmpl (%rdi,%r8,4), %r10d
jge 0x352c
xorl %r11d, %r11d
movl -0x4(%rax,%r11,4), %ebx
movl %ebx, (%rax,%r11,4)
decq %r11
cmpq %r11, %r9
jne 0x3517
movl %r10d, (%rax,%r11,4)
incq %r8
decq %rdx
cmpq %rcx, %r8
jne 0x34fd
incq %rcx
addq $0x4, %rax
cmpq %rsi, %rcx
jne 0x34f7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insertsort_long
void		ft_insertsort_long(long *tab, size_t size)
{
	size_t	i;
	size_t	j;

	if (!tab)
		return ;
	i = 0;
	while (++i < size)
	{
		j = 0;
		while (j < i)
		{
			if (tab[i] < tab[j++])
				ft_insert_elem_long(tab, i, j);
		}
	}
}

// Assembly:
testq %rdi, %rdi
sete %al
cmpq $0x2, %rsi
setb %cl
orb %al, %cl
jne 0x35b0
pushq %rbx
leaq 0x8(%rdi), %rax
movl $0x1, %ecx
movq %rcx, %rdx
xorl %r8d, %r8d
cmpq $0x1, %rdx
movl $0x0, %r10d
sbbq %rdx, %r10
movq (%rdi,%rcx,8), %r9
cmpq (%rdi,%r8,8), %r9
jge 0x3598
xorl %r11d, %r11d
movq -0x8(%rax,%r11,8), %rbx
movq %rbx, (%rax,%r11,8)
decq %r11
cmpq %r11, %r10
jne 0x3580
movslq %r9d, %r9
movq %r9, (%rax,%r11,8)
incq %r8
decq %rdx
cmpq %rcx, %r8
jne 0x3566
incq %rcx
addq $0x8, %rax
cmpq %rsi, %rcx
jne 0x3560
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_08/rightrot.c
// Function: printbin
void printbin(unsigned int x)
{
  unsigned int n = sizeof(unsigned int);

  printf("0b");

  int i;
  for (i = n * 8 - 1; i >= 0; --i)
  {
    (x & (unsigned int)pow(2, i)) ? putchar('1') : putchar('0');
  }

  putchar('\n');
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xe83(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1050
movl $0x1f, %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
callq 0x1030
cvttsd2si %xmm0, %rax
andl %ebx, %eax
cmpl $0x1, %eax
movl $0x31, %edi
sbbl $0x0, %edi
callq 0x1040
addl $-0x1, %ebp
jb 0x118d
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * ch;

	WARNP_INIT;

	/* Process arguments. */
	while ((ch = GETOPT(argc, argv)) != NULL) {
		GETOPT_SWITCH(ch) {
		GETOPT_OPT("-x"):
			exit(selftest());
		GETOPT_OPT("-t"):
			exit(elasticarray_perftest());
		GETOPT_DEFAULT:
			usage();
		}
	}

	usage();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x177c
callq 0x2b18
movl %ebp, %edi
movq %rbx, %rsi
callq 0x22e8
testq %rax, %rax
jne 0x1790
callq 0x1caf
movq %rax, %r14
leaq 0x499e(%rip), %r13      # 0x6138
leaq 0x1863(%rip), %r15      # 0x3004
leaq 0x185f(%rip), %r12      # 0x3007
movq $0x101, (%rsp)          # imm = 0x101
movq (%rsp), %rax
decq %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, (%r13)
je 0x17d9
movq %r14, %rdi
callq 0x2613
addq (%rsp), %rax
jmp 0x17e7
movq 0x10(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
cmpq $0x102, %rax            # imm = 0x102
je 0x183a
cmpq $0x104, %rax            # imm = 0x104
je 0x1825
cmpq $0x106, %rax            # imm = 0x106
je 0x1859
cmpl $0x0, (%r13)
jne 0x178b
cmpl $0x0, 0xc(%rsp)
jne 0x17c4
movl $0x106, %edi            # imm = 0x106
subq (%rsp), %rdi
callq 0x2827
movl $0x1, 0xc(%rsp)
jmp 0x17c4
cmpl $0x0, (%r13)
jne 0x187c
movl $0x104, %esi            # imm = 0x104
subq (%rsp), %rsi
movq %r12, %rdi
jmp 0x184d
cmpl $0x0, (%r13)
jne 0x1883
movl $0x102, %esi            # imm = 0x102
subq (%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x26d0
jmp 0x17c4
movl $0x1, (%r13)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x22e8
movq %rax, %r14
testq %rax, %rax
jne 0x17a8
jmp 0x178b
callq 0x1cf4
jmp 0x1888
callq 0x188f
movl %eax, %edi
callq 0x11b0
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_04/stack.c
// Function: swap
double pop(void)
{
  if (sp > 0)
  {
    return stack[--sp];
  }
  else
  {
    printf("Error: stack empty.\n");
  }

  return 0.0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x276a(%rip), %eax      # 0x4070
leaq 0x2773(%rip), %rbx      # 0x4080
testl %eax, %eax
jle 0x1920
decl %eax
movl %eax, 0x2757(%rip)      # 0x4070
movsd (%rbx,%rax,8), %xmm0
jmp 0x192f
leaq 0x77b(%rip), %rdi       # 0x20a2
callq 0x1030
xorps %xmm0, %xmm0
movl 0x273b(%rip), %eax      # 0x4070
testl %eax, %eax
jle 0x1948
decl %eax
movl %eax, 0x272f(%rip)      # 0x4070
movsd (%rbx,%rax,8), %xmm1
jmp 0x1963
leaq 0x753(%rip), %rdi       # 0x20a2
movsd %xmm0, 0x8(%rsp)
callq 0x1030
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
movslq 0x2706(%rip), %rax      # 0x4070
cmpq $0x63, %rax
jg 0x1980
leal 0x1(%rax), %ecx
movl %ecx, 0x26f7(%rip)      # 0x4070
movsd %xmm0, (%rbx,%rax,8)
jmp 0x1998
leaq 0x708(%rip), %rdi       # 0x208f
movsd %xmm1, 0x8(%rsp)
callq 0x1030
movsd 0x8(%rsp), %xmm1
movslq 0x26d1(%rip), %rax      # 0x4070
cmpq $0x63, %rax
jg 0x19b9
leal 0x1(%rax), %ecx
movl %ecx, 0x26c2(%rip)      # 0x4070
movsd %xmm1, (%rbx,%rax,8)
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6cf(%rip), %rdi       # 0x208f
addq $0x10, %rsp
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: handle_error
void handle_error(int e, struct base64_args *args){
    fprintf(stderr, "Error: %s\n", strerror(e));
    free(args->file);
    free(args);
    exit(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq 0x2d45(%rip), %rax      # 0x3ff8
movq (%rax), %r15
callq 0x1120
leaq 0xd42(%rip), %rsi       # 0x2004
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10d0
movq 0x18(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movl %r14d, %edi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: tripletoquad
char *tripletoquad(char *x, char *r){

    r[0] = lookup(x[0] >> 2);
    r[1] = lookup(((x[0] & 0b00000011) << 4) | ((x[1] & 0b11110000) >> 4));
    r[2] = lookup(((x[1] & 0b00001111) << 2) | ((x[2] & 0b11000000) >> 6));
    r[3] = lookup(x[2] & 0b00111111);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movb (%rdi), %cl
sarb $0x2, %cl
movq 0x2bd0(%rip), %rdx      # 0x40a8
movsbq %cl, %rcx
movb (%rdx,%rcx), %cl
movb %cl, (%rsi)
movzbl (%rdi), %ecx
shll $0x4, %ecx
andl $0x30, %ecx
movzbl 0x1(%rdi), %edx
shrl $0x4, %edx
orl %ecx, %edx
movq 0x2bae(%rip), %rcx      # 0x40a8
movb (%rcx,%rdx), %cl
movb %cl, 0x1(%rsi)
movzbl 0x1(%rdi), %ecx
andl $0xf, %ecx
movzbl 0x2(%rdi), %edx
shrl $0x6, %edx
leal (%rdx,%rcx,4), %ecx
movq 0x2b90(%rip), %rdx      # 0x40a8
movb (%rdx,%rcx), %cl
movb %cl, 0x2(%rsi)
movzbl 0x2(%rdi), %ecx
andl $0x3f, %ecx
movq 0x2b7c(%rip), %rdx      # 0x40a8
movb (%rdx,%rcx), %cl
movb %cl, 0x3(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: wrap_quad
void wrap_quad(char *quad, struct base64_args *args){
    static int printed = 0;
    for(int i = 0; i < 4; i++){
        if(printed++ == args->wrap && args->wrap != 0){
            putchar('\n');
            printed = 1;
        }
        putchar(quad[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x2b66(%rip), %rax      # 0x40b4
leal 0x1(%rax), %ecx
movl %ecx, 0x2b5d(%rip)      # 0x40b4
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
setne %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x157f
movl $0xa, %edi
callq 0x1040
movl $0x1, 0x2b35(%rip)      # 0x40b4
movsbl (%r14,%r15), %edi
callq 0x1040
incq %r15
cmpq $0x4, %r15
jne 0x1547
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: encode_buffer
void encode_buffer(ssize_t size, char *buf, struct base64_args *args){
    //assert(buf[2] == '\n');
    size_t last_triplet = size - size % 3;
    size_t i = 0;
    char *quad = calloc(4, sizeof(char));
    for(; i < last_triplet; i += 3){
        tripletoquad(&buf[i], quad);
        wrap_quad(quad, args);
        memset(quad, 0, 4);
    }
    if(i < size){
        char *triplet = calloc(3, sizeof(char));
        size_t diff = size - i;
        triplet[0] = buf[i];
        if(diff == 2){
            triplet[1] = buf[i+1];
            tripletoquad(triplet, quad);
            quad[3] = '=';
        }
        else if(diff == 3 || diff == 1){
            tripletoquad(triplet, quad);
            quad[2] = '=';
            quad[3] = '=';
        }
        wrap_quad(quad, args);
        if(args->wrap != 0){
            putchar('\n');
        }
    }
    free(quad);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rax
movabsq $0x5555555555555556, %rcx # imm = 0x5555555555555556
movq %rdi, -0x30(%rbp)
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
addq %rdx, %rax
leaq (%rax,%rax,2), %r15
movl $0x4, %edi
movl $0x1, %esi
callq 0x10b0
movq %rax, %r14
xorl %r13d, %r13d
testq %r15, %r15
je 0x1614
leaq (%r12,%r13), %rdi
movq %r14, %rsi
callq 0x14c5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1534
movl $0x0, (%r14)
addq $0x3, %r13
cmpq %r15, %r13
jb 0x15ed
movq -0x30(%rbp), %r15
subq %r13, %r15
jbe 0x1688
movl $0x3, %edi
movl $0x1, %esi
callq 0x10b0
movb (%r12,%r13), %cl
movb %cl, (%rax)
cmpq $0x2, %r15
jne 0x164d
movb 0x1(%r12,%r13), %cl
movb %cl, 0x1(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x14c5
jmp 0x1667
andq $-0x3, %r15
cmpq $0x1, %r15
jne 0x166c
movq %rax, %rdi
movq %r14, %rsi
callq 0x14c5
movb $0x3d, 0x2(%r14)
movb $0x3d, 0x3(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1534
cmpq $0x0, 0x8(%rbx)
je 0x1688
movl $0xa, %edi
callq 0x1040
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: encode_file
void encode_file(struct base64_args *args){
    char *buf = calloc(4096, sizeof(char));
    int fd = open(args->file, O_RDONLY);
    if(fd == -1){
        handle_error(errno, args);
    }

    ssize_t r = 0;
    for(r = read(fd, buf, 4095); r > 0; r = read(fd, buf, 4095)){
        encode_buffer(r, buf, args);
    }

    free(buf);
    close(fd);

    if(r == -1){
        handle_error(errno, args);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10b0
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10f0
cmpl $-0x1, %eax
je 0x171a
movl %eax, %r15d
jmp 0x16e3
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x159d
movl $0xfff, %edx            # imm = 0xFFF
movl %r15d, %edi
movq %r14, %rsi
callq 0x10a0
movq %rax, %r12
testq %rax, %rax
jg 0x16d5
movq %r14, %rdi
callq 0x1030
movl %r15d, %edi
callq 0x1090
cmpq $-0x1, %r12
je 0x171a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050
movl (%rax), %edi
movq %rbx, %rsi
callq 0x129c
// File: /workspace/github_c_makefile_star2_O1/ikbenlike[P]nngutils/src/base64.c
// Function: main
int main(int argc, char **argv){
    struct base64_args *args = calloc(1, sizeof(struct base64_args));
    parse_args(args, argc, argv);

    /*printf("decode: %d\n", args->decode);
    printf("ignore garbage: %d\n", args->ignore_garbage);
    printf("wrap: %d\n", args->wrap);
    printf("help: %d\n", args->help);
    printf("version: %d\n", args->version);
    printf("file: %s\n", args->file);*/

    if(args->file != NULL && strcmp(args->file, "-") && args->decode == false){
        encode_file(args);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x12e8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x177f
leaq 0x9b5(%rip), %rsi       # 0x211e
callq 0x10c0
testl %eax, %eax
je 0x177f
cmpb $0x0, (%rbx)
jne 0x177f
movq %rbx, %rdi
callq 0x169e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phoboslab[P]pl_mpeg/pl_mpeg_extract_frames.c
// Function: write_bmp
int write_bmp(const char *path, int width, int height, uint8_t *pixels) {
	FILE *fh = fopen(path, "wb");
	if (!fh) {
		return 0;
	}

	int padded_width = (width * 3 + 3) & (~3);
	int padding = padded_width - (width * 3);
	int data_size = padded_width * height;
	int file_size = 54 + data_size;

	fwrite("BM", 1, 2, fh);
	fwrite(&file_size, 1, 4, fh);
	fwrite("\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00", 1, 12, fh);
	fwrite(&width, 1, 4, fh);
	fwrite(&height, 1, 4, fh);
	fwrite("\x01\x00\x18\x00\x00\x00\x00\x00", 1, 8, fh); // planes, bpp, compression
	fwrite(&data_size, 1, 4, fh);
	fwrite("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 1, 16, fh);

	for (int y = height - 1; y >= 0; y--) {
		fwrite(pixels + y * width * 3, 3, width, fh);
		fwrite("\x00\x00\x00\x00", 1, padding, fh);
	}
	fclose(fh);
	return file_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movl %esi, (%rsp)
movl %edx, 0xc(%rsp)
leaq 0x1d36(%rip), %rsi      # 0x9533
callq 0x10f0
testq %rax, %rax
je 0x7970
movq %rax, %r14
leal (%r15,%r15,2), %r12d
addl $0x3, %r12d
andl $-0x4, %r12d
imull %r12d, %ebp
leaq 0x8(%rsp), %rax
movl %ebp, (%rax)
addl $0x36, %ebp
leaq 0x4(%rsp), %r13
movl %ebp, (%r13)
leaq 0x1cfe(%rip), %rdi      # 0x9536
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
callq 0x1110
movl $0x1, %esi
movl $0x4, %edx
movq %r13, %rdi
movq %r14, %rcx
callq 0x1110
leaq 0x1a0a(%rip), %rdi      # 0x9270
movl $0x1, %esi
movl $0xc, %edx
movq %r14, %rcx
callq 0x1110
movq %rsp, %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x1110
leaq 0xc(%rsp), %r13
movl $0x1, %esi
movl $0x4, %edx
movq %r13, %rdi
movq %r14, %rcx
callq 0x1110
leaq 0x19cf(%rip), %rdi      # 0x927d
movl $0x1, %esi
movl $0x8, %edx
movq %r14, %rcx
callq 0x1110
movl $0x1, %esi
movl $0x4, %edx
leaq 0x8(%rsp), %rdi
movq %r14, %rcx
callq 0x1110
leaq 0x19a8(%rip), %rdi      # 0x9286
movl $0x1, %esi
movl $0x10, %edx
movq %r14, %rcx
callq 0x1110
movslq (%r13), %rax
testq %rax, %rax
jle 0x7962
movq %rbx, %rdx
leal (%r15,%r15,2), %ecx
subl %ecx, %r12d
movslq (%rsp), %r15
movslq %r12d, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rbp
incq %rbp
leal -0x1(%rax), %ebx
leal (%r15,%r15,2), %r13d
imull %r13d, %ebx
movslq %ebx, %rbx
leaq (%rdx,%rbx), %rdi
movl $0x3, %esi
movq %rdx, %r12
movq %r15, %rdx
movq %r14, %rcx
callq 0x1110
movl $0x1, %esi
leaq 0x1951(%rip), %rdi      # 0x9297
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x1110
movq %r12, %rdx
decq %rbp
subl %r13d, %ebx
cmpq $0x1, %rbp
jg 0x7920
movq %r14, %rdi
callq 0x1060
movl 0x4(%rsp), %eax
jmp 0x7972
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phoboslab[P]pl_mpeg/pl_mpeg_extract_frames.c
// Function: main
int main(int argc, char *argv[]) {
	if (argc < 2) {
		printf("Usage: pl_mpeg_extract_frames <file.mpg>\n");
		return 1;
	}

	plm_t *plm = plm_create_with_filename(argv[1]);
	if (!plm) {
		printf("Couldn't open file %s\n", argv[1]);
		return 1;
	}

	plm_set_audio_enabled(plm, FALSE);
	
	int w = plm_get_width(plm);
	int h = plm_get_height(plm);
	uint8_t *pixels = (uint8_t *)malloc(w * h * 3);
	
	char bmp_name[16];
	plm_frame_t *frame = NULL;

	for (int i = 1; frame = plm_decode_video(plm); i++) {
		plm_frame_to_bgr(frame, pixels, w * 3); // BMP expects BGR ordering

		sprintf(bmp_name, "%06d.bmp", i);
		printf("Writing %s\n", bmp_name);
		write_bmp(bmp_name, w, h, pixels);
	}
	
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jg 0x79a5
leaq 0x1bca(%rip), %rdi      # 0x9565
callq 0x1040
jmp 0x7a7d
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x121c
testq %rax, %rax
je 0x7a6b
movq %rax, %r14
xorl %eax, %eax
movl %eax, 0x38(%r14)
movl %eax, 0x40(%r14)
movq %r14, %rdi
callq 0x1dac
movl %eax, %ebx
movq %r14, %rdi
callq 0x1df7
movl %eax, %ebp
movq %rbx, %rax
movq %rbx, 0x8(%rsp)
imull %ebp, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdi
callq 0x10b0
movq %rax, %r12
movq %r14, %rdi
callq 0x25a9
testq %rax, %rax
je 0x7a67
movq 0x8(%rsp), %rcx
leal (%rcx,%rcx,2), %r13d
movl $0x1, %ebx
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x50cd
movq %r15, %rdi
leaq 0x1b24(%rip), %rsi      # 0x9550
movl %ebx, %edx
xorl %eax, %eax
callq 0x1100
leaq 0x1b1d(%rip), %rdi      # 0x9559
movq %r15, %rsi
xorl %eax, %eax
callq 0x1070
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x77d9
incl %ebx
movq %r14, %rdi
callq 0x25a9
testq %rax, %rax
jne 0x7a14
xorl %eax, %eax
jmp 0x7a82
movq 0x8(%rbx), %rsi
leaq 0x1ac3(%rip), %rdi      # 0x9539
xorl %eax, %eax
callq 0x1070
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nemequ[P]safe-math/munit/munit.c
// Function: munit_rand_double
double
munit_rand_double(void) {
  uint32_t old, state;
  double retval = 0.0;

  do {
    state = old = munit_atomic_load(&munit_rand_state);

    /* See http://mumble.net/~campbell/tmp/random_real.c for how to do
     * this right.  Patches welcome if you feel that this is too
     * biased. */
    do {
      retval = munit_rand_state_uint32(&state) / ((double) UINT32_MAX);
    } while (MUNIT_UNLIKELY(MUNIT_UNLIKELY(retval >= 1.0) || MUNIT_UNLIKELY(retval <= 0.0)));
  } while (!munit_atomic_cas(&munit_rand_state, &old, state));

  return retval;
}

// Assembly:
movsd 0x3410(%rip), %xmm1     # 0x66c8
movsd 0x3410(%rip), %xmm2     # 0x66d0
xorpd %xmm3, %xmm3
movl 0x8426(%rip), %eax      # 0xb6f0
movl %eax, %ecx
movl %ecx, %edx
shrl $0x1c, %ecx
addb $0x4, %cl
movl %edx, %esi
shrl %cl, %esi
xorl %edx, %esi
imull $0x2c9277b5, %edx, %ecx # imm = 0x2C9277B5
imull $0x108ef2d9, %esi, %edx # imm = 0x108EF2D9
movl %edx, %esi
shrl $0x16, %esi
xorl %edx, %esi
cvtsi2sd %rsi, %xmm0
addl $0x6c1, %ecx            # imm = 0x6C1
divsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0x32cc
ucomisd %xmm0, %xmm3
jae 0x32cc
lock
cmpxchgl %ecx, 0x83e0(%rip)      # 0xb6f0
jne 0x32c4
retq
// File: /workspace/github_c_makefile_star2_O1/nemequ[P]safe-math/test.c
// Function: test_safe_generic
static MunitResult
test_safe_generic(const MunitParameter params[], void* user_data) {
  (void) params;
  (void) user_data;
  unsigned long long a = 1, b = 1, res;

  do {
    if (!safe_add(&res, a, b)) {
      munit_logf(MUNIT_LOG_DEBUG, "%llu + %llu overflows", a, b);
      break;
    }

    munit_logf(MUNIT_LOG_DEBUG, "%llu + %llu = %llu", a, b, res);
    a = b;
    b = res;
  } while (1);

  return MUNIT_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x2, %r13d
movl $0x1, %ebx
leaq 0x2ea0(%rip), %r15      # 0x6558
leaq 0x2ff5(%rip), %r12      # 0x66b4
movl $0x1, %r14d
movq %r14, %r8
movq %rbx, %r14
movq %r13, %rbx
movq %r13, (%rsp)
xorl %edi, %edi
movq %r15, %rsi
movl $0x11, %edx
movq %r12, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x3720
addq %r14, %r13
jae 0x36c5
leaq 0x2e63(%rip), %rsi      # 0x6558
leaq 0x2fa2(%rip), %rcx      # 0x669e
xorl %edi, %edi
movl $0xd, %edx
movq %r14, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x3720
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nemequ[P]safe-math/munit/munit.c
// Function: munit_logf_ex
void
munit_logf_ex(MunitLogLevel level, const char* filename, int line, const char* format, ...) {
  va_list ap;

  va_start(ap, format);
  munit_logf_exv(level, stderr, filename, line, format, ap);
  va_end(ap);

  if (level >= munit_log_level_fatal) {
#if defined(MUNIT_THREAD_LOCAL)
    if (munit_error_jmp_buf_valid)
      longjmp(munit_error_jmp_buf, 1);
#endif
    abort();
  }
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %r10
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %ebx
leaq 0x20(%rsp), %rsi
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x377a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r9
movq %rsi, 0x10(%r9)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r9)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%r9)
movq 0x684f(%rip), %rax      # 0x9ff0
movq (%rax), %rsi
movq %r10, %r8
callq 0x37ed
cmpl $0x2, %ebx
ja 0x37c3
testb $0x1, 0x7f40(%rip)      # 0xb6f8
jne 0x37c3
addq $0xd0, %rsp
popq %rbx
retq
cmpb $0x1, %fs:-0xe0
jne 0x37e8
movq %fs:0x0, %rax
leaq -0xd0(%rax), %rdi
movl $0x1, %esi
callq 0x3250
callq 0x3040