LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: f_readdir
FRESULT f_readdir (
	DIR* dp,			/* Pointer to the open directory object */
	FILINFO* fno		/* Pointer to file information to return */
)
{
	FRESULT res;
	FATFS *fs;
	DEF_NAMBUF


	res = validate(&dp->obj, &fs);	/* Check validity of the directory object */
	if (res == FR_OK) {
		if (!fno) {
			res = dir_sdi(dp, 0);			/* Rewind the directory object */
		} else {
			INIT_NAMBUF(fs);
			res = dir_read_file(dp);		/* Read an item */
			if (res == FR_NO_FILE) res = FR_OK;	/* Ignore end of directory */
			if (res == FR_OK) {				/* A valid entry is found */
				get_fileinfo(dp, fno);		/* Get the object information */
				res = dir_next(dp, 0);		/* Increment index for next */
				if (res == FR_NO_FILE) res = FR_OK;	/* Ignore end of directory now */
			}
			FREE_NAMBUF();
		}
	}
	LEAVE_FF(fs, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x18(%rbp), %rsi
callq 0x228f
testl %eax, %eax
je 0x2cef
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testq %r14, %r14
je 0x2d24
movq %rbx, %rdi
callq 0x2d34
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jne 0x2ce6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dc7
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2e47
cmpl $0x4, %eax
cmovel %r14d, %eax
jmp 0x2ce6
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2bf4
// File: /workspace/github_c_makefile_star2_O2/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: f_stat
FRESULT f_stat (
	const TCHAR* path,	/* Pointer to the file path */
	FILINFO* fno		/* Pointer to file information to return */
)
{
	FRESULT res;
	DIR dj;
	DEF_NAMBUF


	/* Get logical drive */
	res = find_volume(&path, &dj.obj.fs, 0);
	if (res == FR_OK) {
		INIT_NAMBUF(dj.obj.fs);
		res = follow_path(&dj, path);	/* Follow the file path */
		if (res == FR_OK) {				/* Follow completed */
			if (dj.fn[NSFLAG] & NS_NONAME) {	/* It is origin directory */
				res = FR_INVALID_NAME;
			} else {							/* Found an object */
				if (fno) get_fileinfo(&dj, fno);
			}
		}
		FREE_NAMBUF();
	}

	LEAVE_FF(dj.obj.fs, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
leaq -0x18(%rbp), %rax
movq %rdi, (%rax)
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x1480
testl %eax, %eax
jne 0x2fe1
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1a6d
testl %eax, %eax
je 0x2ff0
movl %eax, %r14d
movl %r14d, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x0, -0x1d(%rbp)
js 0x300c
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x2fe4
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x2dc7
jmp 0x2fe4
pushq $0x6
popq %r14
jmp 0x2fe4
// File: /workspace/github_c_makefile_star2_O2/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 0x228f
movl %eax, %r14d
testl %eax, %eax
jne 0x324b
movzbl 0x21(%rbx), %r14d
testl %r14d, %r14d
jne 0x324b
testb $0x2, 0x20(%rbx)
jne 0x31af
pushq $0x7
popq %r14
jmp 0x324b
movq 0x28(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x18(%rbx), %rax
jae 0x324b
testq %rax, %rax
je 0x3210
movq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0x1ed8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
cmpq %rcx, %rax
sete %dl
cmpq $0x1, %rax
pushq $0x2
popq %r15
cmovnel %edx, %r15d
testl %r15d, %r15d
jne 0x3226
movq -0x20(%rbp), %rcx
xorl %r15d, %r15d
cmpq 0x20(%rcx), %rax
jae 0x3226
movq 0x30(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1dde
movl %eax, %r15d
jmp 0x3226
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1dde
movl %eax, %r15d
andq $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
je 0x3247
movb %r15b, 0x21(%rbx)
movl %r15d, %r14d
jmp 0x324b
testb %al, %al
js 0x3259
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edi
leaq 0x50(%rbx), %rsi
movq 0x38(%rbx), %rdx
pushq $0x1
popq %r15
movl %r15d, %ecx
callq 0x131f
testl %eax, %eax
jne 0x323e
andb $0x7f, 0x20(%rbx)
jmp 0x324b
// File: /workspace/github_c_makefile_star2_O2/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 0x35e0
movq %rdi, %r14
movzbl 0x1(%rdi), %edi
leaq 0x58(%r14), %rbx
movq 0x50(%r14), %rdx
pushq $0x1
popq %r15
movq %rbx, %rsi
movl %r15d, %ecx
callq 0x131f
testl %eax, %eax
jne 0x35e3
movb $0x0, 0x3(%r14)
movq 0x28(%r14), %rdx
movq 0x50(%r14), %rax
movq %rax, %rcx
subq 0x38(%r14), %rcx
cmpq %rdx, %rcx
jae 0x35e0
cmpb $0x2, 0x2(%r14)
jne 0x35e0
movzbl 0x1(%r14), %edi
addq %rax, %rdx
pushq $0x1
popq %rcx
movq %rbx, %rsi
callq 0x131f
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x357b
testl %eax, %eax
je 0x3613
pushq $0x1
popq %rax
jmp 0x3673
movq %rbx, %rdi
movq %r14, %rsi
callq 0x201a
movq %rax, %r14
movq %rax, 0x50(%rbx)
leaq 0x58(%rbx), %r15
xorl %r13d, %r13d
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
pushq $0x1
popq %r12
movzwl 0xa(%rbx), %eax
cmpq %rax, %r13
jae 0x3668
movzbl 0x1(%rbx), %edi
leaq (%r14,%r13), %rdx
movq %r15, %rsi
movl %r12d, %ecx
callq 0x131f
testl %eax, %eax
jne 0x3664
incq %r13
jmp 0x363f
movzwl 0xa(%rbx), %eax
movzwl %ax, %ecx
xorl %eax, %eax
cmpq %r13, %rcx
setne %al
addq $0x8, %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/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 0x1e87
movl %eax, %ecx
movb $0x4, %al
testl %ecx, %ecx
jne 0x4194
movb $0x3, %al
cmpw $0xaa55, 0x256(%rbx)    # imm = 0xAA55
jne 0x4194
movzbl 0x58(%rbx), %eax
addl $0xffffff18, %eax       # imm = 0xFFFFFF18
cmpl $0x3, %eax
ja 0x418e
cmpl $0x2, %eax
je 0x418e
leaq 0x8e(%rbx), %rdi
leaq 0x1369(%rip), %rsi      # 0x54ce
pushq $0x3
popq %rdx
callq 0x419b
testl %eax, %eax
je 0x4192
addq $0xaa, %rbx
leaq 0x1353(%rip), %rsi      # 0x54d2
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x419b
testl %eax, %eax
je 0x4192
movb $0x2, %al
jmp 0x4194
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: mem_cmp
static
int mem_cmp (const void* dst, const void* src, UINT cnt)	/* ZR:same, NZ:different */
{
	const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
	int r = 0;

	do {
		r = *d++ - *s++;
	} while (--cnt && r == 0);

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
decl %edx
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb (%rsi,%rax), %r8b
cmpl %eax, %edx
je 0x41b6
incq %rax
cmpb %r8b, %cl
je 0x41a3
movzbl %cl, %eax
movzbl %r8b, %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x23a8
movq %rax, %r15
movq %rax, (%rsp)
callq 0x23a8
movq %rax, 0x8(%rsp)
testq %r15, %r15
setne %cl
testq %rax, %rax
setne %al
testb %al, %cl
jne 0x11b9
callq 0x15bd
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x181a
movq %rsp, %r14
testq %rbx, %rbx
je 0x11df
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x184b
movq 0x8(%rbx), %rbx
jmp 0x11c9
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x10(%rcx)
jne 0x1213
movq (%rsp), %rcx
movq (%rcx), %rdx
pushq $0x1
popq %rcx
movq 0x8(%rdx), %rsi
testq %rsi, %rsi
je 0x1211
movq (%rdx), %rdx
movl (%rdx), %edi
movq (%rsi), %r8
movq %rsi, %rdx
cmpl (%r8), %edi
jge 0x11f6
jmp 0x1213
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
decl %esi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
leaq 0x4(%rdi), %rdx
movabsq $-0x1, %r8
movl $0x1, %r9d
xorl %r10d, %r10d
cmpq %rcx, %r10
je 0x127a
incq %r8
xorl %r11d, %r11d
cmpq %r11, %rsi
je 0x126b
movl (%rdi,%r8,4), %ebx
leaq 0x1(%r11), %r14
cmpl (%rdx,%r11,4), %ebx
movq %r14, %r11
jne 0x1253
jmp 0x1277
incq %r10
decq %rsi
addq $0x4, %rdx
jmp 0x1248
movl %r9d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, 0x20(%rsp)
andq $0x0, 0x8(%rsp)
xorl %r15d, %r15d
cmpl $0x1, %esi
je 0x13be
movq %rdi, 0x10(%rsp)
movslq %esi, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
pushq $0x1
popq %r15
pushq $0x8
popq %r12
movq %rsp, %r13
leaq 0x8(%rsp), %rbp
incq %r14
cmpq 0x18(%rsp), %r14
jge 0x135c
movq 0x20(%rsp), %rax
movq (%rax,%r14,8), %rax
movq %rax, (%rsp)
movb (%rax), %al
testb %al, %al
je 0x12c3
movsbl %al, %edi
callq 0x2380
movq (%rsp), %rcx
testl %eax, %eax
je 0x12fd
incq %rcx
movq %rcx, (%rsp)
jmp 0x133e
movsbl (%rcx), %edi
callq 0x1bc0
testl %eax, %eax
je 0x1344
movq %r15, %rdi
movq %r12, %rsi
callq 0x1e00
movq %rax, %rbx
testq %rax, %rax
jne 0x1321
callq 0x15bd
movq %r13, %rdi
callq 0x14e0
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x1da8
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1d3c
movq (%rsp), %rax
jmp 0x12de
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1309
cmpl $0x2b, %eax
je 0x1309
callq 0x15bd
jmp 0x133e
movq 0x8(%rsp), %rdi
callq 0x1de8
movslq %eax, %rdi
pushq $0x4
popq %rsi
callq 0x1e00
movq 0x10(%rsp), %rbx
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1383
callq 0x15bd
movq 0x8(%rsp), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0x13aa
movq (%rax), %rcx
movl (%rcx), %ecx
movq (%rbx), %rdx
movl %ecx, (%rdx,%r15,4)
incq %r15
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x138b
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x1220
testl %eax, %eax
je 0x13be
callq 0x15bd
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1c29(%rip), %rsi      # 0x3004
pushq $0x3
popq %rdx
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1c15(%rip), %rsi      # 0x3007
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1bfe(%rip), %rsi      # 0x300a
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1be7(%rip), %rsi      # 0x300d
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1bd0(%rip), %rsi      # 0x3010
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1bba(%rip), %rsi      # 0x3014
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1ba8(%rip), %rsi      # 0x3018
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1b96(%rip), %rsi      # 0x301c
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1b77(%rip), %rsi      # 0x3013
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1b65(%rip), %rsi      # 0x3017
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
leaq 0x1b53(%rip), %rsi      # 0x301b
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x14dd
popq %rbx
jmp 0x15bd
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
leal -0x2b(%r14), %ecx
andb $-0x3, %cl
xorl %r15d, %r15d
negb %cl
sbbq %r15, %r15
cmpl $0x2d, %r14d
je 0x150e
cmpl $0x2b, %r14d
jne 0x151f
movsbl 0x1(%rax), %edi
callq 0x1bc0
testl %eax, %eax
je 0x15b8
movl $0x8000002f, %eax       # imm = 0x8000002F
leaq 0x1(%rax), %r13
cmpb $0x2d, %r14b
cmovneq %rax, %r13
incq %r15
xorl %r12d, %r12d
movq (%rbx), %rax
movsbl (%rax,%r15), %edi
testl %edi, %edi
je 0x1581
callq 0x1bc0
testl %eax, %eax
je 0x1589
imulq $0xa, %r12, %rcx
movq (%rbx), %rax
movsbq (%rax,%r15), %rdx
leaq (%rcx,%rdx), %rsi
cmpq %r13, %rsi
jg 0x15b8
leaq (%rcx,%rdx), %r12
addq $-0x30, %r12
testq %r12, %r12
jne 0x157c
movsbl 0x1(%rax,%r15), %edi
callq 0x1bc0
testl %eax, %eax
jne 0x15b8
incq %r15
jmp 0x1536
addq %r15, %rax
movq %rax, (%rbx)
jmp 0x15a1
movq (%rbx), %rax
leaq (%rax,%r15), %rcx
movq %rcx, (%rbx)
movsbl (%rax,%r15), %edi
callq 0x2380
testl %eax, %eax
je 0x15b8
movl %r12d, %eax
negl %eax
cmpb $0x2d, %r14b
cmovnel %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x15bd
// File: /workspace/github_c_makefile_star2_O2/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 0x1633
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x2447
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x23c8
movq (%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x23c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1688
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x2447
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x23c8
movq 0x8(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x23c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16d1
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x170a
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1744
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x240a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x177e
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2447
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x240a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17c7
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2493
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1800
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2493
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23c8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17a8(%rip), %rsi      # 0x3004
pushq $0x3
popq %rdx
callq 0x1bd4
testl %eax, %eax
jne 0x1870
movq %rbx, %rdi
callq 0x15e8
leaq 0x1790(%rip), %rsi      # 0x3007
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x188e
movq %rbx, %rdi
callq 0x1639
leaq 0x1775(%rip), %rsi      # 0x300a
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x18ac
movq %rbx, %rdi
callq 0x168e
leaq 0x175a(%rip), %rsi      # 0x300d
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x18ca
movq %rbx, %rdi
callq 0x16a0
leaq 0x173f(%rip), %rsi      # 0x3010
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x18e8
movq %rbx, %rdi
callq 0x16d9
leaq 0x1725(%rip), %rsi      # 0x3014
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x1906
movq %rbx, %rdi
callq 0x1714
leaq 0x170b(%rip), %rsi      # 0x3018
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x1924
movq %rbx, %rdi
callq 0x174c
leaq 0x16f1(%rip), %rsi      # 0x301c
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x1942
movq %rbx, %rdi
callq 0x1786
leaq 0x16ca(%rip), %rsi      # 0x3013
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x1960
movq %rbx, %rdi
callq 0x1798
leaq 0x16b0(%rip), %rsi      # 0x3017
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
jne 0x197e
movq %rbx, %rdi
callq 0x17cf
leaq 0x1696(%rip), %rsi      # 0x301b
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x1bd4
testl %eax, %eax
je 0x199c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1808
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2371
movl %eax, %ebp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x10(%rax), %r12d
subl %ebp, %r12d
addl 0x10(%rcx), %r12d
pushq $0x1
popq %r14
movq %r15, %rdi
movl %r14d, %esi
callq 0x1c34
leaq 0x16da(%rip), %r15      # 0x30d3
testl %r12d, %r12d
jle 0x1a0e
decl %r12d
movq %r15, %rdi
movl %r14d, %esi
callq 0x1c34
jmp 0x19f9
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x8(%rax), %r14
movq 0x8(%rcx), %r12
pushq $0x1
popq %r15
leaq 0x16ab(%rip), %r13      # 0x30d3
testl %ebp, %ebp
jle 0x1a8a
movq (%rbx), %rax
cmpl 0x10(%rax), %ebp
jle 0x1a45
leaq 0x15ea(%rip), %rdi      # 0x3025
movl %r15d, %esi
callq 0x1d00
jmp 0x1a53
movq (%r14), %rax
movl (%rax), %edi
callq 0x1ab7
movq 0x10(%r14), %r14
leaq 0x15d1(%rip), %rdi      # 0x302b
movl %r15d, %esi
callq 0x1d00
movq 0x8(%rbx), %rax
cmpl 0x10(%rax), %ebp
jg 0x1a7b
movq (%r12), %rax
movl (%rax), %edi
callq 0x1ab7
movq 0x10(%r12), %r12
movq %r13, %rdi
movl %r15d, %esi
callq 0x1c34
decl %ebp
jmp 0x1a28
leaq 0x15a0(%rip), %rdi      # 0x3031
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x1c34
leaq 0x15ab(%rip), %rdi      # 0x304d
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c34
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movl %edi, %r15d
shrl $0x1f, %r15d
incl %r15d
pushq $0xa
popq %rcx
movl %edi, %eax
leal -0xa(%rax), %edx
cmpl $-0x14, %edx
ja 0x1ae0
incl %r15d
cltd
idivl %ecx
jmp 0x1ad0
pushq $0xb
popq %r12
pushq $0x20
popq %rbp
pushq $0x1
popq %r14
cmpl %r12d, %r15d
je 0x1aff
movl %ebp, %edi
movl %r14d, %esi
callq 0x1c0c
decl %r12d
jmp 0x1aeb
pushq $0x1
popq %rsi
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1c64
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x127e
movl %eax, %ebx
testl %eax, %eax
jne 0x1b37
callq 0x15da
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
leaq 0x8(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x1e3c
cmpl $0x1, %eax
jne 0x1b75
movq 0x8(%rsp), %rdi
callq 0x13d0
movq 0x8(%rsp), %rdi
callq 0x1da8
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d3c
jmp 0x1b45
testl %ebx, %ebx
je 0x1b97
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl %ebx, %esi
callq 0x117c
testl %eax, %eax
je 0x1b9e
leaq 0x14d4(%rip), %rdi      # 0x3069
jmp 0x1ba5
callq 0x15da
jmp 0x1bad
leaq 0x14c7(%rip), %rdi      # 0x306c
pushq $0x1
popq %rsi
callq 0x1c34
callq 0x1e24
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1c09
testq %rsi, %rsi
je 0x1c09
testb %cl, %cl
jne 0x1c09
movzbl (%rdi), %eax
movb (%rsi), %cl
testl %eax, %eax
je 0x1c04
cmpb %cl, %al
jne 0x1c04
incq %rdi
incq %rsi
jmp 0x1bd8
movzbl %cl, %ecx
subl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1c8b
movl %esi, %ebx
movl %edi, %r14d
movl %edi, %eax
negl %eax
jo 0x1c96
testl %r14d, %r14d
jne 0x1cae
leaq 0x13e6(%rip), %rdi      # 0x306f
jmp 0x1c9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13d4(%rip), %rdi      # 0x3071
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d00
jns 0x1cba
pushq $0x2d
popq %rdi
movl %ebx, %esi
callq 0x1c0c
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
pushq $0xa
popq %r14
cmpl $0xa, %r15d
jb 0x1cdf
movl %r15d, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %edi
movl %ebx, %esi
callq 0x1c64
movl %r15d, %eax
xorl %edx, %edx
divl %r14d
orb $0x30, %dl
movzbl %dl, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c0c
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1d6c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1d8c
testq %rax, %rax
je 0x1d7f
movq %rbx, 0x8(%rax)
jmp 0x1d82
leaq 0x130a(%rip), %rdi      # 0x307d
pushq $0x1
popq %rsi
callq 0x1d00
xorl %eax, %eax
jmp 0x1d85
movq %rbx, (%r14)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x1e00
movq %rax, %rbx
testq %rax, %rax
je 0x1dcf
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x1dde
leaq 0x12c0(%rip), %rdi      # 0x3096
pushq $0x1
popq %rsi
callq 0x1d00
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x1e00
movq %rax, (%r14)
testq %rax, %rax
je 0x218c
movl 0x10(%rbx), %esi
movq (%rbx), %rcx
xorl %eax, %eax
movl %esi, %edx
movslq 0x8(%rbx), %rdi
movslq %esi, %rsi
subq %rsi, %rdi
cmpq %rdi, %rax
jge 0x2179
movq (%rcx), %rsi
movslq %edx, %rdi
movb (%rsi,%rdi), %sil
testb %sil, %sil
jne 0x2168
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
movb (%rdx), %sil
xorl %edx, %edx
incl %edx
movq (%r14), %rdi
movb %sil, (%rdi,%rax)
incq %rax
movl 0x10(%rbx), %esi
jmp 0x213e
movq (%r14), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x227f
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %r13
orb %al, %cl
jne 0x222c
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x1e00
testq %rax, %rax
je 0x222c
movq %rax, %r12
andq $0x0, 0x8(%rax)
leal 0x1(%rbx), %edi
pushq $0x1
popq %rsi
callq 0x2530
movq %rax, (%r12)
testq %rax, %rax
je 0x222c
movslq %ebx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2203
movb (%r15,%rcx), %dl
movq (%r12), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0x21ee
movq (%r14), %rax
testq %rax, %rax
je 0x2221
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x220b
movq %r12, 0x8(%rcx)
addl %ebx, 0x8(%r14)
jmp 0x2228
movq %r12, (%r14)
movl %ebx, 0x8(%r14)
pushq $0x1
popq %r13
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_O2/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
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x1e00
testq %rax, %rax
je 0x227a
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
movl %r14d, 0xc(%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x10(%rdi)
andl $0x0, 0x8(%rdi)
movq (%rbx), %r14
testq %r14, %r14
je 0x22b2
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x1e0e
movq %r14, %rdi
callq 0x1e0e
jmp 0x2291
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x22e0
cmpl $0x0, 0x8(%r14)
je 0x22e0
pushq $0x1
jmp 0x2357
movq (%r15), %rax
cmpq %r14, %rax
je 0x2323
movq %rax, %rcx
movq 0x18(%rax), %rax
cmpq %r14, %rax
jne 0x22e8
movq 0x18(%r14), %rax
movq %rax, 0x18(%rcx)
cmpq $0x0, (%r14)
je 0x230a
movq %r14, %rdi
callq 0x227f
movq %r14, %rdi
callq 0x1e0e
movl 0x4(%rbx), %ecx
cmpl $-0x1, %ecx
je 0x2355
xorl %eax, %eax
cmpl (%rbx), %ecx
sete %al
jmp 0x2358
cmpq $0x0, (%r14)
je 0x2331
movq %r14, %rdi
callq 0x227f
movq 0x18(%r14), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x1e0e
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2358
xorl %eax, %eax
cmpl $0x0, (%rbx)
setne %al
jmp 0x2358
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x24e0
testq %rax, %rax
je 0x2403
cmpl $0x1, 0x10(%rbx)
jne 0x23f0
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x2400
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_O2/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 0x24e0
testq %rax, %rax
je 0x2440
cmpl $0x1, 0x10(%rbx)
jne 0x2432
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x243d
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_O2/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 0x248c
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x248c
decl %eax
movl %eax, 0x10(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x2474
andq $0x0, 0x8(%rax)
testq %rsi, %rsi
je 0x247e
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e0e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24d6
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x24d6
decl %eax
movl %eax, 0x10(%rdi)
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
testq %rax, %rax
je 0x24be
andq $0x0, 0x10(%rax)
testq %rsi, %rsi
je 0x24c8
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e0e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x1e00
testq %rax, %rax
je 0x2503
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e00
movq %rax, %rbx
testq %rax, %rax
je 0x2560
imulq %r15, %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x25a8
jmp 0x256f
leaq 0xb43(%rip), %rdi       # 0x30aa
pushq $0x1
popq %rsi
callq 0x1d00
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/LeoFu9487[P]push_swap/libft/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *b, int c, size_t len)
{
	unsigned char	*s;

	s = (unsigned char *)b;
	while (len--)
		*(s++) = (unsigned char)c;
	return (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x25bf
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x25b1
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2580
cmpq %r14, %rax
jbe 0x2624
movq %rbx, %rdi
callq 0x2580
subl %r14d, %eax
movl %eax, %edi
movl %r15d, %esi
callq 0x2364
testq %rbx, %rbx
je 0x2639
movslq %eax, %r15
leaq 0x1(%r15), %rdi
pushq $0x1
popq %rsi
callq 0x2530
testq %rax, %rax
je 0x2639
addq %r14, %rbx
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x263d
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x2614
pushq $0x1
popq %rdi
movq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2530
xorl %eax, %eax
jmp 0x2641
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq