LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_is_the_biggest
int		ft_is_the_biggest(long *tab, size_t size, long big)
{
	size_t	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2c6e
cmpq $0x1, -0x18(%rbp)
jne 0x2c77
movl $0x1, -0x4(%rbp)
jmp 0x2cb9
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2cb2
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jle 0x2ca4
movl $0x0, -0x4(%rbp)
jmp 0x2cb9
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c7f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_tool_push_swap.c
// Function: ft_is_the_smallest
int		ft_is_the_smallest(long *tab, size_t size, long small)
{
	size_t	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2cde
cmpq $0x1, -0x18(%rbp)
jne 0x2ce7
movl $0x1, -0x4(%rbp)
jmp 0x2d29
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2d22
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jge 0x2d14
movl $0x0, -0x4(%rbp)
jmp 0x2d29
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2cef
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2d73
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
jmp 0x2dd0
jmp 0x2d75
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2da0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d75
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5260
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1050
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2e26
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
jmp 0x2f12
jmp 0x2e28
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x2e50
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2e28
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5260
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x12c, -0x14(%rbp)     # imm = 0x12C
jl 0x2e8f
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl -0x30(%rbp), %eax
addl %edx, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ec8
cmpl $0xc, -0x14(%rbp)
jl 0x2eb8
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x34(%rbp), %eax
addl %edx, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ec6
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
jmp 0x2ec8
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2ed9
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x2ef1
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x2efc
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x306a(%rip), %rsi      # 0x6028
callq 0x4890
cmpl $0x0, %eax
je 0x3005
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3048(%rip), %rsi      # 0x6028
callq 0x4890
cmpl $0x0, %eax
je 0x3005
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3170
movl %eax, -0x1c(%rbp)
jmp 0x3158
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3013(%rip), %rsi      # 0x602b
callq 0x4890
cmpl $0x0, %eax
je 0x305f
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2ff1(%rip), %rsi      # 0x602b
callq 0x4890
cmpl $0x0, %eax
je 0x305f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3170
movl %eax, -0x1c(%rbp)
jmp 0x3156
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2fa3(%rip), %rsi      # 0x6015
callq 0x4890
cmpl $0x0, %eax
jne 0x3099
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2f85(%rip), %rsi      # 0x6014
callq 0x4890
cmpl $0x0, %eax
je 0x30d8
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4890
cmpl $0x0, %eax
je 0x30d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3320
movl %eax, -0x1c(%rbp)
jmp 0x3154
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2f2e(%rip), %rsi      # 0x6019
callq 0x4890
cmpl $0x0, %eax
jne 0x3112
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x2f10(%rip), %rsi      # 0x6018
callq 0x4890
cmpl $0x0, %eax
je 0x3152
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4890
cmpl $0x0, %eax
je 0x3152
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x3320
movl %eax, -0x1c(%rbp)
jmp 0x3154
jmp 0x3156
jmp 0x3158
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x34e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x3254
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x2e76(%rip), %rsi      # 0x6032
leaq 0x2e6b(%rip), %rax      # 0x602e
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x31ff
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x320f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x3233
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x3243
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x31a1
jmp 0x3256
cmpl $0x0, -0x24(%rbp)
jge 0x3309
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x2dbd(%rip), %rsi      # 0x602e
leaq 0x2dba(%rip), %rax      # 0x6032
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x32b4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x32c4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x32e8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x32f8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3256
movl -0x20(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4890
cmpl $0x0, %eax
je 0x3380
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x334e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x33b1
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jg 0x33d6
cmpl $0x0, -0x1c(%rbp)
jne 0x3405
movl -0x24(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jle 0x3405
cmpl $0x0, -0x1c(%rbp)
je 0x33ee
movslq -0x24(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x28(%rcx), %rax
movq %rax, -0x40(%rbp)
jmp 0x33fe
movslq -0x24(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x20(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x3412
movl $0x0, -0x20(%rbp)
jmp 0x3414
cmpl $0x0, -0x24(%rbp)
jge 0x34c8
cmpl $0x0, -0x1c(%rbp)
je 0x3470
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2bdf(%rip), %rsi      # 0x6019
callq 0x4890
movq -0x48(%rbp), %rdi
movl %eax, %ecx
leaq 0x2beb(%rip), %rsi      # 0x6037
leaq 0x2be3(%rip), %rax      # 0x6036
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x34ba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x2b8f(%rip), %rsi      # 0x6015
callq 0x4890
movq -0x50(%rbp), %rdi
movl %eax, %ecx
leaq 0x2ba4(%rip), %rsi      # 0x603c
leaq 0x2b9c(%rip), %rax      # 0x603b
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl $0x1, %edx
callq 0x49f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3414
movl -0x20(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_push_swap/ft_post_process.c
// Function: ft_how_push
static int	ft_how_push(char **tab, int which, int *tmp)
{
	int		i;

	i = 0;
	while ((ft_strequ(tab[i], which ? "pb" : "pa")))
	{
		i++;
		(*tmp)++;
	}
	while ((ft_strequ(tab[i], which ? "pa" : "pb")))
	{
		i++;
		(*tmp)--;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %ecx
leaq 0x2b18(%rip), %rsi      # 0x6028
leaq 0x2b14(%rip), %rax      # 0x602b
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x4890
cmpl $0x0, %eax
je 0x353e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x34fa
jmp 0x3540
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %ecx
leaq 0x2ad5(%rip), %rsi      # 0x602b
leaq 0x2acb(%rip), %rax      # 0x6028
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x4890
cmpl $0x0, %eax
je 0x3584
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x3540
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x35fc
cmpl $0x0, -0x24(%rbp)
jne 0x35cd
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jl 0x35e5
cmpl $0x0, -0x24(%rbp)
je 0x35ee
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jl 0x35ee
movl $0x1, -0x4(%rbp)
jmp 0x3603
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x35ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x20(%rax)
jbe 0x3642
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x27c0
cmpl $0x0, %eax
je 0x3644
jmp 0x36a3
movq -0x8(%rbp), %rax
cmpq $0x2, 0x20(%rax)
jne 0x3698
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x3696
movq -0x8(%rbp), %rsi
leaq 0x776(%rip), %rdi       # 0x3e00
leaq 0x2979(%rip), %rdx      # 0x600a
callq 0x2f20
jmp 0x36a1
movq -0x8(%rbp), %rdi
callq 0x36b0
jmp 0x36a3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jbe 0x3926
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x27c0
cmpl $0x0, %eax
je 0x3928
jmp 0x3989
movq -0x8(%rbp), %rax
cmpq $0x2, 0x28(%rax)
jne 0x397e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq $0x2, %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x397c
movq -0x8(%rbp), %rsi
leaq 0x490(%rip), %rdi       # 0x3e00
leaq 0x2696(%rip), %rdx      # 0x600d
callq 0x2f20
jmp 0x3987
movq -0x8(%rbp), %rdi
callq 0x3990
jmp 0x3989
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5159
jmp 0x51bd
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jae 0x51bd
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x51bb
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
cmpl (%rcx,%rdx,4), %eax
jge 0x51b9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x51d0
jmp 0x517b
jmp 0x5161
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insert_elem
static void	ft_insert_elem(int *tab, size_t i, size_t j)
{
	size_t	n;
	int		tmp;

	n = 0;
	tmp = tab[i];
	while (n < (i - (j - 1)))
	{
		tab[i - n] = tab[i - (n + 1)];
		n++;
	}
	tab[i - n] = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x5241
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
subq %rdx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x51f6
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5279
jmp 0x52df
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
jae 0x52df
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x52dd
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
cmpq (%rcx,%rdx,8), %rax
jge 0x52db
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x52f0
jmp 0x529b
jmp 0x5281
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/sort/ft_insertsort_integer.c
// Function: ft_insert_elem_long
static void	ft_insert_elem_long(long *tab, size_t i, size_t j)
{
	size_t	n;
	int		tmp;

	n = 0;
	tmp = tab[i];
	while (n < (i - (j - 1)))
	{
		tab[i - n] = tab[i - (n + 1)];
		n++;
	}
	tab[i - n] = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x5364
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
subq %rdx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5317
movslq -0x24(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_08/rightrot.c
// Function: main
int main(void)
{
  unsigned int x = 0b11110101;

  printbin(x);
  printbin(rightrot(x, 5));

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0xf5, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x11a0
movl -0x8(%rbp), %edi
movl $0x5, %esi
callq 0x1230
movl %eax, %edi
callq 0x11a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x4, -0x8(%rbp)
leaq 0xe57(%rip), %rdi       # 0x2010
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %eax
shll $0x3, %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x121a
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0xe23(%rip), %xmm0      # 0x2008
callq 0x1040
movl -0x10(%rbp), %eax
cvttsd2si %xmm0, %rcx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1205
movl $0x31, %edi
callq 0x1030
jmp 0x120f
movl $0x30, %edi
callq 0x1030
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11cc
movl $0xa, %edi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_08/rightrot.c
// Function: rightrot
unsigned int rightrot(unsigned int x, unsigned int n)
{
  unsigned int msb_1 = ~(~(unsigned)0 >> 1);

  int i;
  for (i = 0; i < n; ++i)
  {
    if (x & 1)
    {
      x = (x >> 1) | msb_1;
    }
    else
    {
      x = (x >> 1);
    }
  }

  return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x80000000, -0xc(%rbp) # imm = 0x80000000
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x127d
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1268
movl -0x4(%rbp), %eax
shrl %eax
orl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1270
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
jmp 0x1272
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1248
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12dc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x37f0
jmp 0x12de
jmp 0x12e0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x27c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1459
movq $0x101, -0x20(%rbp)     # imm = 0x101
movq -0x20(%rbp), %rax
decq %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
leaq 0x4(%rip), %rax         # 0x131f
movq %rax, -0x38(%rbp)
leaq 0x5df2(%rip), %rax      # 0x7118
cmpl $0x0, (%rax)
je 0x1341
movq -0x18(%rbp), %rdi
callq 0x2e80
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x1354
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x102, %rax            # imm = 0x102
je 0x1389
jmp 0x1366
movq -0x48(%rbp), %rax
subq $0x104, %rax            # imm = 0x104
je 0x13ca
jmp 0x1374
movq -0x48(%rbp), %rax
subq $0x106, %rax            # imm = 0x106
je 0x1408
jmp 0x1417
leaq 0x5d88(%rip), %rax      # 0x7118
cmpl $0x0, (%rax)
je 0x1397
jmp 0x13be
movq -0x20(%rbp), %rax
movl $0x102, %esi            # imm = 0x102
subq %rax, %rsi
leaq 0x2c5a(%rip), %rdi      # 0x4004
xorl %edx, %edx
callq 0x2fd0
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1467
callq 0x1470
movl %eax, %edi
callq 0x1180
leaq 0x5d47(%rip), %rax      # 0x7118
cmpl $0x0, (%rax)
je 0x13d8
jmp 0x13fc
movq -0x20(%rbp), %rax
movl $0x104, %esi            # imm = 0x104
subq %rax, %rsi
leaq 0x2c1c(%rip), %rdi      # 0x4007
xorl %edx, %edx
callq 0x2fd0
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1467
callq 0x1d00
movl %eax, %edi
callq 0x1180
leaq 0x5d09(%rip), %rax      # 0x7118
movl $0x1, (%rax)
jmp 0x1454
leaq 0x5cfa(%rip), %rax      # 0x7118
cmpl $0x0, (%rax)
je 0x1425
jmp 0x144f
movl -0x2c(%rbp), %eax
cmpl $0x0, %eax
jne 0x1445
movq -0x20(%rbp), %rax
movl $0x106, %edi            # imm = 0x106
subq %rax, %rdi
callq 0x3320
movl $0x1, -0x2c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x1467
callq 0x14d0
jmp 0x12e0
callq 0x14d0
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rax
jmpq *%rax
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: selftest
static int
selftest(void)
{

	/* Elasticarray with simple integers. */
	if (test_intlist())
		goto err0;

	/* Elasticarray with dynamically-allocated structures. */
	if (test_dynlist())
		goto err0;

	/* Elasticarray with pointers. */
	if (test_pointerlist())
		goto err0;

	/* Elasticarray with size 0. */
	if (test_emptylist())
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1510
cmpl $0x0, %eax
je 0x1484
jmp 0x14b1
callq 0x15f0
cmpl $0x0, %eax
je 0x1490
jmp 0x14b1
callq 0x1720
cmpl $0x0, %eax
je 0x149c
jmp 0x14b1
callq 0x1880
cmpl $0x0, %eax
je 0x14a8
jmp 0x14b1
movl $0x0, -0x4(%rbp)
jmp 0x14b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: test_intlist
static int
test_intlist(void)
{
	INTLIST list;
	size_t i;
	int x;

	/* Allocate list. */
	if ((list = intlist_init(0)) == NULL)
		goto err0;

	/* Append some values. */
	for (i = 0; i < NUM_ELEM; i++) {
		x = (int)i;
		if (intlist_append(list, &x, 1))
			goto err1;
	}

	/* Use the list. */
	for (i = 0; i < intlist_getsize(list); i++) {
		x = *intlist_get(list, i);
		printf("int:\t%d\n", x);
	}

	/* Free memory. */
	intlist_free(list);

	/* Success! */
	return (0);

err1:
	intlist_free(list);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1930
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1530
jmp 0x15e0
movq $0x0, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x156f
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x1, %edx
callq 0x1960
cmpl $0x0, %eax
je 0x155f
jmp 0x15d7
jmp 0x1561
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1538
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1990
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x15c5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19b0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x2a5a(%rip), %rdi      # 0x400a
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1577
movq -0x10(%rbp), %rdi
callq 0x19e0
movl $0x0, -0x4(%rbp)
jmp 0x15e7
movq -0x10(%rbp), %rdi
callq 0x19e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: test_dynlist
static int
test_dynlist(void)
{
	DYNLIST list;
	struct dyn d;
	size_t i;

	/* Allocate list. */
	if ((list = dynlist_init(0)) == NULL)
		goto err0;

	/* Append some values. */
	for (i = 0; i < NUM_ELEM; i++) {
		/* Dynamically allocate part of structure. */
		if ((d.arr = malloc(sizeof(int))) == NULL)
			goto err1;
		d.arr[0] = (int)i;

		/* Append item. */
		if (dynlist_append(list, &d, 1))
			goto err2;
	}

	/* Use the list. */
	for (i = 0; i < dynlist_getsize(list); i++) {
		d = *dynlist_get(list, i);
		printf("dyn:\t%d\n", d.arr[0]);
	}

	/* Free memory. */
	dynlist_iter(list, free_dyn);
	dynlist_free(list);

	/* Success! */
	return (0);

err2:
	free(d.arr);
err1:
	dynlist_iter(list, free_dyn);
	dynlist_free(list);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1a00
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1610
jmp 0x170f
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0x1670
movl $0x4, %edi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1638
jmp 0x16f6
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1a30
cmpl $0x0, %eax
je 0x1660
jmp 0x16ed
jmp 0x1662
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1618
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a60
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x16cb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a80
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x295d(%rip), %rdi      # 0x4013
movb $0x0, %al
callq 0x10c0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1678
movq -0x10(%rbp), %rdi
leaq 0x44a(%rip), %rsi       # 0x1b20
callq 0x1ab0
movq -0x10(%rbp), %rdi
callq 0x1b40
movl $0x0, -0x4(%rbp)
jmp 0x1716
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
leaq 0x41f(%rip), %rsi       # 0x1b20
callq 0x1ab0
movq -0x10(%rbp), %rdi
callq 0x1b40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: test_pointerlist
static int
test_pointerlist(void)
{
	POINTERLIST list;
	struct dyn * p;
	size_t i;

	/* Allocate list. */
	if ((list = pointerlist_init(0)) == NULL)
		goto err0;

	/* Append some values. */
	for (i = 0; i < NUM_ELEM; i++) {
		/* Dynamically allocate item to append. */
		if ((p = malloc(sizeof(struct dyn))) == NULL)
			goto err1;
		if ((p->arr = malloc(sizeof(int))) == NULL)
			goto err2;
		p->arr[0] = (int)i;

		/* Append pointer to structure. */
		if (pointerlist_append(list, &p, 1))
			goto err3;
	}

	/* Use the list. */
	for (i = 0; i < pointerlist_getsize(list); i++) {
		p = *pointerlist_get(list, i);
		printf("pointer:\t%d\n", p->arr[0]);
	}

	/* Free memory. */
	pointerlist_iter(list, free_p_dyn);
	pointerlist_free(list);

	/* Success! */
	return (0);

err3:
	free(p->arr);
err2:
	free(p);
err1:
	pointerlist_iter(list, free_p_dyn);
	pointerlist_free(list);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1b60
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1740
jmp 0x186d
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0x17bf
movl $0x8, %edi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1768
jmp 0x1854
movl $0x4, %edi
callq 0x1120
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x1784
jmp 0x184b
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1b90
cmpl $0x0, %eax
je 0x17af
jmp 0x183f
jmp 0x17b1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1748
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x181d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1be0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %esi
leaq 0x2814(%rip), %rdi      # 0x401c
movb $0x0, %al
callq 0x10c0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17c7
movq -0x10(%rbp), %rdi
leaq 0x458(%rip), %rsi       # 0x1c80
callq 0x1c10
movq -0x10(%rbp), %rdi
callq 0x1cb0
movl $0x0, -0x4(%rbp)
jmp 0x1874
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
leaq 0x421(%rip), %rsi       # 0x1c80
callq 0x1c10
movq -0x10(%rbp), %rdi
callq 0x1cb0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/main.c
// Function: test_emptylist
static int
test_emptylist(void)
{
	INTLIST list;
	int x;		/* Not set to a value. */

	/* Allocate list and check size. */
	if ((list = intlist_init(0)) == NULL)
		goto err0;
	if (intlist_getsize(list) != 0)
		goto err1;

	/* Resize to 0 (should be a no-op) and check size. */
	if (intlist_resize(list, 0))
		goto err1;
	if (intlist_getsize(list) != 0)
		goto err1;

	/* Append nothing.  The value of x should not be read.  Check size. */
	if (intlist_append(list, &x, 0))
		goto err1;
	if (intlist_getsize(list) != 0)
		goto err1;

	/* Free memory. */
	intlist_free(list);

	/* Success! */
	return (0);

err1:
	intlist_free(list);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1930
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x189d
jmp 0x1917
movq -0x10(%rbp), %rdi
callq 0x1990
cmpq $0x0, %rax
je 0x18ae
jmp 0x190e
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1cd0
cmpl $0x0, %eax
je 0x18c2
jmp 0x190e
movq -0x10(%rbp), %rdi
callq 0x1990
cmpq $0x0, %rax
je 0x18d3
jmp 0x190e
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1960
cmpl $0x0, %eax
je 0x18eb
jmp 0x190e
movq -0x10(%rbp), %rdi
callq 0x1990
cmpq $0x0, %rax
je 0x18fc
jmp 0x190e
movq -0x10(%rbp), %rdi
callq 0x19e0
movl $0x0, -0x4(%rbp)
jmp 0x191e
movq -0x10(%rbp), %rdi
callq 0x19e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/elasticarray/elasticarray_perftest.c
// Function: elasticarray_perftest
int
elasticarray_perftest(void)
{

	/* Benchmark elasticarray_append() and elasticarray_shrink(). */
	if (check_append_shrink())
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1d30
cmpl $0x0, %eax
je 0x1d14
jmp 0x1d1d
movl $0x0, -0x4(%rbp)
jmp 0x1d24
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_04/stack.c
// Function: main
int main(void)
{
  int type;
  double op2;
  char s[MAXOP];

  while ((type = getop(s)) != EOF)
  {
    switch (type)
    {
    case NUMBER:
      push(atof(s));
      break;

    case '+':
      push(pop() + pop());
      break;

    case '-':
      op2 = pop();
      push(pop() - op2);
      break;

    case '*':
      push(pop() * pop());
      break;

    case '/':
      op2 = pop();

      if (op2 != 0.0)
      {
        push(pop() / op2);
      }
      else
      {
        printf("Error: zero divisor.\n");
      }

      break;

    case '%':
      op2 = pop();

      if (op2 != 0.0)
      {
        push((int)pop() % (int)op2);
      }
      else
      {
        printf("Error: zero divisor.\n");
      }
      break;

    case 'h':
      view_head();
      break;

    case 'd':
      duplicate();
      break;

    case 's':
      swap();
      break;

    case 'c':
      clear();
      break;

    case '\n':
      printf("result: %.8g\n", pop());
      break;

    default:
      printf("Error: unknown command %s.\n", s);
      break;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1330
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x131d
movl -0x8(%rbp), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x88(%rbp)
subl $0x69, %eax
ja 0x1306
movq -0x88(%rbp), %rax
leaq 0xe47(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x80(%rbp), %rdi
callq 0x1030
callq 0x1500
jmp 0x1318
callq 0x1560
movsd %xmm0, -0x90(%rbp)
callq 0x1560
movaps %xmm0, %xmm1
movsd -0x90(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x1500
jmp 0x1318
callq 0x1560
movsd %xmm0, -0x10(%rbp)
callq 0x1560
subsd -0x10(%rbp), %xmm0
callq 0x1500
jmp 0x1318
callq 0x1560
movsd %xmm0, -0x98(%rbp)
callq 0x1560
movaps %xmm0, %xmm1
movsd -0x98(%rbp), %xmm0
mulsd %xmm1, %xmm0
callq 0x1500
jmp 0x1318
callq 0x1560
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1269
jp 0x1269
jmp 0x127a
callq 0x1560
divsd -0x10(%rbp), %xmm0
callq 0x1500
jmp 0x1288
leaq 0xf2b(%rip), %rdi       # 0x21ac
movb $0x0, %al
callq 0x1040
jmp 0x1318
callq 0x1560
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x12a9
jp 0x12a9
jmp 0x12c5
callq 0x1560
cvttsd2si %xmm0, %eax
cvttsd2si -0x10(%rbp), %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
callq 0x1500
jmp 0x12d3
leaq 0xee0(%rip), %rdi       # 0x21ac
movb $0x0, %al
callq 0x1040
jmp 0x1318
callq 0x15c0
jmp 0x1318
callq 0x1610
jmp 0x1318
callq 0x1640
jmp 0x1318
callq 0x1680
jmp 0x1318
callq 0x1560
leaq 0xec5(%rip), %rdi       # 0x21c2
movb $0x1, %al
callq 0x1040
jmp 0x1318
leaq -0x80(%rbp), %rsi
leaq 0xebf(%rip), %rdi       # 0x21d0
movb $0x0, %al
callq 0x1040
jmp 0x1182
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_04/stack.c
// Function: pop
double pop(void)
{
  if (sp > 0)
  {
    return stack[--sp];
  }
  else
  {
    printf("Error: stack empty.\n");
  }

  return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x2af1(%rip)      # 0x4060
jle 0x1596
movl 0x2ae9(%rip), %eax      # 0x4060
addl $-0x1, %eax
movl %eax, 0x2ae0(%rip)      # 0x4060
movslq %eax, %rcx
leaq 0x2ae6(%rip), %rax      # 0x4070
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15ac
leaq 0xc63(%rip), %rdi       # 0x2200
movb $0x0, %al
callq 0x1040
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_04/stack.c
// Function: swap
void swap(void)
{
  double temp1 = pop();
  double temp2 = pop();

  push(temp1);
  push(temp2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1560
movsd %xmm0, -0x8(%rbp)
callq 0x1560
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x1500
movsd -0x10(%rbp), %xmm0
callq 0x1500
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2da2(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
callq 0x1130
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xd91(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %edi
callq 0x1110
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
sarl $0x2, %eax
movsbl %al, %edi
callq 0x1560
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
andl $0x3, %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
andl $0xf0, %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movsbl %al, %edi
callq 0x1560
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xf, %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
andl $0xc0, %ecx
sarl $0x6, %ecx
orl %ecx, %eax
movsbl %al, %edi
callq 0x1560
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x8(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x3f, %eax
movsbl %al, %edi
callq 0x1560
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x16e5
movl 0x2a29(%rip), %eax      # 0x40bc
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x2a1e(%rip)      # 0x40bc
cltq
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x16c9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16c9
movl $0xa, %edi
callq 0x1040
movl $0x1, 0x29f3(%rip)      # 0x40bc
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1687
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)