LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.5/sigusr1.c
// Function: main
int main ()
{
	struct sigaction sa;
	memset (&sa, 0, sizeof (sa));
	sa.sa_handler = &handler;
	sigaction (SIGUSR1, &sa, NULL);
	int pid = (int) getpid();
	for (int i=0; i<10; i++)	
        kill(pid, SIGUSR1);
	printf ("SIGUSR1 was raised %d times\n", sigusr1_count);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq -0xa8(%rbp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
leaq -0x39(%rip), %rax       # 0x117c
movq %rax, -0x8(%rbx)
pushq $0xa
popq %rbx
leaq -0xb0(%rbp), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x1050
callq 0x1070
movl %eax, %r14d
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x11e9
movl %r14d, %edi
movl %ebx, %esi
callq 0x1060
jmp 0x11d7
movl 0x2e65(%rip), %esi      # 0x4054
leaq 0xe0e(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_06/psprintf.c
// Function: main
int main(int argc, char *argv[])
{
	char *msg;
	int ret;

        if (argc < 2) {
                fprintf(stderr, "usage: %s <prefix>\n",
                        argv[0]);
                return -1;
        }

	/* Format the message with the supplied prefix */
	ret = psprintf(&msg, argv[1],
		"some data: %d, %c\n", 10, 'x');
	if (ret < 0) {
		fprintf(stderr, "psprintf error\n");
		return -1;
	}

	/* Print the message on stdout */
	fputs(msg, stdout);

	/* Free the allocated memory buffer */
	free(msg);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x11f8
movq 0x8(%rsi), %rsi
xorl %ebx, %ebx
movq %rsp, %rdi
pushq $0xa
popq %rcx
pushq $0x78
popq %r8
xorl %eax, %eax
callq 0x1236
testl %eax, %eax
js 0x1215
movq (%rsp), %r14
movq 0x2dfd(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2df9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0xdf8(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1080
jmp 0x1231
movq 0x2ddc(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe05(%rip), %rdi       # 0x202b
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
pushq $-0x1
popq %rbx
jmp 0x11ee
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_06/psprintf.c
// Function: psprintf
static int psprintf(char **str, const char *name,
		const char *fmt, ...)
{
	int size;
	char *nfmt;
	va_list ap;
	int ret;

	/* Compute the new format size.
	 *
	 * The new format string is formed as:
	 *     <name>: <fmt>\0
	 * so it must be computed as:
	 */
	size = strlen(name) + strlen(fmt) + 3;

	/* Allocate the new format */
	nfmt = malloc(size);
	if (!nfmt)
		return -1;

	/* Build the new format as "<name>: <fmt>".
	 *
	 * Note that nft string has the right size so
	 * we can safely not check the return value
	 */
	snprintf(nfmt, size, "%s: %s", name, fmt);
	
	/* Compute the output size */
	va_start(ap, fmt);
	ret = vsnprintf(NULL, 0, nfmt, ap);
	va_end(ap);
	if (ret < 0)
		goto free_nfmt;
	size = ret + 1; /* for '\0' */

	/* Allocate the output buffer */
	*str = malloc(size);
	if (*str == NULL) {
		ret = -1;
		goto free_nfmt;
	}

	/* Build the output string */
	va_start(ap, fmt);
	ret = vsnprintf(*str, size, nfmt, ap);
	va_end(ap);
	if (ret < 0)
		goto free_nfmt;

free_nfmt:
	free(nfmt);

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1297
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, %rdi
callq 0x1050
addl $0x15, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x1090
testq %rax, %rax
je 0x1343
movq %rax, %rbx
leaq 0xd7b(%rip), %rdx       # 0x203b
leaq 0xd51(%rip), %r8        # 0x2018
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x1060
movabsq $0x3000000018, %r12     # imm = 0x3000000018
movq %rsp, %rcx
movq %r12, (%rcx)
leaq 0x110(%rsp), %r13
movq %r13, 0x8(%rcx)
leaq 0x20(%rsp), %rbp
movq %rbp, 0x10(%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1040
movl %eax, %r15d
testl %eax, %eax
js 0x134d
incl %r15d
movq %r15, %rdi
callq 0x1090
movq %rax, (%r14)
testq %rax, %rax
je 0x1349
movq %rsp, %rcx
movq %rbp, 0x10(%rcx)
movq %r13, 0x8(%rcx)
movq %r12, (%rcx)
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1040
movl %eax, %r15d
jmp 0x134d
pushq $-0x1
popq %r15
jmp 0x1355
pushq $-0x1
popq %r15
movq %rbx, %rdi
callq 0x1030
movl %r15d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gadget114514[P]fatfs-example/fmkfs.c
// Function: main
void main()
{
  char b[4096];
  FATFS fs;

  int fno = open("abc.dat", O_CREAT|O_SYNC|O_RDWR, S_IRUSR|S_IWUSR);
  printf("fno = %d\n", fno);
  int i = 0;
  char buf[512]={0};
  while (i < SECCOUNT) {
    //    printf("size = %ld\n", write(fno, buf, 512));
    write(fno, buf, 512);
    i++;
  }
  close(fno);
  fno = -1;
  //  f_mount(&fs, "", 0); 
  //  f_mkfs("", FM_FAT, 2*512, b, 4096);
  FCHK(f_mkfs("", FM_SFD|FM_FAT, 0, b, 4096));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1208, %rsp           # imm = 0x1208
leaq 0x3e41(%rip), %rdi      # 0x5004
movl $0x101042, %esi         # imm = 0x101042
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x10a0
movl %eax, %ebx
leaq 0x3e2f(%rip), %rdi      # 0x500c
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
leaq -0x220(%rbp), %r14
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x80, %r15d
subl $0x1, %r15d
jb 0x1219
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
callq 0x1040
jmp 0x1202
movl %ebx, %edi
callq 0x1080
leaq 0x3dee(%rip), %rdi      # 0x5015
pushq $0x9
popq %rsi
leaq -0x1220(%rbp), %rcx
xorl %edx, %edx
movl $0x1000, %r8d           # imm = 0x1000
callq 0x3854
cmpl $0x12, %eax
ja 0x1255
movl %eax, %ecx
leaq 0x418c(%rip), %rdx      # 0x53d8
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmp 0x125c
leaq 0x4161(%rip), %rcx      # 0x53bd
leaq 0x3db3(%rip), %rdi      # 0x5016
leaq 0x3dbf(%rip), %rsi      # 0x5029
movl %eax, %edx
xorl %eax, %eax
callq 0x1050
addq $0x1208, %rsp           # imm = 0x1208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/exit_checker.c
// Function: ft_dellists
void	ft_dellists(t_list **list)
{
	t_list	*del;
	t_list	*lst;

	if (!list)
		return ;
	lst = *list;
	while (lst)
	{
		del = lst->next;
		free(lst->content);
		free(lst);
		lst = del;
	}
	*list = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x11d3
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x11ca
movq (%r14), %rdi
movq 0x8(%r14), %r15
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
jmp 0x11ac
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: check_existant
int		check_existant(char **av, int i)
{
	int		j;
	int		len;

	j = 1;
	while (j < i)
	{
		if (ft_strlen(av[j]) > ft_strlen(av[i]))
			len = ft_strlen(av[j]);
		else
			len = ft_strlen(av[i]);
		if (!ft_strncmp(av[j], av[i], len))
			return (1);
		j++;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %r12
leaq (%rdi,%r12,8), %r13
addq $0x8, %r14
pushq $0x1
popq %rbp
pushq $0x1
popq %rbx
cmpq %r12, %rbp
jge 0x12bd
movq (%r14), %rdi
callq 0x2fbc
movq %rax, %r15
movq (%r13), %rdi
callq 0x2fbc
cmpq %rax, %r15
movq %r13, %rax
cmovaq %r14, %rax
movq (%rax), %rdi
callq 0x2fbc
movq (%r14), %rdi
movq (%r13), %rsi
movslq %eax, %rdx
callq 0x2feb
incq %rbp
addq $0x8, %r14
testl %eax, %eax
jne 0x1276
jmp 0x12bf
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: parsing_ac
int		parsing_ac(char *av)
{
	int		i;
	int		minus;

	i = 0;
	minus = 0;
	while (av[i])
	{
		if (av[i] == '-')
			minus++;
		if (av[i] > '9' || av[i] < '0')
		{
			if (av[i] != '-' || minus > 1)
				return (-1);
		}
		i++;
	}
	return (0);
}

// Assembly:
xorl %edx, %edx
pushq $-0x1
popq %rcx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x12ec
testl %eax, %eax
je 0x12ff
leal -0x3a(%rax), %esi
cmpb $-0xb, %sil
jbe 0x12ee
jmp 0x12f8
incl %edx
cmpl $0x2d, %eax
jne 0x12fd
cmpl $0x1, %edx
jg 0x12fd
incq %rdi
jmp 0x12d5
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/parsing.c
// Function: fill_list_a
t_list	*fill_list_a(char *av)
{
	t_list	*new;
	t_data	*new_data;

	if (!(new_data = malloc(sizeof(t_data))))
		return (NULL);
	new_data->value = ft_atoi(av);
	new_data->index = 0;
	new_data->keep = 0;
	new = ft_lstnew(new_data);
	return (new);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0xc
popq %rdi
callq 0x1080
testq %rax, %rax
je 0x134c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3087
movl %eax, (%rbx)
andq $0x0, 0x4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e73
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_a
void		ft_swap_a(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp_1 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp_2->next = NULL;
	new_list = lists->list_a;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_a = new_list;
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x13b0
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x13a7
movq %rdi, %rbx
andq $0x0, 0x8(%rsi)
movq 0x8(%r14), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2eb8
movq %r15, %rdi
movq %r14, %rsi
callq 0x2eb8
movq (%r15), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_swap.c
// Function: ft_swap_b
void		ft_swap_b(t_lists *lists)
{
	t_list	*tmp_1;
	t_list	*tmp_2;
	t_list	*new_list;

	new_list = NULL;
	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp_1 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_1->next = NULL;
	tmp_2 = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp_2->next = NULL;
	new_list = lists->list_b;
	ft_lstadd_front(&new_list, tmp_1);
	ft_lstadd_front(&new_list, tmp_2);
	lists->list_b = new_list;
}

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x140c
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x1403
movq %rdi, %rbx
andq $0x0, 0x8(%rsi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2eb8
movq %r15, %rdi
movq %r14, %rsi
callq 0x2eb8
movq (%r15), %rax
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_push.c
// Function: ft_push_b
void	ft_push_b(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_a)
		return ;
	tmp = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp->next = NULL;
	ft_lstadd_front(&lists->list_b, tmp);
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1459
movq 0x8(%rsi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rsi)
addq $0x8, %rdi
jmp 0x2eb8
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_a
void	ft_rotate_a(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = lists->list_a;
	lists->list_a = lists->list_a->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_a, tmp);
}

// Assembly:
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x147a
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x147a
movq %rax, (%rdi)
andq $0x0, 0x8(%rsi)
jmp 0x2f68
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_rotate.c
// Function: ft_rotate_b
void	ft_rotate_b(t_lists *lists)
{
	t_list		*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = lists->list_b;
	lists->list_b = lists->list_b->next;
	tmp->next = NULL;
	ft_lstadd_back(&lists->list_b, tmp);
}

// Assembly:
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x149e
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x149e
addq $0x8, %rdi
movq %rax, (%rdi)
andq $0x0, 0x8(%rsi)
jmp 0x2f68
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_a
void	del_last_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_a;
	while (i < (ft_lstsize(lists->list_a) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %r14
movq (%r14), %r14
movq (%rbx), %rdi
callq 0x2f03
addl $-0x2, %eax
cmpl %eax, %ebp
jge 0x14da
incl %ebp
addq $0x8, %r14
jmp 0x14c0
andq $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: del_last_b
void	del_last_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;

	i = 0;
	cursor = lists->list_b;
	while (i < (ft_lstsize(lists->list_b) - 2))
	{
		i++;
		cursor = cursor->next;
	}
	cursor->next = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x8, %rbx
xorl %ebp, %ebp
movq %rbx, %r14
movq (%r14), %r14
movq (%rbx), %rdi
callq 0x2f03
addl $-0x2, %eax
cmpl %eax, %ebp
jge 0x150e
incl %ebp
addq $0x8, %r14
jmp 0x14f4
andq $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_a
void	ft_rev_rotate_a(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_a || !lists->list_a->next)
		return ;
	tmp = ft_lstlast(lists->list_a);
	del_last_a(lists);
	ft_lstadd_front(&lists->list_a, tmp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1550
cmpq $0x0, 0x8(%rdi)
je 0x1550
callq 0x2f38
movq %rax, %r14
movq %rbx, %rdi
callq 0x14b4
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2eb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_reverse_rotate.c
// Function: ft_rev_rotate_b
void	ft_rev_rotate_b(t_lists *lists)
{
	t_list	*tmp;

	if (!lists->list_b || !lists->list_b->next)
		return ;
	tmp = ft_lstlast(lists->list_b);
	del_last_b(lists);
	ft_lstadd_front(&lists->list_b, tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1594
cmpq $0x0, 0x8(%rdi)
je 0x1594
leaq 0x8(%rbx), %r14
callq 0x2f38
movq %rax, %r15
movq %rbx, %rdi
callq 0x14e4
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2eb8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_a
void	ft_print_a(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_a;
	printf("\033[1;34mLIST A :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
leaq 0x2a79(%rip), %rdi      # 0x4033
callq 0x1040
leaq 0x2a8d(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x2aa5(%rip), %rdi      # 0x4077
callq 0x1040
leaq 0x2a43(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
testq %r14, %r14
je 0x1601
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
jmp 0x15e0
leaq 0x2a95(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_b
void	ft_print_b(t_lists *lists)
{
	int		i;
	t_list	*cursor;
	t_data	*t;

	i = 0;
	cursor = lists->list_b;
	printf("\033[1;33mLIST B :\n");
	printf("___________________________________\n");
	printf("|   INDICE  |   NUMBER  |INDEX FINAL|\n");
	while (cursor)
	{
		t = cursor->content;
		printf("|%11d|%11d|%11d|\n", i, t->value, t->index);
		i++;
		cursor = cursor->next;
	}
	printf("___________________________________\033[0;m\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
leaq 0x2a23(%rip), %rdi      # 0x4043
callq 0x1040
leaq 0x2a27(%rip), %rdi      # 0x4053
callq 0x1040
leaq 0x2a3f(%rip), %rdi      # 0x4077
callq 0x1040
leaq 0x29dd(%rip), %rbx      # 0x4021
xorl %ebp, %ebp
testq %r14, %r14
je 0x1667
movq (%r14), %rax
movl (%rax), %edx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1060
incl %ebp
movq 0x8(%r14), %r14
jmp 0x1646
leaq 0x2a2f(%rip), %rdi      # 0x409d
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_print_lists.c
// Function: ft_print_both
void	ft_print_both(t_lists *lists)
{
	ft_print_a(lists);
	printf("-------------------------------------\n");
	ft_print_b(lists);
	printf("\033[1;31m=====================================\033[0;m\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x15ac
leaq 0x2a3f(%rip), %rdi      # 0x40c6
callq 0x1040
movq %rbx, %rdi
callq 0x1611
leaq 0x2a51(%rip), %rdi      # 0x40ec
popq %rbx
jmp 0x1040
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: use_commands
void	use_commands(t_list *commands, t_lists *lists)
{
	t_list	*cursor;

	cursor = commands->next;
	while (cursor)
	{
		swap_fct(lists, cursor);
		push_fct(lists, cursor);
		rotate_fct(lists, cursor);
		rev_rotate_fct(lists, cursor);
		cursor = cursor->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x16e5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1884
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1952
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19bc
jmp 0x16ae
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/ft_command.c
// Function: ft_read_command
int		ft_read_command(t_list *commands)
{
	int		ret;
	char	*line;

	while ((ret = get_next_line(0, &line)) == 1)
	{
		if (!ft_strcmp(line, "sa") || !ft_strcmp(line, "sb")
		|| !ft_strcmp(line, "ss"))
			get_swap(commands, line);
		else if (!ft_strcmp(line, "pa") || !ft_strcmp(line, "pb"))
			get_push(commands, line);
		else if (!ft_strcmp(line, "ra") || !ft_strcmp(line, "rb")
		|| !ft_strcmp(line, "rr"))
			get_rotate(commands, line);
		else if (!ft_strcmp(line, "rra") ||
		!ft_strcmp(line, "rrb") || !ft_strcmp(line, "rrr"))
			get_rev_rotate(commands, line);
		else
		{
			get_next_line(-42, &line);
			free(line);
			return (-1);
		}
		free(line);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
leaq 0x2a19(%rip), %r15      # 0x411e
leaq 0x2a15(%rip), %r12      # 0x4121
leaq 0x2a11(%rip), %r13      # 0x4124
xorl %ebp, %ebp
xorl %edi, %edi
movq %r14, %rsi
callq 0x1ced
cmpl $0x1, %eax
jne 0x1871
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x323e
testl %eax, %eax
je 0x1822
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x323e
testl %eax, %eax
je 0x1822
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x323e
testl %eax, %eax
je 0x1822
movq (%rsp), %rdi
leaq 0x29b8(%rip), %rsi      # 0x4127
callq 0x323e
testl %eax, %eax
je 0x183c
movq (%rsp), %rdi
leaq 0x29a3(%rip), %rsi      # 0x412a
callq 0x323e
testl %eax, %eax
je 0x183c
movq (%rsp), %rdi
leaq 0x298f(%rip), %rsi      # 0x412e
callq 0x323e
testl %eax, %eax
je 0x184a
movq (%rsp), %rdi
leaq 0x297b(%rip), %rsi      # 0x4132
callq 0x323e
testl %eax, %eax
je 0x184a
movq (%rsp), %rdi
leaq 0x2967(%rip), %rsi      # 0x4136
callq 0x323e
testl %eax, %eax
je 0x184a
movq (%rsp), %rdi
leaq 0x294a(%rip), %rsi      # 0x412d
callq 0x323e
testl %eax, %eax
je 0x1814
movq (%rsp), %rdi
leaq 0x293a(%rip), %rsi      # 0x4131
callq 0x323e
testl %eax, %eax
je 0x1814
movq (%rsp), %rdi
leaq 0x292a(%rip), %rsi      # 0x4135
callq 0x323e
testl %eax, %eax
jne 0x1858
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1bb2
jmp 0x182e
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1ad2
movq (%rsp), %rdi
callq 0x1030
jmp 0x1715
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1a78
jmp 0x182e
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1b42
jmp 0x182e
pushq $-0x2a
popq %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x1ced
movq (%rbx), %rdi
callq 0x1030
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: swap_fct
void	swap_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "sa"))
		ft_swap_a(lists);
	else if (!ft_strcmp(commands->content, "sb"))
		ft_swap_b(lists);
	else if (!ft_strcmp(commands->content, "ss"))
		ft_swap_ss(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2886(%rip), %rsi      # 0x411e
callq 0x323e
testl %eax, %eax
je 0x18cf
movq (%r14), %rdi
leaq 0x2876(%rip), %rsi      # 0x4121
callq 0x323e
testl %eax, %eax
je 0x18de
movq (%r14), %rdi
leaq 0x2866(%rip), %rsi      # 0x4124
callq 0x323e
testl %eax, %eax
je 0x18ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1358
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13b1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x140d
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: push_fct
void	push_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "pa"))
		ft_push_a(lists);
	else if (!ft_strcmp(commands->content, "pb"))
		ft_push_b(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2817(%rip), %rsi      # 0x4127
callq 0x323e
testl %eax, %eax
je 0x1934
movq (%r14), %rdi
leaq 0x2807(%rip), %rsi      # 0x412a
callq 0x323e
testl %eax, %eax
je 0x1943
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1420
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x143c
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rotate_fct
void	rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "ra"))
		ft_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rb"))
		ft_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rr"))
		ft_rotate_rr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x27c8(%rip), %rsi      # 0x412e
callq 0x323e
testl %eax, %eax
jne 0x1977
movq %rbx, %rdi
callq 0x145c
movq (%r14), %rdi
leaq 0x27b1(%rip), %rsi      # 0x4132
callq 0x323e
testl %eax, %eax
jne 0x1992
movq %rbx, %rdi
callq 0x147b
movq (%r14), %rdi
leaq 0x279a(%rip), %rsi      # 0x4136
callq 0x323e
testl %eax, %eax
je 0x19ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x149f
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/checker_func.c
// Function: rev_rotate_fct
void	rev_rotate_fct(t_lists *lists, t_list *commands)
{
	if (!ft_strcmp(commands->content, "rra"))
		ft_rev_rotate_a(lists);
	if (!ft_strcmp(commands->content, "rrb"))
		ft_rev_rotate_b(lists);
	if (!ft_strcmp(commands->content, "rrr"))
		ft_rev_rotate_rrr(lists);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x275d(%rip), %rsi      # 0x412d
callq 0x323e
testl %eax, %eax
jne 0x19e1
movq %rbx, %rdi
callq 0x1518
movq (%r14), %rdi
leaq 0x2746(%rip), %rsi      # 0x4131
callq 0x323e
testl %eax, %eax
jne 0x19fc
movq %rbx, %rdi
callq 0x1558
movq (%r14), %rdi
leaq 0x272f(%rip), %rsi      # 0x4135
callq 0x323e
testl %eax, %eax
je 0x1a17
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x159a
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/checker/check_sort.c
// Function: check_sort
void		check_sort(int ac, t_lists *lists)
{
	int		value;
	t_list	*cursor;
	t_data	*this;
	t_data	*the_next;

	cursor = lists->list_a;
	if (ft_lstsize(cursor) != (ac - 1))
	{
		printf("\033[1;31mKO\n\033[0;m");
		return ;
	}
	while (cursor->next)
	{
		this = cursor->content;
		value = this->value;
		the_next = cursor->next->content;
		if (value > the_next->value)
		{
			printf("\033[1;31mKO\n\033[0;m");
			return ;
		}
		cursor = cursor->next;
	}
	printf("\033[1;32mOK\n\033[0;m");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movq (%rsi), %rbx
movq %rbx, %rdi
callq 0x2f03
decl %ebp
leaq 0x26f8(%rip), %rdi      # 0x4139
cmpl %ebp, %eax
jne 0x1a69
leaq 0x26fd(%rip), %rax      # 0x4149
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1a66
movq (%rbx), %rdx
movl (%rdx), %edx
movq (%rcx), %rsi
movq %rcx, %rbx
cmpl (%rsi), %edx
jle 0x1a4c
jmp 0x1a69
movq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1060
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_first_lines
char	*append_first_lines(char *str, char **line, int i)
{
	char *tmp;

	str[i] = '\0';
	*line = ft_strdup(str);
	tmp = ft_strdup(str + (i + 1));
	free(str);
	str = tmp;
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
leaq (%rdi,%rax), %r15
incq %r15
movb $0x0, -0x1(%r15)
callq 0x31c0
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x31c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: append_next_lines
char	*append_next_lines(char *str, char **line, int i, int output)
{
	if (output == 0 && i != -1)
	{
		append_first_lines(str, line, i);
		return (str);
	}
	else if (output == 0)
	{
		*line = ft_strdup(str);
		free(str);
		str = NULL;
		return (str);
	}
	free(str);
	str = NULL;
	return (str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
setne %al
cmpl $-0x1, %edx
sete %sil
orb %al, %sil
jne 0x1c8a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c24
jmp 0x1ca3
testl %ecx, %ecx
jne 0x1c99
movq %rbx, %rdi
callq 0x31c0
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/gnl/get_next_line.c
// Function: get_next_line
int		get_next_line(int fd, char **line)
{
	static char		*str = NULL;
	char			buffer[BUFFER_SIZE + 1];
	int				output;
	int				i;

	i = 0;
	if (fd < 0 && str)
	{
		free(str);
		return (-1);
	}
	while (((output = read(fd, buffer, BUFFER_SIZE)) && output > 0) || i != -1)
	{
		buffer[output] = '\0';
		str = ft_join(str, buffer);
		i = check_line(str);
		if (i >= 0)
		{
			str = append_first_lines(str, line, i);
			return (1);
		}
		if (is_output_null(output, str) == 0)
			return (0);
	}
	return (read_finished(str, line, output, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebp
testl %edi, %edi
sets %al
movq 0x535f(%rip), %rdi      # 0x7068
testq %rdi, %rdi
setne %cl
testb %cl, %al
je 0x1d1f
callq 0x1030
pushq $-0x1
jmp 0x1dbe
movq %rsi, %rbx
xorl %r13d, %r13d
movq %rsp, %r14
pushq $0x20
popq %r15
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1070
movq %rax, %r12
testl %r12d, %r12d
setle %al
cmpl $-0x1, %r13d
sete %cl
testb %al, %cl
jne 0x1d90
movslq %r12d, %rax
movb $0x0, (%rsp,%rax)
movq 0x530d(%rip), %rdi      # 0x7068
movq %r14, %rsi
callq 0x1dd0
movq %rax, 0x52fe(%rip)      # 0x7068
movq %rax, %rdi
callq 0x1e61
movl %eax, %r13d
movq 0x52ec(%rip), %rsi      # 0x7068
testl %eax, %eax
jns 0x1da7
movl %r12d, %edi
callq 0x1cae
testl %eax, %eax
jne 0x1d2c
xorl %eax, %eax
jmp 0x1dbf
movq 0x52d1(%rip), %rdi      # 0x7068
pushq $-0x1
popq %rcx
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1cc6
jmp 0x1dbf
movq %rsi, %rdi
movq %rbx, %rsi
movl %r13d, %edx
callq 0x1c24
movq %rax, 0x52ac(%rip)      # 0x7068
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/gnl/get_next_line_utils.c
// Function: ft_join
char	*ft_join(char *s1, char *s2)
{
	size_t		i;
	size_t		j;
	size_t		len1;
	char		*str;

	if (s1 == NULL)
		len1 = 0;
	else
		len1 = ft_strlen(s1);
	if (!(str = malloc(sizeof(char) * (len1 + ft_strlen(s2) + 1))))
		return (NULL);
	i = 0;
	j = 0;
	while (i < len1)
	{
		str[i] = s1[i];
		i++;
	}
	while (j < ft_strlen(s2))
		str[i++] = s2[j++];
	str[i] = '\0';
	free(s1);
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1df1
movq %rbx, %rdi
callq 0x2fbc
movq %rax, %r12
jmp 0x1df4
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2fbc
leaq (%r12,%rax), %rdi
incq %rdi
callq 0x1080
movq %rax, %r15
testq %rax, %rax
je 0x1e54
xorl %eax, %eax
cmpq %rax, %r12
je 0x1e23
movb (%rbx,%rax), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x1e12
movq %r15, %r13
addq %r12, %r13
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x2fbc
cmpq %rax, %r12
jae 0x1e47
movb (%r14,%r12), %al
movb %al, (%r13,%r12)
incq %r12
jmp 0x1e2c
movb $0x0, (%r12,%r13)
movq %rbx, %rdi
callq 0x1030
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/get_index.c
// Function: get_index
void	get_index(t_list *l_a)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = l_a;
	while (cursor)
	{
		this = cursor->content;
		index = comp_value(l_a, this);
		this->index = index;
		cursor = cursor->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r15
testq %r15, %r15
je 0x1ec3
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e7c
movl %eax, 0x4(%r14)
movq 0x8(%r15), %r15
jmp 0x1ea6
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: first_in_chunk
int		first_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		ret;

	cursor = la;
	this = cursor->content;
	ret = 0;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			return (ret);
		ret++;
		cursor = cursor->next;
	}
	return (-1);
}

// Assembly:
xorl %ecx, %ecx
pushq $-0x1
popq %rax
testq %rdx, %rdx
je 0x1f56
movq (%rdx), %r8
movl 0x4(%r8), %r8d
cmpl %edi, %r8d
setge %r9b
cmpl %esi, %r8d
setle %r8b
testb %r8b, %r9b
jne 0x1f54
incl %ecx
movq 0x8(%rdx), %rdx
jmp 0x1f2d
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: last_in_chunk
int		last_in_chunk(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;
	int		index;

	cursor = la;
	this = cursor->content;
	index = -1;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			index = this->index;
		cursor = cursor->next;
	}
	if (index != -1)
		return (how_many_rotate(la, index) - 1);
	return (-1);
}

// Assembly:
pushq %rax
movl %esi, %eax
pushq $-0x1
popq %rsi
movq %rdx, %rcx
testq %rcx, %rcx
je 0x1f83
movq (%rcx), %r8
movl 0x4(%r8), %r8d
cmpl %eax, %r8d
movl %r8d, %r9d
cmovgl %esi, %r9d
movq 0x8(%rcx), %rcx
cmpl %edi, %r8d
cmovgel %r9d, %esi
jmp 0x1f60
cmpl $-0x1, %esi
je 0x1f94
movq %rdx, %rdi
callq 0x2d28
decl %eax
jmp 0x1f97
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/chunks.c
// Function: fill_b_per_chunk
void	fill_b_per_chunk(t_lists *l, int chunk1, int chunk2)
{
	int ra_nb;
	int rra_nb;
	int rb_nb;

	while (first_in_chunk(chunk1, chunk2, l->list_a) != -1)
	{
		ra_nb = first_in_chunk(chunk1, chunk2, l->list_a);
		rra_nb = ft_lstsize(l->list_a) -
		last_in_chunk(chunk1, chunk2, l->list_a);
		if (ft_lstsize(l->list_b) > 1)
			rb_nb = how_many_rotate(l->list_b,
			chose_index_to_push(l, chunk1, chunk2)) - 1;
		ra_or_rra_hundred(l, ra_nb, rra_nb, rb_nb);
		write_pb(l);
		if (chose_index_to_push(l, chunk1, chunk2) == -1)
			write_rb(l);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq (%r14), %r15
movl %ebp, %edi
movl %ebx, %esi
movq %r15, %rdx
callq 0x1f28
cmpl $-0x1, %eax
je 0x2050
movl %eax, %r12d
movq %r15, %rdi
callq 0x2f03
movl %eax, %r13d
movq (%r14), %rdx
movl %ebp, %edi
movl %ebx, %esi
callq 0x1f57
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x2f03
cmpl $0x2, %eax
jl 0x2012
movq 0x8(%r14), %rax
movq %rax, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2311
movq (%rsp), %rdi
movl %eax, %esi
callq 0x2d28
decl %eax
movl %eax, (%rsp)
subl %r15d, %r13d
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl (%rsp), %ecx
callq 0x2c79
movq %r14, %rdi
callq 0x20c4
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2311
cmpl $-0x1, %eax
jne 0x1fab
movq %r14, %rdi
callq 0x2145
jmp 0x1fab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/smaller_index.c
// Function: new_smaller
int		new_smaller(t_list *la, int smaller_a)
{
	int		i;
	t_list	*cursor;
	t_data	*this;
	int		new_smaller;

	i = -1;
	new_smaller = smaller_a;
	cursor = la;
	while (i < get_good_smaller(la, smaller_a))
	{
		this = cursor->content;
		new_smaller = this->index;
		cursor = cursor->next;
		i++;
	}
	return (new_smaller);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x21b8
pushq $-0x1
popq %rcx
cmpl %eax, %ecx
jge 0x21f9
movq (%rbx), %rdx
movq 0x8(%rbx), %rbx
movl 0x4(%rdx), %ebp
incl %ecx
jmp 0x21e7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: first_in_chunk_index
int		first_in_chunk_index(int ch1, int ch2, t_list *la)
{
	t_list	*cursor;
	t_data	*this;

	cursor = la;
	this = cursor->content;
	while (cursor)
	{
		this = cursor->content;
		if (this->index >= ch1 && this->index <= ch2)
			return (this->index);
		cursor = cursor->next;
	}
	return (-1);
}

// Assembly:
pushq $-0x1
popq %rcx
testq %rdx, %rdx
je 0x2245
movq (%rdx), %rax
movl 0x4(%rax), %eax
cmpl %edi, %eax
setge %r8b
cmpl %esi, %eax
setle %r9b
testb %r9b, %r8b
jne 0x2247
movq 0x8(%rdx), %rdx
jmp 0x2223
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: does_lb_exist
int		does_lb_exist(t_lists *l, int idx_to_push)
{
	if (ft_lstsize(l->list_b) > 1)
	{
		if (smaller(l->list_b) > idx_to_push)
			return (-1);
		else if (bigger(l->list_b) < idx_to_push)
			return (bigger(l->list_b));
		else
			return (between_index(l->list_b, idx_to_push));
	}
	else if (ft_lstsize(l->list_b) == 1)
	{
		if (smaller(l->list_b) > idx_to_push)
			return (-1);
		else if (bigger(l->list_b) < idx_to_push)
			return (bigger(l->list_b));
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x2f03
movq 0x8(%r14), %rdi
cmpl $0x2, %eax
jl 0x22d4
callq 0x219c
cmpl %ebx, %eax
jg 0x22ed
movq 0x8(%r14), %rdi
callq 0x2204
movq 0x8(%r14), %rdi
cmpl %ebx, %eax
jl 0x2308
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x226c
callq 0x2f03
xorl %ebp, %ebp
cmpl $0x1, %eax
jne 0x22f0
movq 0x8(%r14), %rdi
callq 0x219c
cmpl %ebx, %eax
jle 0x22f7
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%r14), %rdi
callq 0x2204
cmpl %ebx, %eax
jge 0x22f0
movq 0x8(%r14), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2204
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/is_between_index.c
// Function: chose_index_to_push
int		chose_index_to_push(t_lists *l, int ch1, int ch2)
{
	int		idx_to_push;
	int		ra;
	int		rra;

	ra = first_in_chunk(ch1, ch2, l->list_a);
	rra = ft_lstsize(l->list_a) -
	last_in_chunk(ch1, ch2, l->list_a);
	if (ra < rra)
		idx_to_push = first_in_chunk_index(ch1, ch2, l->list_a);
	else
		idx_to_push = last_in_chunk_index(ch1, ch2, l->list_a);
	return (does_lb_exist(l, idx_to_push));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdx
movl %esi, %edi
movl %ebp, %esi
callq 0x1f28
movl %eax, %r15d
movq (%rbx), %rdi
callq 0x2f03
movl %eax, %r12d
movq (%rbx), %rdx
movl %r14d, %edi
movl %ebp, %esi
callq 0x1f57
subl %eax, %r12d
movq (%rbx), %rdx
movl %r14d, %edi
movl %ebp, %esi
cmpl %r12d, %r15d
jge 0x235f
callq 0x2220
jmp 0x2364
callq 0x2248
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2294
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_three.c
// Function: how_sort_three
void		how_sort_three(int first, int second, int third, t_lists *l)
{
	if (first > second && first < third)
		write_sa(l);
	else if (first > second && first > third && second < third)
		write_ra(l);
	else if (first < second && first > third)
		write_rra(l);
	else if (first > second && first > third && second > third)
	{
		write_sa(l);
		write_rra(l);
	}
	else if (first < second && first < third && second > third)
	{
		write_sa(l);
		write_ra(l);
	}
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
cmpl %esi, %edi
setle %al
cmpl %edx, %edi
setge %cl
orb %al, %cl
jne 0x2393
movq %rbx, %rdi
popq %rbx
jmp 0x2060
cmpl %esi, %edi
setg %cl
cmpl %edx, %edi
setg %al
andb %cl, %al
xorb $0x1, %al
cmpl %edx, %esi
setge %cl
orb %al, %cl
jne 0x23b3
movq %rbx, %rdi
popq %rbx
jmp 0x212c
cmpl %edx, %edi
setle %cl
cmpl %esi, %edi
setge %r8b
orb %cl, %r8b
je 0x23d4
cmpl %edx, %esi
setle %cl
orb %al, %cl
jne 0x23dd
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
popq %rbx
jmp 0x20e0
cmpl %edx, %esi
jle 0x23f3
cmpl %esi, %edi
jge 0x23f3
cmpl %edx, %edi
jge 0x23f3
movq %rbx, %rdi
callq 0x2060
jmp 0x23aa
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_three.c
// Function: sorting_three
void		sorting_three(t_lists *l)
{
	int		first;
	int		second;
	int		third;
	t_data	*this;

	if (ft_lstsize(l->list_a) == 1)
		return ;
	else if (ft_lstsize(l->list_a) == 2)
	{
		if (check_sort_ps(l) != 0)
			write_sa(l);
		return ;
	}
	else
	{
		this = l->list_a->content;
		first = this->index;
		this = l->list_a->next->content;
		second = this->index;
		this = l->list_a->next->next->content;
		third = this->index;
		how_sort_three(first, second, third, l);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2f03
cmpl $0x1, %eax
jne 0x2408
popq %rbx
retq
movq (%rbx), %rdi
callq 0x2f03
cmpl $0x2, %eax
jne 0x242a
movq %rbx, %rdi
callq 0x2178
testl %eax, %eax
je 0x2406
movq %rbx, %rdi
popq %rbx
jmp 0x2060
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %edi
movq (%rax), %rcx
movq 0x8(%rax), %rax
movl 0x4(%rcx), %esi
movq (%rax), %rax
movl 0x4(%rax), %edx
movq %rbx, %rcx
popq %rbx
jmp 0x2378
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_one
void	check_still_in_b_one(t_lists *l, int first, int second)
{
	if (first == 1)
	{
		write_pa(l);
		write_pa(l);
	}
	else if (first == 2)
	{
		write_pa(l);
		write_sa(l);
		if (second == 1)
		{
			write_pa(l);
			write_sa(l);
		}
		else
			write_pa(l);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x2476
cmpl $0x1, %esi
jne 0x24a3
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20ab
movl %edx, %ebp
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x20ab
cmpl $0x1, %ebp
jne 0x24a3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2060
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_two
void	check_still_in_b_two(t_lists *l, int first, int second)
{
	if (first == 3)
	{
		write_rra(l);
		write_pa(l);
		if (second == 0)
		{
			write_ra(l);
			write_ra(l);
			write_pa(l);
		}
		else if (second == 1)
		{
			write_ra(l);
			write_ra(l);
			write_pa(l);
			write_sa(l);
		}
		else if (second == 2)
		{
			pa_ra(l);
			write_ra(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x3, %esi
jne 0x24f0
movl %edx, %ebp
movq %rdi, %rbx
callq 0x20e0
movq %rbx, %rdi
callq 0x20ab
cmpl $0x2, %ebp
je 0x251d
cmpl $0x1, %ebp
je 0x24f7
testl %ebp, %ebp
jne 0x24f0
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20ab
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2060
movq %rbx, %rdi
callq 0x26f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x212c
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: check_still_in_b_three
void	check_still_in_b_three(t_lists *l, int first, int second)
{
	if (first == 4)
	{
		write_pa(l);
		if (second == 3)
			pa_ra(l);
		else if (second == 2)
		{
			write_rra(l);
			pa_ra(l);
			write_ra(l);
		}
		else if (second == 1)
		{
			write_ra(l);
			write_pa(l);
			write_sa(l);
		}
		else if (second == 0)
		{
			write_ra(l);
			write_pa(l);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x4, %esi
jne 0x2572
movl %edx, %ebp
movq %rdi, %rbx
callq 0x20ab
cmpl $0x3, %ebp
ja 0x2572
movl %ebp, %eax
leaq 0x1c29(%rip), %rcx      # 0x417c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20ab
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x26f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x212c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26f4
movq %rbx, %rdi
callq 0x212c
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: sort_four
void	sort_four(int index, t_lists *l)
{
	if (index == 0)
		write_pa(l);
	else if (index == 1)
	{
		write_pa(l);
		write_sa(l);
	}
	else if (index == 2)
	{
		write_rra(l);
		write_pa(l);
		write_ra(l);
		write_ra(l);
	}
	else if (index == 3)
	{
		write_pa(l);
		write_ra(l);
	}
}

// Assembly:
pushq %rbx
cmpl $0x3, %edi
ja 0x2623
movq %rsi, %rbx
movl %edi, %eax
leaq 0x1bb7(%rip), %rcx      # 0x418c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x20ab
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
callq 0x212c
jmp 0x2609
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
popq %rbx
jmp 0x212c
movq %rbx, %rdi
callq 0x20ab
movq %rbx, %rdi
popq %rbx
jmp 0x2060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_five.c
// Function: sorting_five
void	sorting_five(t_lists *l)
{
	int		how_many_pb;
	t_data	*first_b;
	t_data	*sec_b;

	how_many_pb = ft_lstsize(l->list_a);
	if (check_sort_ps(l) != 0)
	{
		while (how_many_pb-- > 3)
			write_pb(l);
		sorting_three(l);
		first_b = l->list_b->content;
		if (ft_lstsize(l->list_b) == 2)
		{
			sec_b = l->list_b->next->content;
			if (first_b->index < sec_b->index)
				write_sb(l);
			first_b = l->list_b->content;
			sec_b = l->list_b->next->content;
			check_still_in_b_one(l, first_b->index, sec_b->index);
			check_still_in_b_two(l, first_b->index, sec_b->index);
			check_still_in_b_three(l, first_b->index, sec_b->index);
		}
		else
			sort_four(first_b->index, l);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2f03
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2178
testl %eax, %eax
jne 0x265a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
decl %ebp
movq %rbx, %rdi
callq 0x20c4
cmpl $0x4, %ebp
jge 0x2650
movq %rbx, %rdi
callq 0x23f5
movq 0x8(%rbx), %rdi
movq (%rdi), %r15
callq 0x2f03
cmpl $0x2, %eax
jne 0x26dd
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %r14
movl 0x4(%r14), %edx
cmpl %edx, 0x4(%r15)
jge 0x26a4
movq %rbx, %rdi
callq 0x2079
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %r14
movl 0x4(%r14), %edx
movq (%rax), %r15
movl 0x4(%r15), %esi
movq %rbx, %rdi
callq 0x2450
movl 0x4(%r15), %esi
movl 0x4(%r14), %edx
movq %rbx, %rdi
callq 0x24aa
movl 0x4(%r15), %esi
movl 0x4(%r14), %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2533
movl 0x4(%r15), %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25c3
nop
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: init_chunks_h
void	init_chunks_h(t_chunk_h *ch, t_list *la)
{
	ch->chunk1 = ft_lstsize(la) / 7;
	ch->chunk2 = 2 * (ft_lstsize(la) / 7);
	ch->chunk3 = 3 * (ft_lstsize(la) / 7);
	ch->chunk4 = 4 * (ft_lstsize(la) / 7);
	ch->chunk5 = 5 * (ft_lstsize(la) / 7);
	ch->chunk6 = 6 * (ft_lstsize(la) / 7);
	ch->chunk7 = ft_lstsize(la) - 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f03
pushq $0x7
popq %rbp
cltd
idivl %ebp
movl %eax, (%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
addl %eax, %eax
movl %eax, 0x4(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
leal (%rax,%rax,2), %eax
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
shll $0x2, %eax
movl %eax, 0xc(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
leal (%rax,%rax,4), %eax
movl %eax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2f03
cltd
idivl %ebp
imull $0x6, %eax, %eax
movl %eax, 0x14(%rbx)
movq %r14, %rdi
callq 0x2f03
addl $-0x2, %eax
movl %eax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/WalterLuong[P]push_swap/srcs/push_swap/sort_hundred.c
// Function: refill_a_sorted
void	refill_a_sorted(t_lists *l)
{
	int		rb_nb;
	int		i;

	i = ft_lstsize(l->list_b);
	while (i > 0)
	{
		rb_nb = how_many_rotate(l->list_b, bigger(l->list_b)) - 1;
		if (rb_nb < ft_lstsize(l->list_b) / 2)
		{
			while (rb_nb-- > 0)
				write_rb(l);
			write_pa(l);
			i--;
		}
		else
		{
			while (rb_nb++ < ft_lstsize(l->list_b))
				write_rrb(l);
			write_pa(l);
			i--;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2f03
movl %eax, %ebp
pushq $0x2
popq %r15
testl %ebp, %ebp
jle 0x2815
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x2204
movq %r14, %rdi
movl %eax, %esi
callq 0x2d28
movl %eax, %r14d
leal -0x1(%r14), %r12d
movq 0x8(%rbx), %rdi
callq 0x2f03
cltd
idivl %r15d
cmpl %eax, %r14d
jg 0x27fb
testl %r12d, %r12d
jle 0x2809
decl %r12d
movq %rbx, %rdi
callq 0x2145
jmp 0x27de
incl %r12d
movq %rbx, %rdi
callq 0x20f9
movq 0x8(%rbx), %rdi
callq 0x2f03
cmpl %eax, %r12d
jl 0x27f0
movq %rbx, %rdi
callq 0x20ab
decl %ebp
jmp 0x27ab
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq