LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: fe_neg
void fe_neg(fe h, const fe f) {
    int32_t f0 = f[0];
    int32_t f1 = f[1];
    int32_t f2 = f[2];
    int32_t f3 = f[3];
    int32_t f4 = f[4];
    int32_t f5 = f[5];
    int32_t f6 = f[6];
    int32_t f7 = f[7];
    int32_t f8 = f[8];
    int32_t f9 = f[9];
    int32_t h0 = -f0;
    int32_t h1 = -f1;
    int32_t h2 = -f2;
    int32_t h3 = -f3;
    int32_t h4 = -f4;
    int32_t h5 = -f5;
    int32_t h6 = -f6;
    int32_t h7 = -f7;
    int32_t h8 = -f8;
    int32_t h9 = -f9;
    h[0] = h0;
    h[1] = h1;
    h[2] = h2;
    h[3] = h3;
    h[4] = h4;
    h[5] = h5;
    h[6] = h6;
    h[7] = h7;
    h[8] = h8;
    h[9] = h9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x40(%rbp)
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
xorl %eax, %eax
subl -0x28(%rbp), %eax
movl %eax, -0x50(%rbp)
xorl %eax, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
xorl %eax, %eax
subl -0x30(%rbp), %eax
movl %eax, -0x58(%rbp)
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x44(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x48(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x50(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x54(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x58(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x5c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x60(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: ge_p3_to_cached
void ge_p3_to_cached(ge_cached *r, const ge_p3 *p) {
    fe_add(r->YplusX,p->Y,p->X);
    fe_sub(r->YminusX,p->Y,p->X);
    fe_copy(r->Z,p->Z);
    fe_mul(r->T2d,p->T,d2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xc370
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0xdd20
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
leaq 0x2346(%rip), %rdx      # 0xf160
callq 0xb2f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: ge_p1p1_to_p3
void ge_p1p1_to_p3(ge_p3 *r,const ge_p1p1 *p) {
    fe_mul(r->X,p->X,p->T);
    fe_mul(r->Y,p->Y,p->Z);
    fe_mul(r->Z,p->Z,p->T);
    fe_mul(r->T,p->X,p->Y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x78, %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
addq $0x50, %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movq -0x10(%rbp), %rdx
addq $0x78, %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
callq 0xb2f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: ge_add
void ge_add(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q) {
    fe t0;
    fe_add(r->X,p->Y,p->X);
    fe_sub(r->Y,p->Y,p->X);
    fe_mul(r->Z,r->X,q->YplusX);
    fe_mul(r->Y,r->Y,q->YminusX);
    fe_mul(r->T,q->T2d,p->T);
    fe_mul(r->X,p->Z,q->Z);
    fe_add(t0,r->X,r->X);
    fe_sub(r->X,r->Z,r->Y);
    fe_add(r->Y,r->Z,r->Y);
    fe_add(r->Z,t0,r->T);
    fe_sub(r->T,t0,r->T);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0xc370
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
movq -0x10(%rbp), %rdx
addq $0x78, %rdx
callq 0xb2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
callq 0xb2f0
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
callq 0xc370
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
leaq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
leaq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0xc370
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: ge_p2_dbl
void ge_p2_dbl(ge_p1p1 *r, const ge_p2 *p) {
    fe t0;
    fe_sq(r->X,p->X);
    fe_sq(r->Z,p->Y);
    fe_sq2(r->T,p->Z);
    fe_add(r->Y,p->X,p->Y);
    fe_sq(t0,r->Y);
    fe_add(r->Y,r->Z,r->X);
    fe_sub(r->Z,r->Z,r->X);
    fe_sub(r->X,t0,r->Y);
    fe_sub(r->T,r->T,r->Z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa830
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0xa830
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0xde80
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x28, %rdx
callq 0xc530
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
callq 0xa830
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
callq 0xc530
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
callq 0xc370
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
callq 0xc370
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x8(%rbp), %rsi
addq $0x78, %rsi
movq -0x8(%rbp), %rdx
addq $0x50, %rdx
callq 0xc370
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joewalnes[P]verifysignature/verifysignature.c
// Function: fe_copy
void fe_copy(fe h, const fe f) {
    int32_t f0 = f[0];
    int32_t f1 = f[1];
    int32_t f2 = f[2];
    int32_t f3 = f[3];
    int32_t f4 = f[4];
    int32_t f5 = f[5];
    int32_t f6 = f[6];
    int32_t f7 = f[7];
    int32_t f8 = f[8];
    int32_t f9 = f[9];
    h[0] = f0;
    h[1] = f1;
    h[2] = f2;
    h[3] = f3;
    h[4] = f4;
    h[5] = f5;
    h[6] = f6;
    h[7] = f7;
    h[8] = f8;
    h[9] = f9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x38(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: main
int			main(int ac, char **av)
{
	t_stack	s;
	int		flag_v;
	int		flag_c;
	char	*s_arg;
	char	**arg;

	if (ac == 1)
		return (0);
	s.a = NULL;
	s.b = NULL;
	flag_v = 0;
	flag_c = 0;
	s_arg = ft_get_av_checker(av + 1);
	arg = ft_get_option(s_arg, &flag_v, &flag_c);
	s.size = ft_size_of_arg(arg);
	ft_set_a_and_b(&s, arg, s.size);
	ft_free_tab_str(arg);
	ft_exec(&s, flag_v, flag_c);
	ft_is_ok(s.a, s.size_a);
	ft_free_stack(&s);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x11a8
movl $0x0, -0x4(%rbp)
jmp 0x1245
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1250
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1320
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x23d0
cltq
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rsi
movq -0x28(%rbp), %rax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
callq 0x22f0
movq -0x58(%rbp), %rdi
callq 0x2620
movl -0x44(%rbp), %esi
movl -0x48(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x15a0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x1450
leaq -0x40(%rbp), %rdi
callq 0x1f30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: ft_get_av_checker
static char	*ft_get_av_checker(char **av)
{
	char	**tab;
	char	*s;
	int		i;
	int		count;

	s = NULL;
	count = 0;
	while (av[count])
	{
		tab = ft_strsplit(av[count], ' ');
		i = 0;
		while (tab[i])
		{
			s = ft_strjoinfree(s, tab[i++], FIRST);
			s = ft_strjoinfree(s, "\n", FIRST);
		}
		ft_free_tab_str(tab);
		count++;
	}
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1308
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x20, %esi
callq 0x2700
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12f1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x2580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x8da6(%rip), %rsi      # 0xa087
movl $0x1, %edx
callq 0x2580
movq %rax, -0x18(%rbp)
jmp 0x129f
movq -0x10(%rbp), %rdi
callq 0x2620
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x126b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: ft_get_option
static char	**ft_get_option(char *s, int *flag_v, int *flag_c)
{
	int		i;
	char	**tab;

	i = ft_get_option_extend(s, flag_v, flag_c);
	if (!(tab = ft_strsplit(s + i, '\n')) || !tab[0])
	{
		ft_strdel(&s);
		ft_free_tab_str(tab);
		exit(0);
	}
	ft_strdel(&s);
	i = -1;
	while (tab[++i])
	{
		if (ft_strequ(tab[i], "-")
			|| !(ft_str_is_numeric(tab[i]) || (tab[i][0] == '-'
			&& ft_str_is_numeric(tab[i] + 1))))
		{
			ft_free_tab_str(tab);
			ft_putendl_fd("Error", 2);
			exit(1);
		}
	}
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movl $0xa, %esi
callq 0x2700
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1371
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x138a
leaq -0x8(%rbp), %rdi
callq 0x25e0
movq -0x28(%rbp), %rdi
callq 0x2620
xorl %edi, %edi
callq 0x1070
leaq -0x8(%rbp), %rdi
callq 0x25e0
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x143f
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8c3c(%rip), %rsi      # 0xa004
callq 0x2420
cmpl $0x0, %eax
jne 0x1416
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2690
cmpl $0x0, %eax
jne 0x143a
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1416
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
callq 0x2690
cmpl $0x0, %eax
jne 0x143a
movq -0x28(%rbp), %rdi
callq 0x2620
leaq 0x8be0(%rip), %rdi      # 0xa006
movl $0x2, %esi
callq 0x2be0
movl $0x1, %edi
callq 0x1070
jmp 0x139a
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: ft_is_ok
static void	ft_is_ok(long *tab, int size)
{
	int		i;

	i = 0;
	while (i + 1 < size)
	{
		if (tab[i] < tab[i + 1])
		{
			ft_putendl("KO");
			return ;
		}
		i++;
	}
	ft_putendl("OK");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0x14a9
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x149e
leaq 0x8b75(%rip), %rdi      # 0xa00c
callq 0x2b80
jmp 0x14b5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1466
leaq 0x8b5f(%rip), %rdi      # 0xa00f
callq 0x2b80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_checker.c
// Function: ft_get_option_extend
static int	ft_get_option_extend(char *s, int *flag_v, int *flag_c)
{
	int		i;

	i = 0;
	while (s[i] == '-')
	{
		if (s[i + 1] == 'c' || s[i + 1] == 'v')
			i++;
		else
			break ;
		while (s[i] == 'c' || s[i] == 'v')
		{
			if (s[i] == 'v')
				*flag_v = 1;
			else
				*flag_c = 1;
			i++;
		}
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x159b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x63, %eax
je 0x1518
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x76, %eax
jne 0x1523
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1525
jmp 0x159b
jmp 0x1527
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x63, %ecx
movb %al, -0x1d(%rbp)
je 0x1552
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x76, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x155b
jmp 0x158d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x76, %eax
jne 0x1578
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x1582
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1527
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14d7
movl -0x1c(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_exec.c
// Function: ft_exec
void		ft_exec(t_stack *s, int flag_v, int flag_c)
{
	char	*line;
	int		step;

	step = 1;
	line = NULL;
	if (flag_v)
	{
		ft_printf("\033[2J\033[;H");
		ft_printf("---> \033[031mINIT\033[0m\n");
		ft_print_stack(s);
	}
	while (get_next_line(0, &line) > 0)
	{
		ft_process(s, &line);
		if (flag_v)
		{
			ft_printf("\033[2J\033[;H");
			ft_printf("---> \033[031mSTEP %d\033[0m\n", step++);
			ft_print_stack(s);
		}
		if (flag_c)
			ft_exec_flag_c(line, flag_v);
		ft_strdel(&line);
	}
	ft_strdel(&line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x15ec
leaq 0x8a44(%rip), %rdi      # 0xa012
movb $0x0, %al
callq 0x34d0
leaq 0x8a3f(%rip), %rdi      # 0xa01b
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
callq 0x1770
jmp 0x15ee
xorl %edi, %edi
leaq -0x18(%rbp), %rsi
callq 0x2cd0
cmpl $0x0, %eax
jle 0x165e
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1670
cmpl $0x0, -0xc(%rbp)
je 0x1641
leaq 0x89fa(%rip), %rdi      # 0xa012
movb $0x0, %al
callq 0x34d0
movl -0x1c(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x89ff(%rip), %rdi      # 0xa030
movb $0x0, %al
callq 0x34d0
movq -0x8(%rbp), %rdi
callq 0x1770
cmpl $0x0, -0x10(%rbp)
je 0x1653
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1720
leaq -0x18(%rbp), %rdi
callq 0x25e0
jmp 0x15ee
leaq -0x18(%rbp), %rdi
callq 0x25e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_exec.c
// Function: ft_process
static void	ft_process(t_stack *s, char **str)
{
	int		ret;

	ret = 0;
	if (**str == 's')
		ret = ft_exec_swap(s, *str);
	else if (**str == 'p')
		ret = ft_exec_push(s, *str);
	else if (**str == 'r')
		ret = ft_exec_rotate(s, *str);
	if (ret == 0)
	{
		ft_strdel(str);
		ft_exit(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x73, %eax
jne 0x16ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1990
movl %eax, -0x14(%rbp)
jmp 0x16f5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x16cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1b60
movl %eax, -0x14(%rbp)
jmp 0x16f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x16f1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1c70
movl %eax, -0x14(%rbp)
jmp 0x16f3
jmp 0x16f5
cmpl $0x0, -0x14(%rbp)
jne 0x170d
movq -0x10(%rbp), %rdi
callq 0x25e0
movq -0x8(%rbp), %rdi
callq 0x1f90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_exec.c
// Function: ft_exec_flag_c
static void	ft_exec_flag_c(char *cmd, int flag_v)
{
	if (flag_v)
	{
		ft_printf("\n\n    --------------- Last CMD: \033[36m%-4s\033[0m", cmd);
		ft_printf("---------------\n\n\n");
	}
	else
		ft_printf("Last CMD: \033[36m%-4s\033[0m\n", cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1757
movq -0x8(%rbp), %rsi
leaq 0x8908(%rip), %rdi      # 0xa048
movb $0x0, %al
callq 0x34d0
leaq 0x8928(%rip), %rdi      # 0xa076
movb $0x0, %al
callq 0x34d0
jmp 0x1769
movq -0x8(%rbp), %rsi
leaq 0x8927(%rip), %rdi      # 0xa089
movb $0x0, %al
callq 0x34d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_print_stack.c
// Function: ft_print_stack
void			ft_print_stack(t_stack *s)
{
	size_t	i;
	size_t	size_max;

	size_max = s->size;
	i = 0;
	ft_putstr("\n    |       \033[32mstack A\033[0m       |       ");
	ft_putendl("\033[32mstack B\033[0m       |");
	ft_putendl("    |                     |                     |");
	while (i < size_max)
	{
		ft_putstr("    |");
		ft_print_case(s->a, s->size_a, size_max - 1 - i);
		ft_putstr(" | ");
		ft_print_case(s->b, s->size_b, size_max - 1 - i);
		ft_putendl("|");
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x890b(%rip), %rdi      # 0xa0a2
callq 0x2b40
leaq 0x892c(%rip), %rdi      # 0xa0cf
callq 0x2b80
leaq 0x8939(%rip), %rdi      # 0xa0e8
callq 0x2b80
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1831
leaq 0x894f(%rip), %rdi      # 0xa114
callq 0x2b40
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
subq -0x10(%rbp), %rdx
callq 0x1840
leaq 0x8929(%rip), %rdi      # 0xa11a
callq 0x2b40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
subq -0x10(%rbp), %rdx
callq 0x1840
leaq 0x88fa(%rip), %rdi      # 0xa118
callq 0x2b80
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x17b4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_print_stack.c
// Function: ft_print_case
static void		ft_print_case(long *tab, size_t size_tab, size_t i)
{
	size_t nb_size;

	ft_putstr("\033[33m");
	if (i < size_tab)
	{
		nb_size = 21 - ft_size_of_int(tab[i]);
		ft_print_nb_of_char(nb_size / 2, ' ');
		nb_size -= nb_size / 2;
		ft_putnbr(tab[i]);
		ft_print_nb_of_char(nb_size - 1, ' ');
	}
	else
		ft_putstr("         .          ");
	ft_putstr("\033[0m");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x88c3(%rip), %rdi      # 0xa11e
callq 0x2b40
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x18d6
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edi
callq 0x1900
movq %rax, %rcx
movl $0x15, %eax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shrq %rdi
movl $0x20, %esi
callq 0x1950
movq -0x20(%rbp), %rcx
shrq %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edi
callq 0x2c40
movq -0x20(%rbp), %rdi
subq $0x1, %rdi
movl $0x20, %esi
callq 0x1950
jmp 0x18e2
leaq 0x8847(%rip), %rdi      # 0xa124
callq 0x2b40
leaq 0x8788(%rip), %rdi      # 0xa071
callq 0x2b40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_print_stack.c
// Function: ft_size_of_int
static size_t	ft_size_of_int(int nb)
{
	size_t	size;

	size = 0;
	if (nb <= 0)
		size++;
	while (nb)
	{
		nb /= 10;
		size++;
	}
	return (size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jg 0x1921
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1923
cmpl $0x0, -0x4(%rbp)
je 0x1945
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1923
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_process.c
// Function: ft_exec_swap
int			ft_exec_swap(t_stack *s, char *str)
{
	if (ft_strequ(str, "sa"))
	{
		if (s->size_a > 1)
			ft_swap_long(&s->a[s->size_a - 1], &s->a[s->size_a - 2]);
	}
	else if (ft_strequ(str, "sb"))
	{
		if (s->size_b > 1)
			ft_swap_long(&s->b[s->size_b - 1], &s->b[s->size_b - 2]);
	}
	else if (ft_strequ(str, "ss"))
	{
		if (s->size_a > 1)
			ft_swap_long(&s->a[s->size_a - 1], &s->a[s->size_a - 2]);
		if (s->size_b > 1)
			ft_swap_long(&s->b[s->size_b - 1], &s->b[s->size_b - 2]);
	}
	else
		return (FALSE);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x878e(%rip), %rsi      # 0xa139
callq 0x2420
cmpl $0x0, %eax
je 0x19fe
movq -0x10(%rbp), %rax
cmpq $0x1, 0x20(%rax)
jbe 0x19f9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b20
jmp 0x1b10
movq -0x18(%rbp), %rdi
leaq 0x8733(%rip), %rsi      # 0xa13c
callq 0x2420
cmpl $0x0, %eax
je 0x1a5e
movq -0x10(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jbe 0x1a59
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b20
jmp 0x1b0e
movq -0x18(%rbp), %rdi
leaq 0x86d6(%rip), %rsi      # 0xa13f
callq 0x2420
cmpl $0x0, %eax
je 0x1b03
movq -0x10(%rbp), %rax
cmpq $0x1, 0x20(%rax)
jbe 0x1abb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b20
movq -0x10(%rbp), %rax
cmpq $0x1, 0x28(%rax)
jbe 0x1b01
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x1, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
subq $0x2, %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b20
jmp 0x1b0c
movl $0x0, -0x4(%rbp)
jmp 0x1b17
jmp 0x1b0e
jmp 0x1b10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_process.c
// Function: ft_exec_push
int			ft_exec_push(t_stack *s, char *str)
{
	if (ft_strequ(str, "pa"))
	{
		if (s->size_b)
		{
			s->size_a++;
			s->a[s->size_a - 1] = s->b[s->size_b - 1];
			s->size_b--;
		}
	}
	else if (ft_strequ(str, "pb"))
	{
		if (s->size_a)
		{
			s->size_b++;
			s->b[s->size_b - 1] = s->a[s->size_a - 1];
			s->size_a--;
		}
	}
	else
		return (FALSE);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x85c7(%rip), %rsi      # 0xa142
callq 0x2420
cmpl $0x0, %eax
je 0x1be1
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1bdf
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x1c5d
movq -0x18(%rbp), %rdi
leaq 0x8559(%rip), %rsi      # 0xa145
callq 0x2420
cmpl $0x0, %eax
je 0x1c52
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1c50
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x1c5b
movl $0x0, -0x4(%rbp)
jmp 0x1c64
jmp 0x1c5d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_process.c
// Function: ft_exec_rotate
int			ft_exec_rotate(t_stack *s, char *str)
{
	if (ft_strequ(str, "ra"))
		ft_rotate_extend(s->a, s->size_a, 1);
	else if (ft_strequ(str, "rb"))
		ft_rotate_extend(s->b, s->size_b, 1);
	else if (ft_strequ(str, "rr"))
	{
		ft_rotate_extend(s->a, s->size_a, 1);
		ft_rotate_extend(s->b, s->size_b, 1);
	}
	else if (ft_strequ(str, "rra"))
		ft_rotate_extend(s->a, s->size_a, -1);
	else if (ft_strequ(str, "rrb"))
		ft_rotate_extend(s->b, s->size_b, -1);
	else if (ft_strequ(str, "rrr"))
	{
		ft_rotate_extend(s->a, s->size_a, -1);
		ft_rotate_extend(s->b, s->size_b, -1);
	}
	else
		return (FALSE);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x84be(%rip), %rsi      # 0xa149
callq 0x2420
cmpl $0x0, %eax
je 0x1cb3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x1, %edx
callq 0x1e10
jmp 0x1df5
movq -0x18(%rbp), %rdi
leaq 0x848f(%rip), %rsi      # 0xa14d
callq 0x2420
cmpl $0x0, %eax
je 0x1ce7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x1e10
jmp 0x1df3
movq -0x18(%rbp), %rdi
leaq 0x845f(%rip), %rsi      # 0xa151
callq 0x2420
cmpl $0x0, %eax
je 0x1d34
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x1, %edx
callq 0x1e10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0x1, %edx
callq 0x1e10
jmp 0x1df1
movq -0x18(%rbp), %rdi
leaq 0x8409(%rip), %rsi      # 0xa148
callq 0x2420
cmpl $0x0, %eax
je 0x1d67
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1e10
jmp 0x1def
movq -0x18(%rbp), %rdi
leaq 0x83da(%rip), %rsi      # 0xa14c
callq 0x2420
cmpl $0x0, %eax
je 0x1d98
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1e10
jmp 0x1ded
movq -0x18(%rbp), %rdi
leaq 0x83ad(%rip), %rsi      # 0xa150
callq 0x2420
cmpl $0x0, %eax
je 0x1de2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1e10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1e10
jmp 0x1deb
movl $0x0, -0x4(%rbp)
jmp 0x1dfc
jmp 0x1ded
jmp 0x1def
jmp 0x1df1
jmp 0x1df3
jmp 0x1df5
movl $0x1, -0x4(%rbp)
movl -0x4(%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_checker/ft_process.c
// Function: ft_rotate_extend
static void	ft_rotate_extend(long *tab, size_t size, int inc)
{
	size_t	i;
	long	tmp;

	if (size < 2)
		return ;
	if (inc > 0)
	{
		i = -1;
		tmp = tab[0];
		tab[0] = tab[size - 1];
		while (size - 1 - ++i > 0)
			tab[size - 1 - i] = tab[size - 2 - i];
		tab[1] = tmp;
	}
	else
	{
		i = -1;
		tmp = tab[size - 1];
		tab[size - 1] = tab[0];
		while (++i + 1 < size)
			tab[i] = tab[i + 1];
		tab[size - 2] = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x2, -0x10(%rbp)
jae 0x1e2b
jmp 0x1f28
cmpl $0x0, -0x14(%rbp)
jle 0x1eb0
movq $-0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
subq %rcx, %rax
cmpq $0x0, %rax
jbe 0x1ea2
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x2, %rcx
subq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
subq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1e5b
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1f28
movq $-0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
addq $0x1, %rax
cmpq -0x10(%rbp), %rax
jae 0x1f14
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1ee3
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x2, %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_tool.c
// Function: ft_free_stack
void	ft_free_stack(t_stack *s)
{
	if (s->a)
	{
		free(s->a);
		s->a = NULL;
	}
	if (s->b)
	{
		free(s->b);
		s->b = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1f5d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1f81
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_tool2.c
// Function: ft_check_arg
int		ft_check_arg(t_stack *s, char *str, size_t i)
{
	long	nb;
	size_t	j;

	nb = ft_atol(str);
	j = s->size_a - 1;
	if (nb > 2147483647 || nb < -2147483648)
		return (0);
	while (j > i)
		if (s->a[j--] == nb)
			return (0);
	if (*str == '-' && *(str + 1))
		str++;
	while (*str)
	{
		if (*str < '0' || *str > '9')
			return (0);
		str++;
	}
	s->a[i] = nb;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1fd0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jg 0x2225
cmpq $-0x80000000, -0x28(%rbp) # imm = 0x80000000
jge 0x2231
movl $0x0, -0x4(%rbp)
jmp 0x22e1
jmp 0x2233
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x2268
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x30(%rbp)
movq (%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jne 0x2266
movl $0x0, -0x4(%rbp)
jmp 0x22e1
jmp 0x2233
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x228d
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x228d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x228f
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x22c7
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x22b0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x22b9
movl $0x0, -0x4(%rbp)
jmp 0x22e1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x228f
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_tool2.c
// Function: ft_set_a_and_b
void	ft_set_a_and_b(t_stack *s, char **av, int ac)
{
	size_t	i;
	int		tmp;

	i = 0;
	s->size_a = s->size;
	s->size_b = 0;
	if (!(s->a = (long *)malloc(sizeof(long) * s->size)))
		ft_exit(s);
	if (!(s->b = (long *)malloc(sizeof(long) * s->size)))
		ft_exit(s);
	tmp = ac;
	while (tmp)
	{
		if (!(ft_check_arg(s, av[i++], (tmp-- - 1))))
			ft_exit(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
shlq $0x3, %rdi
callq 0x1060
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x234e
movq -0x8(%rbp), %rdi
callq 0x1f90
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
shlq $0x3, %rdi
callq 0x1060
movq -0x8(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x2376
movq -0x8(%rbp), %rdi
callq 0x1f90
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x23c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movq (%rax,%rcx,8), %rsi
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
movslq %eax, %rdx
callq 0x21e0
cmpl $0x0, %eax
jne 0x23c1
movq -0x8(%rbp), %rdi
callq 0x1f90
jmp 0x237c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/srcs_checker/ft_tool2.c
// Function: ft_size_of_arg
int		ft_size_of_arg(char **arg)
{
	int		i;

	i = 0;
	while (arg && arg[i])
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0xd(%rbp)
je 0x23fe
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x2407
jmp 0x2412
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23df
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strequ.c
// Function: ft_strequ
int	ft_strequ(char const *s1, char const *s2)
{
	if (!s1 && !s2)
		return (1);
	else if (!s1 || !s2)
		return (0);
	while (*s1 || *s2)
	{
		if (ft_isalpha(*s1))
			ft_toupper(*s1);
		if (ft_isalpha(*s2))
			ft_toupper(*s2);
		if (*s1++ != *s2++)
			return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x244a
cmpq $0x0, -0x18(%rbp)
jne 0x244a
movl $0x1, -0x4(%rbp)
jmp 0x2509
cmpq $0x0, -0x10(%rbp)
je 0x2458
cmpq $0x0, -0x18(%rbp)
jne 0x2464
movl $0x0, -0x4(%rbp)
jmp 0x2509
jmp 0x2466
jmp 0x2468
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x2489
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2492
jmp 0x2502
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2aa0
cmpl $0x0, %eax
je 0x24af
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2a70
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2aa0
cmpl $0x0, %eax
je 0x24cc
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2a70
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x24fd
movl $0x0, -0x4(%rbp)
jmp 0x2509
jmp 0x2468
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strjoinfree.c
// Function: ft_strjoinfree_n
char	*ft_strjoinfree_n(char **s1, char **s2, int which)
{
	char	*new_str;

	new_str = ft_strjoin(*s1, *s2);
	if (which == FIRST || which == BOTH)
		ft_strdel(s1);
	if (which == SECOND || which == BOTH)
		ft_strdel(s2);
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x9190
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x2556
cmpl $0x3, -0x14(%rbp)
jne 0x255f
movq -0x8(%rbp), %rdi
callq 0x25e0
cmpl $0x2, -0x14(%rbp)
je 0x256b
cmpl $0x3, -0x14(%rbp)
jne 0x2574
movq -0x10(%rbp), %rdi
callq 0x25e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strjoinfree.c
// Function: ft_strjoinfree
char	*ft_strjoinfree(char *s1, char *s2, int which)
{
	char	*new_str;

	new_str = ft_strjoin(s1, s2);
	if (which == FIRST || which == BOTH)
		ft_strdel(&s1);
	if (which == SECOND || which == BOTH)
		ft_strdel(&s2);
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9190
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x25b0
cmpl $0x3, -0x14(%rbp)
jne 0x25b9
leaq -0x8(%rbp), %rdi
callq 0x25e0
cmpl $0x2, -0x14(%rbp)
je 0x25c5
cmpl $0x3, -0x14(%rbp)
jne 0x25ce
leaq -0x10(%rbp), %rdi
callq 0x25e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strdel.c
// Function: ft_strdel
void	ft_strdel(char **as)
{
	if (!as || !*as)
		return ;
	free(*as);
	*as = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25fd
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x25ff
jmp 0x2616
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_free_tab_str.c
// Function: ft_free_tab_str
void	ft_free_tab_str(char **tab)
{
	size_t	i;

	if (!tab)
		return ;
	i = 0;
	while (tab[i])
		ft_strdel(&tab[i++]);
	free(tab);
	tab = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2635
jmp 0x267e
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x266d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
shlq $0x3, %rax
addq %rax, %rdi
callq 0x25e0
jmp 0x263d
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_str_is_numeric.c
// Function: ft_str_is_numeric
int		ft_str_is_numeric(char *str)
{
	if (str == NULL)
		return (FALSE);
	while (*str != '\0')
	{
		if (ft_isdigit(*str) == FALSE)
			return (FALSE);
		str++;
	}
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x26ac
movl $0x0, -0x4(%rbp)
jmp 0x26e9
jmp 0x26ae
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x26e2
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2ae0
cmpl $0x0, %eax
jne 0x26d4
movl $0x0, -0x4(%rbp)
jmp 0x26e9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x26ae
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char				**tab;
	size_t				count;
	size_t				i;

	if (!s)
		return (NULL);
	i = 0;
	count = 0;
	while (s[i] == c && s[i])
		i++;
	if (s[i])
		count = ft_count_words(s, c);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	if (count)
	{
		if (!(tab = ft_fill_table(s + i, tab, c)))
		{
			free(tab);
			tab = NULL;
			return (NULL);
		}
	}
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2726
movq $0x0, -0x8(%rbp)
jmp 0x281a
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x2764
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x276d
jmp 0x277b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2736
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x279a
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x2830
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x27bf
movq $0x0, -0x8(%rbp)
jmp 0x281a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, -0x28(%rbp)
je 0x2812
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x28c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2810
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x20(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x281a
jmp 0x2812
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strsplit.c
// Function: ft_count_words
static size_t	ft_count_words(char const *s, char c)
{
	size_t	count;
	size_t	i;

	count = 0;
	i = 0;
	while (s[i++])
	{
		if (s[i] == c || !s[i])
		{
			if (s[i - 1] != c)
				count++;
		}
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
cmpb $0x0, (%rax,%rcx)
je 0x28b1
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x2889
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x28af
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x28ad
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x28af
jmp 0x284e
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)