LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: f_truncate
FRESULT f_truncate (
	FIL* fp		/* Pointer to the file object */
)
{
	FRESULT res;
	FATFS *fs;
	DWORD ncl;


	res = validate(&fp->obj, &fs);	/* Check validity of the file object */
	if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
	if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);	/* Check access mode */

	if (fp->fptr < fp->obj.objsize) {	/* Process when fptr is not on the eof */
		if (fp->fptr == 0) {	/* When set file size to zero, remove entire cluster chain */
			res = remove_chain(&fp->obj, fp->obj.sclust, 0);
			fp->obj.sclust = 0;
		} else {				/* When truncate a part of the file, remove remaining clusters */
			ncl = get_fat(&fp->obj, fp->clust);
			res = FR_OK;
			if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
			if (ncl == 1) res = FR_INT_ERR;
			if (res == FR_OK && ncl < fs->n_fatent) {
				res = remove_chain(&fp->obj, ncl, fp->clust);
			}
		}
		fp->obj.objsize = fp->fptr;	/* Set file size to current read/write point */
		fp->flag |= FA_MODIFIED;
#if !FF_FS_TINY
		if (res == FR_OK && (fp->flag & FA_DIRTY)) {
			if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) {
				res = FR_DISK_ERR;
			} else {
				fp->flag &= (BYTE)~FA_DIRTY;
			}
		}
#endif
		if (res != FR_OK) ABORT(fs, res);
	}

	LEAVE_FF(fs, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %rsi
callq 0x23bb
movl %eax, %r14d
testl %eax, %eax
jne 0x344d
movzbl 0x21(%rbx), %r14d
testl %r14d, %r14d
jne 0x344d
movl $0x7, %r14d
testb $0x2, 0x20(%rbx)
je 0x344d
movq 0x28(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x18(%rbx), %rax
jae 0x344d
testq %rax, %rax
je 0x33de
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0x1fc1
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
cmpq %rcx, %rax
sete %dl
cmpq $0x1, %rax
movl $0x2, %r15d
cmovnel %edx, %r15d
testl %r15d, %r15d
jne 0x33f7
movq -0x20(%rbp), %rcx
xorl %r15d, %r15d
cmpq 0x20(%rcx), %rax
jae 0x33f7
movq 0x30(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ec8
movl %eax, %r15d
jmp 0x33f7
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1ec8
movl %eax, %r15d
movq $0x0, 0x10(%rbx)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movb 0x20(%rbx), %al
movl %eax, %ecx
orb $0x40, %cl
movb %cl, 0x20(%rbx)
testl %r15d, %r15d
jne 0x3441
xorl %r15d, %r15d
testb %al, %al
jns 0x3441
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edi
leaq 0x50(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl $0x1, %r15d
movl $0x1, %ecx
callq 0x1321
testl %eax, %eax
jne 0x3441
andb $0x7f, 0x20(%rbx)
xorl %r15d, %r15d
testl %r15d, %r15d
je 0x344d
movb %r15b, 0x21(%rbx)
movl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: sync_window
static
FRESULT sync_window (	/* Returns FR_OK or FR_DISK_ERR */
	FATFS* fs			/* Filesystem object */
)
{
	FRESULT res = FR_OK;


	if (fs->wflag) {	/* Is the disk access window dirty */
		if (disk_write(fs->pdrv, fs->win, fs->winsect, 1) == RES_OK) {	/* Write back the window */
			fs->wflag = 0;	/* Clear window dirty flag */
			if (fs->winsect - fs->fatbase < fs->fsize) {	/* Is it in the 1st FAT? */
				if (fs->n_fats == 2) disk_write(fs->pdrv, fs->win, fs->winsect + fs->fsize, 1);	/* Reflect it to 2nd FAT if needed */
			}
		} else {
			res = FR_DISK_ERR;
		}
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x3(%rdi)
je 0x37fe
movq %rdi, %rbx
movzbl 0x1(%rdi), %edi
leaq 0x58(%rbx), %r14
movq 0x50(%rbx), %rdx
movl $0x1, %r15d
movq %r14, %rsi
movl $0x1, %ecx
callq 0x1321
testl %eax, %eax
jne 0x3801
movb $0x0, 0x3(%rbx)
movq 0x28(%rbx), %rdx
movq 0x50(%rbx), %rax
movq %rax, %rcx
subq 0x38(%rbx), %rcx
cmpq %rdx, %rcx
jae 0x37fe
cmpb $0x2, 0x2(%rbx)
jne 0x37fe
movzbl 0x1(%rbx), %edi
addq %rax, %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x1321
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: dir_clear
static
FRESULT dir_clear (	/* Returns FR_OK or FR_DISK_ERR */
	FATFS *fs,		/* Filesystem object */
	DWORD clst		/* Directory table to clear */
)
{
	DWORD sect;
	UINT n, szb;
	BYTE *ibuf;


	if (sync_window(fs) != FR_OK) return FR_DISK_ERR;	/* Flush disk access window */
	sect = clst2sect(fs, clst);		/* Top of the cluster */
	fs->winsect = sect;				/* Set window to top of the cluster */
	mem_set(fs->win, 0, SS(fs));	/* Clear window buffer */
#if FF_USE_LFN == 3		/* Quick table clear by using multi-secter write */
	/* Allocate a temporary buffer */
	for (szb = ((DWORD)fs->csize * SS(fs) >= MAX_MALLOC) ? MAX_MALLOC : fs->csize * SS(fs); szb > SS(fs) && !(ibuf = ff_memalloc(szb)); szb /= 2) ;
	if (szb > SS(fs)) {		/* Buffer allocated? */
		mem_set(ibuf, 0, szb);
		szb /= SS(fs);		/* Bytes -> Sectors */
		for (n = 0; n < fs->csize && disk_write(fs->pdrv, ibuf, sect + n, szb) == RES_OK; n += szb) ;	/* Fill the cluster with 0 */
		ff_memfree(ibuf);
	} else
#endif
	{
		ibuf = fs->win; szb = 1;	/* Use window buffer (single-sector writes may take a time) */
		for (n = 0; n < fs->csize && disk_write(fs->pdrv, ibuf, sect + n, szb) == RES_OK; n += szb) ;	/* Fill the cluster with 0 */
	}
	return (n == fs->csize) ? FR_OK : FR_DISK_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3796
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x38a7
addq $-0x2, %r14
movq 0x20(%rbx), %rax
addq $-0x2, %rax
xorl %r12d, %r12d
cmpq %rax, %r14
jae 0x3852
movzwl 0xa(%rbx), %eax
imulq %rax, %r14
addq 0x48(%rbx), %r14
jmp 0x3855
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
leaq 0x58(%rbx), %r15
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
cmpw $0x0, 0xa(%rbx)
je 0x389b
xorl %r12d, %r12d
movzbl 0x1(%rbx), %edi
leaq (%r14,%r12), %rdx
movq %r15, %rsi
movl $0x1, %ecx
callq 0x1321
testl %eax, %eax
jne 0x389b
incq %r12
movzwl 0xa(%rbx), %eax
cmpq %rax, %r12
jb 0x3876
movzwl 0xa(%rbx), %ecx
xorl %eax, %eax
cmpl %ecx, %r12d
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: check_fs
static
BYTE check_fs (	/* 0:FAT, 1:exFAT, 2:Valid BS but not FAT, 3:Not a BS, 4:Disk error */
	FATFS* fs,	/* Filesystem object */
	DWORD sect	/* Sector# (lba) to load and check if it is an FAT-VBR or not */
)
{
	fs->wflag = 0; fs->winsect = 0xFFFFFFFF;		/* Invaidate window */
	if (move_window(fs, sect) != FR_OK) return 4;	/* Load boot record */

	if (ld_word(fs->win + BS_55AA) != 0xAA55) return 3;	/* Check boot record signature (always placed here even if the sector size is >512) */

#if FF_FS_EXFAT
	if (!mem_cmp(fs->win + BS_JmpBoot, "\xEB\x76\x90" "EXFAT   ", 11)) return 1;	/* Check if exFAT VBR */
#endif
	if (fs->win[BS_JmpBoot] == 0xE9 || fs->win[BS_JmpBoot] == 0xEB || fs->win[BS_JmpBoot] == 0xE8) {	/* Valid JumpBoot code? */
		if (!mem_cmp(fs->win + BS_FilSysType, "FAT", 3)) return 0;		/* Is it an FAT VBR? */
		if (!mem_cmp(fs->win + BS_FilSysType32, "FAT32", 5)) return 0;	/* Is it an FAT32 VBR? */
	}
	return 2;	/* Valid BS but not FAT */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x3(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x50(%rdi)
callq 0x1f73
movl %eax, %ecx
movb $0x4, %al
testl %ecx, %ecx
jne 0x44b0
movb $0x3, %al
cmpw $0xaa55, 0x256(%rbx)    # imm = 0xAA55
jne 0x44b0
movzbl 0x58(%rbx), %eax
addl $0xffffff18, %eax       # imm = 0xFFFFFF18
cmpl $0x3, %eax
ja 0x44ae
cmpl $0x2, %eax
je 0x44ae
xorl %eax, %eax
leaq 0x1067(%rip), %rcx      # 0x54ce
movb 0x8e(%rbx,%rax), %dl
movb (%rax,%rcx), %sil
cmpl $0x2, %eax
je 0x447f
incq %rax
cmpb %sil, %dl
je 0x4467
cmpb %sil, %dl
je 0x44aa
xorl %eax, %eax
leaq 0x1045(%rip), %rcx      # 0x54d2
movb 0xaa(%rbx,%rax), %dl
movb (%rax,%rcx), %sil
cmpl $0x4, %eax
je 0x44a5
incq %rax
cmpb %sil, %dl
je 0x448d
cmpb %sil, %dl
jne 0x44ae
xorl %eax, %eax
jmp 0x44b0
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/checker/check.c
// Function: check
int	check(int *arr, int arr_size, t_list *instructions)
{
	t_deque			*stack[2];
	t_double_list	*cur;

	stack[0] = deque_init();
	stack[1] = deque_init();
	if (!stack[0] || !stack[1])
		error_exit();
	init_stack(stack[0], arr, arr_size);
	if (DEBUG == 1)
		display_stacks(stack, "Init a and b");
	sub(instructions, stack);
	if (stack[1]->size)
		return (0);
	cur = stack[0]->head;
	while (cur->next)
	{
		if (*((int *)cur->content) < *((int *)cur->next->content))
			return (0);
		cur = cur->next;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x24d4
movq %rax, (%rsp)
callq 0x24d4
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rsp)
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x11c6
callq 0x1605
movq (%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1866
testq %rbx, %rbx
je 0x11f0
movq %rsp, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x1892
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x11dc
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x10(%rcx)
jne 0x1223
movq (%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x121e
movq (%rcx), %rcx
movl (%rcx), %esi
movq (%rdx), %rdi
movq %rdx, %rcx
cmpl (%rdi), %esi
jge 0x1204
jmp 0x1223
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: has_duplicate
int	has_duplicate(int *arr, int arrsize)
{
	int	ct[2];

	ct[0] = -1;
	while (++ct[0] < arrsize - 1)
	{
		ct[1] = ct[0];
		while (++ct[1] < arrsize)
		{
			if (arr[ct[0]] == arr[ct[1]])
				return (1);
		}
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %esi
jl 0x126e
movl %esi, %ecx
decl %esi
movl $0x1, %edx
xorl %r8d, %r8d
movq %rdx, %rax
cmpq %rcx, %rax
jae 0x125a
movl (%rdi,%r8,4), %r9d
leaq 0x1(%rax), %r10
cmpl (%rdi,%rax,4), %r9d
movq %r10, %rax
jne 0x1242
jmp 0x1269
incq %r8
incq %rdx
xorl %eax, %eax
cmpq %rsi, %r8
jne 0x123f
jmp 0x126e
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: get_nbr_in_line
int	get_nbr_in_line(int **arr, int argc, char **argv)
{
	t_list	*lst;
	int		ct;

	lst = NULL;
	if (argc == 1)
		return (0);
	ct = 0;
	while (++ct < argc)
		put_in_list(&lst, argv[ct]);
	*arr = ft_malloc(ft_lstsize(lst), sizeof(int));
	if (!(*arr))
		error_exit();
	ct = 0;
	while (lst)
	{
		arr[0][ct++] = *((int *)(lst->content));
		lst = lst->next;
	}
	if (has_duplicate(arr[0], ct))
		error_exit();
	return (ct);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq $0x0, 0x8(%rsp)
xorl %r15d, %r15d
cmpl $0x1, %esi
je 0x13e3
movq %rdi, 0x10(%rsp)
jle 0x1347
movq %rdx, %r14
movl %esi, %ebp
movl $0x1, %ebx
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq (%r14,%rbx,8), %rax
movq %rax, (%rsp)
movb (%rax), %al
testb %al, %al
je 0x133b
movsbl %al, %edi
callq 0x24b8
movq (%rsp), %rcx
testl %eax, %eax
je 0x12d6
incq %rcx
movq %rcx, (%rsp)
jmp 0x131d
movsbl (%rcx), %edi
callq 0x1c68
testl %eax, %eax
je 0x1323
movl $0x1, %edi
movl $0x8, %esi
callq 0x1ecc
movq %rax, %r13
testq %rax, %rax
jne 0x12fe
callq 0x1605
movq %r15, %rdi
callq 0x151c
movl %eax, (%r13)
movq %r13, %rdi
callq 0x1e6c
movq %r12, %rdi
movq %rax, %rsi
callq 0x1dfc
movq (%rsp), %rax
jmp 0x12b7
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
je 0x12e2
cmpl $0x2b, %eax
je 0x12e2
callq 0x1605
jmp 0x131d
incq %rbx
cmpq %rbp, %rbx
jne 0x12af
movq 0x8(%rsp), %rdi
callq 0x1eb0
movslq %eax, %rdi
movl $0x4, %esi
callq 0x1ecc
movq 0x10(%rsp), %rbx
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1370
callq 0x1605
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x139c
movq (%rbx), %rcx
xorl %r15d, %r15d
movq (%rax), %rdx
movl (%rdx), %edx
movl %edx, (%rcx,%r15,4)
incq %r15
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x1380
jmp 0x139f
xorl %r15d, %r15d
cmpl $0x2, %r15d
jb 0x13e3
movq (%rbx), %rax
leal -0x1(%r15), %ecx
movl %r15d, %edx
movl $0x1, %esi
xorl %edi, %edi
movq %rsi, %r8
cmpq %rdx, %r8
jae 0x13d1
movl (%rax,%rdi,4), %r9d
leaq 0x1(%r8), %r10
cmpl (%rax,%r8,4), %r9d
movq %r10, %r8
jne 0x13b9
jmp 0x13de
incq %rdi
incq %rsi
cmpq %rcx, %rdi
jne 0x13b6
jmp 0x13e3
callq 0x1605
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/parse.c
// Function: check_instructions
void	check_instructions(char *str)
{
	if (!ft_strncmp(str, "sa", 3))
		return ;
	if (!ft_strncmp(str, "sb", 3))
		return ;
	if (!ft_strncmp(str, "ss", 3))
		return ;
	if (!ft_strncmp(str, "pa", 3))
		return ;
	if (!ft_strncmp(str, "pb", 3))
		return ;
	if (!ft_strncmp(str, "ra", 3))
		return ;
	if (!ft_strncmp(str, "rb", 3))
		return ;
	if (!ft_strncmp(str, "rr", 3))
		return ;
	if (!ft_strncmp(str, "rra", 4))
		return ;
	if (!ft_strncmp(str, "rrb", 4))
		return ;
	if (!ft_strncmp(str, "rrr", 4))
		return ;
	error_exit();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1c04(%rip), %rsi      # 0x3004
movl $0x3, %edx
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1bee(%rip), %rsi      # 0x3007
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1bd5(%rip), %rsi      # 0x300a
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1bbc(%rip), %rsi      # 0x300d
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1ba3(%rip), %rsi      # 0x3010
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b8b(%rip), %rsi      # 0x3014
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b77(%rip), %rsi      # 0x3018
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b63(%rip), %rsi      # 0x301c
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b42(%rip), %rsi      # 0x3013
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b2e(%rip), %rsi      # 0x3017
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
leaq 0x1b1a(%rip), %rsi      # 0x301b
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x1518
popq %rbx
jmp 0x1605
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/utils.c
// Function: ft_atoi_with_range
int	ft_atoi_with_range(char **str)
{
	long long int	ct[3];

	sub(ct, str);
	while (str[0][++ct[0]])
	{
		if (!ft_isdigit(str[0][ct[0]]))
		{
			*str += ct[0];
			if (ft_isspace(str[0][0]))
				return (ct[1] * ct[2]);
			error_exit();
		}
		ct[1] = 10LL * ct[1] + str[0][ct[0]] - '0';
		if ((ct[2] == 1LL && ct[1] > 2147483647LL) || (ct[2] == -1LL && ct[1]
				> 2147483648LL) || (ct[1] == 0LL
				&& ft_isdigit(str[0][ct[0] + 1])))
			error_exit();
	}
	*str += ct[0];
	return (ct[1] * ct[2]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movzbl (%rax), %r14d
cmpl $0x2d, %r14d
je 0x153b
cmpl $0x2b, %r14d
jne 0x154c
movsbl 0x1(%rax), %edi
callq 0x1c68
testl %eax, %eax
je 0x1600
leal -0x2b(%r14), %eax
xorl %r15d, %r15d
testb $-0x3, %al
sete %r15b
movq (%rbx), %rax
movb (%rax,%r15), %cl
testb %cl, %cl
je 0x15c6
movl $0x8000002f, %eax       # imm = 0x8000002F
leaq 0x1(%rax), %r13
cmpb $0x2d, %r14b
cmovneq %rax, %r13
xorl %r12d, %r12d
movsbl %cl, %edi
callq 0x1c68
testl %eax, %eax
je 0x15d1
leaq (%r12,%r12,4), %rcx
movq (%rbx), %rax
movsbq (%rax,%r15), %rdx
leaq (%rdx,%rcx,2), %rsi
cmpq %r13, %rsi
jg 0x1600
leaq (%rdx,%rcx,2), %r12
addq $-0x30, %r12
testq %r12, %r12
jne 0x15b5
movsbl 0x1(%rax,%r15), %edi
callq 0x1c68
testl %eax, %eax
jne 0x1600
movq (%rbx), %rax
movb 0x1(%rax,%r15), %cl
incq %r15
testb %cl, %cl
jne 0x1578
jmp 0x15c9
xorl %r12d, %r12d
addq %rax, %r15
movq %r15, (%rbx)
jmp 0x15e9
movq (%rbx), %rax
leaq (%rax,%r15), %rcx
movq %rcx, (%rbx)
movsbl (%rax,%r15), %edi
callq 0x24b8
testl %eax, %eax
je 0x1600
movl %r12d, %eax
negl %eax
cmpb $0x2d, %r14b
cmovnel %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1605
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: sa
void	sa(t_deque *stack[2])
{
	void	*ptr[2];

	if (stack[0]->size > 1)
	{
		ptr[0] = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		ptr[1] = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		deque_push_back(stack[0], ptr[0]);
		deque_push_back(stack[0], ptr[1]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x2, 0x10(%rdi)
jl 0x167f
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x257a
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24fb
movq (%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x24fb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: sb
void	sb(t_deque *stack[2])
{
	void	*ptr[2];

	if (stack[1]->size > 1)
	{
		ptr[0] = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		ptr[1] = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		deque_push_back(stack[1], ptr[0]);
		deque_push_back(stack[1], ptr[1]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpl $0x2, 0x10(%rdi)
jl 0x16d4
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x257a
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x24fb
movq 0x8(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x24fb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: pa
void	pa(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size > 0)
	{
		ptr = stack[1]->tail->content;
		deque_pop_back(stack[1], NULL);
		deque_push_back(stack[0], ptr);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
jle 0x171d
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation1.c
// Function: pb
void	pb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size > 0)
	{
		ptr = stack[0]->tail->content;
		deque_pop_back(stack[0], NULL);
		deque_push_back(stack[1], ptr);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
jle 0x1756
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: ra
void	ra(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size == 0)
		return ;
	ptr = stack[0]->tail->content;
	deque_pop_back(stack[0], NULL);
	deque_push_front(stack[0], ptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x1790
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x253d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rb
void	rb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size == 0)
		return ;
	ptr = stack[1]->tail->content;
	deque_pop_back(stack[1], NULL);
	deque_push_front(stack[1], ptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x17ca
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x257a
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x253d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rra
void	rra(t_deque *stack[2])
{
	void	*ptr;

	if (stack[0]->size == 0)
		return ;
	ptr = stack[0]->head->content;
	deque_pop_front(stack[0], NULL);
	deque_push_back(stack[0], ptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x1813
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x25c9
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation2.c
// Function: rrb
void	rrb(t_deque *stack[2])
{
	void	*ptr;

	if (stack[1]->size == 0)
		return ;
	ptr = stack[1]->head->content;
	deque_pop_front(stack[1], NULL);
	deque_push_back(stack[1], ptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
cmpl $0x0, 0x10(%rdi)
je 0x184c
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x25c9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24fb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation3.c
// Function: init_stack
void	init_stack(t_deque *stack, int *arr, int arr_size)
{
	int	ct;

	ct = -1;
	while (++ct < arr_size)
		deque_push_front(stack, arr + ct);
}

// Assembly:
testl %edx, %edx
jle 0x1891
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x253d
addq $0x4, %rbx
decq %r15
jne 0x1878
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation3.c
// Function: assigned_operation
void	assigned_operation(void *ptr, t_deque *stack[2])
{
	char	*str;

	str = ptr;
	if (!ft_strncmp(str, "sa", 3))
		sa(stack);
	if (!ft_strncmp(str, "sb", 3))
		sb(stack);
	if (!ft_strncmp(str, "ss", 3))
		ss(stack);
	if (!ft_strncmp(str, "pa", 3))
		pa(stack);
	if (!ft_strncmp(str, "pb", 3))
		pb(stack);
	if (!ft_strncmp(str, "ra", 3))
		ra(stack);
	if (!ft_strncmp(str, "rb", 3))
		rb(stack);
	if (!ft_strncmp(str, "rr", 3))
		rr(stack);
	if (!ft_strncmp(str, "rra", 4))
		rra(stack);
	if (!ft_strncmp(str, "rrb", 4))
		rrb(stack);
	if (!ft_strncmp(str, "rrr", 4))
		rrr(stack);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1761(%rip), %rsi      # 0x3004
movl $0x3, %edx
callq 0x1c7c
testl %eax, %eax
jne 0x18b9
movq %rbx, %rdi
callq 0x1634
leaq 0x1747(%rip), %rsi      # 0x3007
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x18d9
movq %rbx, %rdi
callq 0x1685
leaq 0x172a(%rip), %rsi      # 0x300a
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x18f9
movq %rbx, %rdi
callq 0x16da
leaq 0x170d(%rip), %rsi      # 0x300d
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x1919
movq %rbx, %rdi
callq 0x16ec
leaq 0x16f0(%rip), %rsi      # 0x3010
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x1939
movq %rbx, %rdi
callq 0x1725
leaq 0x16d4(%rip), %rsi      # 0x3014
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x1959
movq %rbx, %rdi
callq 0x1760
leaq 0x16b8(%rip), %rsi      # 0x3018
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x1979
movq %rbx, %rdi
callq 0x1798
leaq 0x169c(%rip), %rsi      # 0x301c
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x1999
movq %rbx, %rdi
callq 0x17d2
leaq 0x1673(%rip), %rsi      # 0x3013
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x19b9
movq %rbx, %rdi
callq 0x17e4
leaq 0x1657(%rip), %rsi      # 0x3017
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
jne 0x19d9
movq %rbx, %rdi
callq 0x181b
leaq 0x163b(%rip), %rsi      # 0x301b
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c7c
testl %eax, %eax
je 0x19f9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x17e4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181b
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation4.c
// Function: display_stacks
void	display_stacks(t_deque *stack[2], char *message)
{
	int				ct[3];
	t_double_list	*cur[2];

	sub(ct, cur, message, stack);
	while (--ct[0] >= 0)
	{
		if (ct[0] < stack[0]->size)
		{
			display_number_width11(*((int *)cur[0]->content));
			cur[0] = cur[0]->last;
		}
		else
			ft_putstr_fd("           ", 1);
		ft_putstr_fd("     ", 1);
		if (ct[0] < stack[1]->size)
		{
			display_number_width11(*((int *)cur[1]->content));
			cur[1] = cur[1]->last;
		}
		ft_putendl_fd("", 1);
	}
	ft_putendl_fd("__________a     __________b", 1);
	ft_putendl_fd("---------------------------", 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movl 0x10(%rax), %edi
movl 0x10(%rcx), %esi
callq 0x24a9
movl %eax, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x10(%rax), %ebp
movl 0x10(%rcx), %r12d
movl %ebp, %r13d
subl %r14d, %r13d
addl %r12d, %r13d
movq %r15, %rdi
movl $0x1, %esi
callq 0x1ce0
testl %r13d, %r13d
jle 0x1a82
addl %r12d, %ebp
subl %r14d, %ebp
incl %ebp
leaq 0x1665(%rip), %r15      # 0x30d3
movq %r15, %rdi
movl $0x1, %esi
callq 0x1ce0
decl %ebp
cmpl $0x1, %ebp
jg 0x1a6e
testl %r14d, %r14d
jle 0x1b11
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rbp
movq 0x8(%rax), %r15
leaq 0x158a(%rip), %r12      # 0x302b
leaq 0x162b(%rip), %r13      # 0x30d3
movq (%rbx), %rax
cmpl 0x10(%rax), %r14d
jle 0x1ac4
leaq 0x156d(%rip), %rdi      # 0x3025
movl $0x1, %esi
callq 0x1dc0
jmp 0x1ad2
movq (%r15), %rax
movl (%rax), %edi
callq 0x1b41
movq 0x10(%r15), %r15
movq %r12, %rdi
movl $0x1, %esi
callq 0x1dc0
movq 0x8(%rbx), %rax
cmpl 0x10(%rax), %r14d
jg 0x1af8
movq (%rbp), %rax
movl (%rax), %edi
callq 0x1b41
movq 0x10(%rbp), %rbp
decl %r14d
movq %r13, %rdi
movl $0x1, %esi
callq 0x1ce0
leal 0x1(%r14), %eax
cmpl $0x1, %eax
jg 0x1aa8
leaq 0x1519(%rip), %rdi      # 0x3031
movl $0x1, %esi
callq 0x1ce0
leaq 0x1524(%rip), %rdi      # 0x304d
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ce0
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/share/operation4.c
// Function: display_number_width11
static void	display_number_width11(int num)
{
	int	ct[2];

	ct[0] = 1;
	if (num < 0)
		ct[0]++;
	ct[1] = num;
	while (ct[1] > 9 || ct[1] < -9)
	{
		ct[0]++;
		ct[1] /= 10;
	}
	ct[0] = 11 - ct[0];
	while (ct[0]--)
		ft_putchar_fd(' ', 1);
	ft_putnbr_fd(num, 1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %ebp
shrl $0x1f, %ebp
incl %ebp
leal -0xa(%rbx), %eax
cmpl $-0x14, %eax
ja 0x1b7a
movl %ebx, %eax
incl %ebp
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
leal (%rcx,%rdx), %eax
addl %edx, %ecx
addl $-0xa, %ecx
cmpl $-0x13, %ecx
jb 0x1b57
cmpl $0xb, %ebp
je 0x1b95
addl $-0xb, %ebp
movl $0x20, %edi
movl $0x1, %esi
callq 0x1cb4
incl %ebp
jne 0x1b82
movl %ebx, %edi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d10
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/srcs/checker/main.c
// Function: main
int	main(int argc, char **argv)
{
	int		*arr;
	int		arr_size;
	t_list	*instructions;
	char	*line;

	arr_size = get_nbr_in_line(&arr, argc, argv);
	if (arr_size == 0)
		normal_exit();
	instructions = NULL;
	while (get_next_line(0, &line) == 1)
	{
		check_instructions(line);
		ft_lstadd_back(&instructions, ft_lstnew(line));
	}
	if (arr_size == 0)
		normal_exit();
	else if (check(arr, arr_size, instructions))
		ft_putendl_fd("OK", 1);
	else
		ft_putendl_fd("KO", 1);
	ft_free_all();
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x18(%rsp), %rdi
callq 0x126f
movl %eax, %ebx
testl %eax, %eax
jne 0x1bcb
callq 0x1626
movq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x1f08
cmpl $0x1, %eax
jne 0x1c1d
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rdi
callq 0x13f5
movq 0x8(%rsp), %rdi
callq 0x1e6c
movq %r14, %rdi
movq %rax, %rsi
callq 0x1dfc
xorl %edi, %edi
movq %r15, %rsi
callq 0x1f08
cmpl $0x1, %eax
je 0x1bef
testl %ebx, %ebx
je 0x1c3f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl %ebx, %esi
callq 0x118c
testl %eax, %eax
je 0x1c46
leaq 0x142c(%rip), %rdi      # 0x3069
jmp 0x1c4d
callq 0x1626
jmp 0x1c57
leaq 0x141f(%rip), %rdi      # 0x306c
movl $0x1, %esi
callq 0x1ce0
callq 0x1ef0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_strncmp.c
// Function: ft_strncmp
int	ft_strncmp(const char *ss1, const char *ss2, size_t n)
{
	unsigned char	*s1;
	unsigned char	*s2;

	s1 = (unsigned char *)ss1;
	s2 = (unsigned char *)ss2;
	if (!s1 || !s2)
		return (0);
	if (n == 0)
		return (0);
	if (*s1 == 0 || *s2 == 0 || *s1 != *s2)
		return (*s1 - *s2);
	s1++;
	s2++;
	return (ft_strncmp((char *)(s1), (char *)(s2), n - 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1, %rdx
setb %cl
xorl %eax, %eax
testq %rdi, %rdi
je 0x1caf
testq %rsi, %rsi
je 0x1caf
testb %cl, %cl
jne 0x1caf
movzbl (%rdi), %eax
testl %eax, %eax
je 0x1caa
cmpb (%rsi), %al
jne 0x1caa
incq %rdi
incq %rsi
jmp 0x1c80
movzbl (%rsi), %ecx
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_putnbr_fd.c
// Function: ft_putnbr_fd
void	ft_putnbr_fd(int n, int fd)
{
	if (fd < 0)
		return ;
	if (n == 0)
	{
		ft_putstr_fd("0", fd);
		return ;
	}
	else if (n == -2147483648)
	{
		ft_putstr_fd("-2147483648", fd);
		return ;
	}
	else if (n < 0)
		ft_putchar_fd('-', fd);
	if (n < 0)
		n /= -1;
	if (n > 9)
		ft_putnbr_fd(n / 10, fd);
	ft_putchar_fd('0' + n % 10, fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x1d37
movl %esi, %ebx
movl %edi, %r14d
movl %edi, %eax
negl %eax
jo 0x1d42
testl %r14d, %r14d
jne 0x1d5a
leaq 0x133a(%rip), %rdi      # 0x306f
jmp 0x1d49
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1328(%rip), %rdi      # 0x3071
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1dc0
jns 0x1d68
movl $0x2d, %edi
movl %ebx, %esi
callq 0x1cb4
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
movl %r15d, %r14d
cmpl $0xa, %r15d
jb 0x1d8f
movl $0xcccccccd, %edi       # imm = 0xCCCCCCCD
imulq %r14, %rdi
shrq $0x23, %rdi
movl %ebx, %esi
callq 0x1d10
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
imulq %r14, %rax
shrq $0x23, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %r15d
orb $0x30, %r15b
movzbl %r15b, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1cb4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_lstadd_back.c
// Function: ft_lstadd_back
int	ft_lstadd_back(t_list **lst, t_list *new)
{
	t_list	*temp;

	if (!new || !lst)
	{
		ft_putstr_fd("ERROR_IN_FT_LSTADD_BACK\n", 1);
		return (0);
	}
	temp = ft_lstlast(*lst);
	if (!temp)
	{
		*lst = new;
		return (1);
	}
	temp->next = new;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x1e2c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1e50
testq %rax, %rax
je 0x1e41
movq %rbx, 0x8(%rax)
jmp 0x1e44
leaq 0x124a(%rip), %rdi      # 0x307d
movl $0x1, %esi
callq 0x1dc0
xorl %eax, %eax
jmp 0x1e49
movq %rbx, (%r14)
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_lstnew.c
// Function: ft_lstnew
t_list	*ft_lstnew(void *content)
{
	t_list	*nw;

	nw = (t_list *)ft_malloc(1, sizeof(t_list));
	if (!nw)
	{
		ft_putstr_fd("ERROR_IN_FT_LSTNEW\n", 1);
		return (NULL);
	}
	nw->content = content;
	nw->next = NULL;
	return (nw);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x1ecc
testq %rax, %rax
je 0x1e96
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
jmp 0x1ea9
leaq 0x11f9(%rip), %rdi      # 0x3096
movl $0x1, %esi
callq 0x1dc0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_lstsize.c
// Function: ft_lstsize
int	ft_lstsize(t_list *lst)
{
	int		ans;
	t_list	*temp;

	ans = 0;
	temp = lst;
	while (temp)
	{
		ans++;
		temp = temp->next;
	}
	return (ans);
}

// Assembly:
testq %rdi, %rdi
je 0x1ec8
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x1ebb
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/get_next_line.c
// Function: ft_fill
static int	ft_fill(char **line, t_lst *temp)
{
	int		idx[2];
	t_str	*str;

	*line = ft_malloc(((temp->len) - (temp->idx) + 1), sizeof(char));
	if (!(*line))
		return (-1);
	idx[0] = temp->idx;
	idx[1] = 0;
	str = temp->str;
	while (idx[1] < (temp->len) - (temp->idx))
	{
		if (str->s[idx[0]] == '\0')
		{
			str = str->next;
			idx[0] = 0;
		}
		line[0][idx[1]++] = str->s[idx[0]++];
	}
	line[0][idx[1]] = '\0';
	return (ft_clean_lst(temp));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
subl 0x10(%rsi), %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x1ecc
movq %rax, (%r14)
testq %rax, %rax
je 0x2288
movl 0x10(%rbx), %ecx
cmpl %ecx, 0x8(%rbx)
jle 0x2292
movq (%rbx), %rdx
xorl %eax, %eax
movq (%rdx), %rsi
movslq %ecx, %rdi
cmpb $0x0, (%rsi,%rdi)
jne 0x2260
movq 0x8(%rdx), %rdx
xorl %ecx, %ecx
movq (%rdx), %rsi
movslq %ecx, %rdi
incl %ecx
movb (%rsi,%rdi), %sil
movq (%r14), %rdi
movb %sil, (%rdi,%rax)
incq %rax
movslq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rdi
subq %rdi, %rsi
cmpq %rsi, %rax
jl 0x224e
jmp 0x2294
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
movq (%r14), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x23ab
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/get_next_line_utils.c
// Function: ft_str_add
int	ft_str_add(t_lst *dst, char *s, int len)
{
	t_str	*str;
	int		idx;

	if (len < 0 || !s)
		return (-1);
	str = ft_malloc(1, sizeof(t_str));
	if (!str)
		return (-1);
	idx = -1;
	str->next = 0;
	str->s = ft_calloc(len + 1, sizeof(char));
	if (!(str->s))
		return (-1);
	while (++idx < len)
		str->s[idx] = s[idx];
	return (ft_sub(dst, str, len));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
sets %al
testq %rsi, %rsi
sete %cl
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x2350
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x1ecc
testq %rax, %rax
je 0x2350
movq %rax, %r15
movq $0x0, 0x8(%rax)
leal 0x1(%rbx), %edi
movl $0x1, %esi
callq 0x2674
movq %rax, (%r15)
testq %rax, %rax
je 0x2350
testl %ebx, %ebx
jle 0x2325
movl %ebx, %eax
xorl %ecx, %ecx
movb (%r12,%rcx), %dl
movq (%r15), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x2313
movq (%r14), %rax
testq %rax, %rax
je 0x2343
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x232d
movq %r15, 0x8(%rcx)
addl %ebx, 0x8(%r14)
jmp 0x234a
movq %r15, (%r14)
movl %ebx, 0x8(%r14)
movl $0x1, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/get_next_line_utils.c
// Function: ft_lst_add
t_lst	*ft_lst_add(t_lst **dst, int fd)
{
	t_lst	*temp;

	temp = ft_malloc(1, sizeof(t_lst));
	if (!temp)
		return (NULL);
	temp->str = 0;
	temp->len = 0;
	temp->fd = fd;
	temp->idx = 0;
	temp->next = 0;
	if (*dst == 0)
		*dst = temp;
	else
	{
		temp->next = *dst;
		*dst = temp;
	}
	return (temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x1ecc
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x23a6
movq %rax, (%rcx)
movl %eax, 0x8(%rcx)
movl %r14d, 0xc(%rcx)
movl %eax, 0x10(%rcx)
movq %rax, 0x18(%rcx)
movq (%rbx), %rax
movq %rax, 0x18(%rcx)
movq %rcx, (%rbx)
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/get_next_line_utils.c
// Function: ft_clean_lst
int	ft_clean_lst(t_lst *lst)
{
	t_str	*temp;

	lst->idx = 0;
	lst->len = 0;
	while (lst->str)
	{
		temp = lst->str;
		lst->str = lst->str->next;
		ft_free(temp->s);
		ft_free(temp);
	}
	lst->str = 0;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movl %eax, 0x8(%rdi)
movq (%rdi), %r14
testq %r14, %r14
je 0x23e1
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x1eda
movq %r14, %rdi
callq 0x1eda
movq (%rbx), %r14
jmp 0x23c0
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/get_next_line_sub.c
// Function: ft_del_lst
int	ft_del_lst(t_lst *target, t_lst **head, int *res)
{
	t_lst	*temp;

	if (res[1] != -1 && target->len)
		return (1);
	if (target == *head)
		return (sub(target, head, res));
	temp = *head;
	while (temp->next != target)
		temp = temp->next;
	temp->next = target->next;
	if (target->str)
		ft_clean_lst(target);
	ft_free(target);
	if (res[1] == -1)
		return (-1);
	return (res[1] == res[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $-0x1, 0x4(%rdx)
je 0x2415
movl $0x1, %eax
cmpl $0x0, 0x8(%r14)
jne 0x248f
movq (%r15), %rax
cmpq %r14, %rax
je 0x2458
movq %rax, %rcx
movq 0x18(%rax), %rax
cmpq %r14, %rax
jne 0x241d
movq 0x18(%r14), %rax
movq %rax, 0x18(%rcx)
cmpq $0x0, (%r14)
je 0x243f
movq %r14, %rdi
callq 0x23ab
movq %r14, %rdi
callq 0x1eda
movl 0x4(%rbx), %ecx
cmpl $-0x1, %ecx
je 0x248a
xorl %eax, %eax
cmpl (%rbx), %ecx
sete %al
jmp 0x248f
cmpq $0x0, (%r14)
je 0x2466
movq %r14, %rdi
callq 0x23ab
movq 0x18(%r14), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x1eda
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x248f
xorl %eax, %eax
cmpl $0x0, (%rbx)
setne %al
jmp 0x248f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/deque.c
// Function: deque_push_back
void	deque_push_back(t_deque *deque, void *ptr)
{
	t_double_list	*temp;

	(deque->size)++;
	temp = double_list_init(ptr);
	if (!temp)
		return ;
	if (deque->size == 1)
	{
		deque->head = temp;
		deque->tail = temp;
		return ;
	}
	temp->last = deque->tail;
	deque->tail->next = temp;
	deque->tail = deque->tail->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x10(%rdi)
movq %rsi, %rdi
callq 0x2618
testq %rax, %rax
je 0x2536
cmpl $0x1, 0x10(%rbx)
jne 0x2523
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x2533
movq 0x8(%rbx), %rcx
addq $0x8, %rbx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rcx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/deque.c
// Function: deque_push_front
void	deque_push_front(t_deque *deque, void *ptr)
{
	t_double_list	*temp;

	(deque->size)++;
	temp = double_list_init(ptr);
	if (!temp)
		return ;
	if (deque->size == 1)
	{
		deque->head = temp;
		deque->tail = temp;
		return ;
	}
	temp->next = deque->head;
	deque->head->last = temp;
	deque->head = deque->head->last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x10(%rdi)
movq %rsi, %rdi
callq 0x2618
testq %rax, %rax
je 0x2573
cmpl $0x1, 0x10(%rbx)
jne 0x2565
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x2570
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rcx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/deque.c
// Function: deque_pop_back
void	deque_pop_back(t_deque *deque, void (*f)(void *))
{
	t_double_list	*temp;

	if (deque->size < 1 || !deque->tail)
		return ;
	(deque->size)--;
	temp = deque->tail;
	deque->tail = deque->tail->last;
	if (deque->tail)
		deque->tail->next = NULL;
	if (f)
		f(temp->content);
	ft_free(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x25c2
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x25c2
decl %eax
movl %eax, 0x10(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x25aa
movq $0x0, 0x8(%rax)
testq %rsi, %rsi
je 0x25b4
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1eda
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/deque.c
// Function: deque_pop_front
void	deque_pop_front(t_deque *deque, void (*f)(void*))
{
	t_double_list	*temp;

	if (deque->size < 1 || !deque->head)
		return ;
	(deque->size)--;
	temp = deque->head;
	deque->head = deque->head->next;
	if (deque->head)
		deque->head->last = NULL;
	if (f)
		f(temp->content);
	ft_free(temp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x10(%rdi), %eax
testl %eax, %eax
jle 0x260f
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x260f
decl %eax
movl %eax, 0x10(%rdi)
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
testq %rax, %rax
je 0x25f7
movq $0x0, 0x10(%rax)
testq %rsi, %rsi
je 0x2601
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1eda
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/deque_utils.c
// Function: double_list_init
t_double_list	*double_list_init(void *ptr)
{
	t_double_list	*double_list;

	double_list = ft_malloc(1, sizeof(t_double_list));
	if (!double_list)
		return (NULL);
	double_list->content = ptr;
	double_list->next = NULL;
	double_list->last = NULL;
	return (double_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x1ecc
testq %rax, %rax
je 0x2641
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0x2643
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_calloc.c
// Function: ft_calloc
void	*ft_calloc(size_t elementcount, size_t elementsize)
{
	void	*ans;

	ans = ft_malloc(elementcount, elementsize);
	if (!ans)
	{
		ft_putstr_fd("ERROR_IN_FT_CALLOC\n", 1);
		return (NULL);
	}
	ft_memset(ans, 0, elementcount * elementsize);
	return (ans);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x1ecc
testq %rax, %rax
je 0x26a4
movq %rax, %rbx
imulq %r15, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x26ec
jmp 0x26b7
leaq 0x9ff(%rip), %rdi       # 0x30aa
movl $0x1, %esi
callq 0x1dc0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, size_t start, size_t len)
{
	char	*ans;
	size_t	l;
	size_t	ct;

	if (start >= ft_strlen(s))
	{
		ans = ft_calloc(1, sizeof(char));
		return (ans);
	}
	l = (size_t)ft_min((int)(ft_strlen(s) - start), (int)len);
	if (!s)
		return (NULL);
	ans = ft_calloc(l + 1, sizeof(char));
	if (!ans)
		return (NULL);
	ct = -1;
	while (++ct < l)
		ans[ct] = s[start + ct];
	ans[ct] = '\0';
	return (ans);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x26c8
cmpq %r14, %rax
jbe 0x276c
movq %rbx, %rdi
callq 0x26c8
subl %r14d, %eax
movl %eax, %edi
movl %r15d, %esi
callq 0x249c
testq %rbx, %rbx
je 0x2783
movl %eax, %r15d
movslq %eax, %r12
leaq 0x1(%r12), %rdi
movl $0x1, %esi
callq 0x2674
testq %rax, %rax
je 0x2783
testl %r15d, %r15d
je 0x2787
addq %r14, %rbx
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x275c
jmp 0x2789
movl $0x1, %edi
movl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2674
xorl %eax, %eax
jmp 0x278d
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_memory.c
// Function: ft_memory
void	*ft_memory(size_t elem_cnt,
size_t elem_size, void *del, t_memory type)
{
	static t_list	*head;
	void			*new_mem;

	if (type == push)
	{
		new_mem = ft_calloc_2(elem_cnt, elem_size);
		if (!new_mem)
			ft_putstr_fd("ERROR_IN_FT_MEMORY_0\n", 1);
		else if (!(ft_lstadd_front(&head, ft_lstnew_2(new_mem))))
			ft_putstr_fd("ERROR_IN_FT_MEMORY_1\n", 1);
		return (new_mem);
	}
	if (type == pop)
		ft_lstdelone_2(&head, ft_lstfind(head, del), free);
	else
		ft_lstclear_2(&head, free);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %ecx
je 0x27d8
testl %ecx, %ecx
jne 0x2824
movq %rsi, %r14
imulq %rdi, %r14
movq %r14, %rdi
callq 0x1070
testq %rax, %rax
je 0x2862
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x26ec
jmp 0x2875
movq 0x2889(%rip), %rdi      # 0x5068
movq %rdx, %rsi
callq 0x291c
testq %rax, %rax
je 0x2909
movq %rax, %rbx
movq 0x286e(%rip), %rcx      # 0x5068
cmpq %rax, %rcx
je 0x28d8
testq %rcx, %rcx
je 0x28f8
movq %rcx, %rax
movq 0x8(%rcx), %rcx
cmpq %rbx, %rcx
jne 0x2803
addq $0x8, %rax
movq %rbx, %rcx
jmp 0x28df
movq 0x283d(%rip), %r14      # 0x5068
movq $0x0, 0x2832(%rip) # 0x5068
testq %r14, %r14
je 0x2909
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0x2841
jmp 0x290b
leaq 0x881(%rip), %rdi       # 0x30ea
movl $0x1, %esi
callq 0x1dc0
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2896
movl $0x10, %edi
callq 0x1070
testq %rax, %rax
je 0x289f
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
jmp 0x28b2
leaq 0x821(%rip), %rdi       # 0x30be
jmp 0x28cc
leaq 0x85a(%rip), %rdi       # 0x3100
movl $0x1, %esi
callq 0x1dc0
xorl %eax, %eax
leaq 0x27af(%rip), %rdi      # 0x5068
movq %rax, %rsi
callq 0x2940
testl %eax, %eax
jne 0x290b
leaq 0x808(%rip), %rdi       # 0x30d4
movl $0x1, %esi
callq 0x1dc0
jmp 0x290b
leaq 0x2789(%rip), %rax      # 0x5068
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
jmp 0x2909
leaq 0x817(%rip), %rdi       # 0x3116
movl $0x1, %esi
callq 0x1dc0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_lstfind.c
// Function: ft_lstfind
t_list	*ft_lstfind(t_list *head, void *target)
{
	while (head)
	{
		if (head->content == target)
			return (head);
		head = head->next;
	}
	return (NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x293a
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
cmpq %rsi, (%rax)
je 0x2938
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2928
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/LeoFu9487[P]push_swap/libft/ft_lstadd_front.c
// Function: ft_lstadd_front
int	ft_lstadd_front(t_list **lst, t_list *new)
{
	if (!new || !lst)
	{
		ft_putstr_fd("ERROR_IN_FT_LSTADD_FRONT\n", 1);
		return (0);
	}
	if (!*lst)
	{
		*lst = new;
		return (1);
	}
	new->next = *lst;
	*lst = new;
	return (1);
}

// Assembly:
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x2965
movq (%rdi), %rax
testq %rax, %rax
je 0x295c
movq %rax, 0x8(%rsi)
movq %rsi, (%rdi)
movl $0x1, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x7bf(%rip), %rdi       # 0x312f
movl $0x1, %esi
callq 0x1dc0
xorl %eax, %eax
popq %rbp
retq