LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: dir_sdi
static
FRESULT dir_sdi (	/* FR_OK(0):succeeded, !=0:error */
	DIR* dp,		/* Pointer to directory object */
	DWORD ofs		/* Offset of directory table */
)
{
	DWORD csz, clst;
	FATFS *fs = dp->obj.fs;


	if (ofs >= (DWORD)((FF_FS_EXFAT && fs->fs_type == FS_EXFAT) ? MAX_DIR_EX : MAX_DIR) || ofs % SZDIRE) {	/* Check range of offset and alignment */
		return FR_INT_ERR;
	}
	dp->dptr = ofs;				/* Set current offset */
	clst = dp->obj.sclust;		/* Table start cluster (0:root) */
	if (clst == 0 && fs->fs_type >= FS_FAT32) {	/* Replace cluster# 0 with root cluster# */
		clst = fs->dirbase;
		if (FF_FS_EXFAT) dp->obj.stat = 0;	/* exFAT: Root dir has an FAT chain */
	}

	if (clst == 0) {	/* Static table (root-directory on the FAT volume) */
		if (ofs / SZDIRE >= fs->n_rootdir) return FR_INT_ERR;	/* Is index out of range? */
		dp->sect = fs->dirbase;

	} else {			/* Dynamic table (sub-directory or root-directory on the FAT32/exFAT volume) */
		csz = (DWORD)fs->csize * SS(fs);	/* Bytes per cluster */
		while (ofs >= csz) {				/* Follow cluster chain */
			clst = get_fat(&dp->obj, clst);				/* Get next cluster */
			if (clst == 0xFFFFFFFF) return FR_DISK_ERR;	/* Disk error */
			if (clst < 2 || clst >= fs->n_fatent) return FR_INT_ERR;	/* Reached to end of table or internal error */
			ofs -= csz;
		}
		dp->sect = clst2sect(fs, clst);
	}
	dp->clust = clst;					/* Current cluster# */
	if (dp->sect == 0) return FR_INT_ERR;
	dp->sect += ofs / SS(fs);			/* Sector# of the directory entry */
	dp->dir = fs->win + (ofs % SS(fs));	/* Pointer to the entry in the win[] */

	return FR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %r15
movq $0x0, 0x20(%rdi)
testq %r15, %r15
je 0x2d8f
movzwl 0xa(%r14), %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r15, %rsi
testw %r12w, %r12w
jne 0x2daf
movq (%rbx), %rdi
callq 0x1fb2
cmpq %r13, %rax
je 0x2dcf
movq %rax, %rsi
movl $0x2, %eax
cmpq $0x2, %rsi
jb 0x2df6
cmpq 0x20(%r14), %rsi
jb 0x2d66
jmp 0x2df6
cmpb $0x3, (%r14)
jb 0x2d9e
movq 0x40(%r14), %r15
testq %r15, %r15
jne 0x2d58
cmpw $0x0, 0x8(%r14)
je 0x2df1
movq 0x40(%r14), %rax
xorl %r15d, %r15d
jmp 0x2dd8
leaq -0x2(%r15), %rax
movq 0x20(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jae 0x2dd6
movzwl 0xa(%r14), %ecx
imulq %rcx, %rax
addq 0x48(%r14), %rax
jmp 0x2dd8
movl $0x1, %eax
jmp 0x2df6
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %r15, 0x28(%rbx)
testq %rax, %rax
je 0x2df1
addq $0x58, %r14
movq %r14, 0x38(%rbx)
xorl %eax, %eax
jmp 0x2df6
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23af
testl %eax, %eax
je 0x2e50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testq %r14, %r14
je 0x2e85
movq %rbx, %rdi
callq 0x2e95
testl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jne 0x2e47
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2f2f
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2fc7
cmpl $0x4, %eax
cmovel %r14d, %eax
jmp 0x2e47
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2d33
// File: /workspace/github_c_makefile_star2_O3/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 0x144b
testl %eax, %eax
jne 0x318d
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b32
testl %eax, %eax
je 0x319c
movl %eax, %r14d
movl %r14d, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x0, -0x1d(%rbp)
js 0x31b8
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x3190
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x2f2f
jmp 0x3190
movl $0x6, %r14d
jmp 0x3190
// File: /workspace/github_c_makefile_star2_O3/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 0x23af
movl %eax, %r14d
testl %eax, %eax
jne 0x33ea
movzbl 0x21(%rbx), %r14d
testl %r14d, %r14d
jne 0x33ea
movl $0x7, %r14d
testb $0x2, 0x20(%rbx)
je 0x33ea
movq 0x28(%rbx), %rax
xorl %r14d, %r14d
cmpq 0x18(%rbx), %rax
jae 0x33ea
testq %rax, %rax
je 0x3394
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x1fb2
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
je 0x33af
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
orb $0x40, 0x20(%rbx)
jmp 0x33e3
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1eb2
movl %eax, %r15d
movq $0x0, 0x10(%rbx)
jmp 0x33cb
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x33f8
movq 0x30(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1eb2
movl %eax, %r15d
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 0x340b
movb %r15b, 0x21(%rbx)
movl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rbx)
movb 0x20(%rbx), %al
movl %eax, %ecx
orb $0x40, %cl
movb %cl, 0x20(%rbx)
testb %al, %al
jns 0x33ea
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %edi
leaq 0x50(%rbx), %rsi
movq 0x38(%rbx), %rdx
movl $0x1, %r15d
movl $0x1, %ecx
callq 0x131f
testl %eax, %eax
jne 0x33e3
andb $0x7f, 0x20(%rbx)
jmp 0x33ea
// File: /workspace/github_c_makefile_star2_O3/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 0x37ea
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 0x131f
testl %eax, %eax
jne 0x37ed
movb $0x0, 0x3(%rbx)
movq 0x28(%rbx), %rdx
movq 0x50(%rbx), %rax
movq %rax, %rcx
subq 0x38(%rbx), %rcx
cmpq %rdx, %rcx
jae 0x37ea
cmpb $0x2, 0x2(%rbx)
jne 0x37ea
movzbl 0x1(%rbx), %edi
addq %rax, %rdx
movq %r14, %rsi
movl $0x1, %ecx
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_O3/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 0x3782
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x38a9
addq $-0x2, %r14
movq 0x20(%rbx), %rax
addq $-0x2, %rax
cmpq %rax, %r14
jae 0x3846
movzwl 0xa(%rbx), %eax
movq %rax, -0x30(%rbp)
imulq %rax, %r14
addq 0x48(%rbx), %r14
jmp 0x3851
movzwl 0xa(%rbx), %eax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
leaq 0x58(%rbx), %r15
xorl %r13d, %r13d
movl $0x200, %edx            # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x0, %r12d
cmpw $0x0, -0x30(%rbp)
je 0x38a1
xorl %r12d, %r12d
movzbl 0x1(%rbx), %edi
leaq (%r14,%r12), %rdx
movq %r15, %rsi
movl $0x1, %ecx
callq 0x131f
movzwl 0xa(%rbx), %r13d
testl %eax, %eax
jne 0x38a1
incq %r12
cmpq %r13, %r12
jb 0x387b
xorl %eax, %eax
cmpl %r13d, %r12d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1f5d
movl %eax, %ecx
movb $0x4, %al
testl %ecx, %ecx
jne 0x447c
movb $0x3, %al
cmpw $0xaa55, 0x256(%rbx)    # imm = 0xAA55
jne 0x447c
movzbl 0x58(%rbx), %eax
addl $0xffffff18, %eax       # imm = 0xFFFFFF18
cmpl $0x3, %eax
ja 0x447a
cmpl $0x2, %eax
je 0x447a
xorl %eax, %eax
leaq 0x109b(%rip), %rcx      # 0x54ce
movb 0x8e(%rbx,%rax), %dl
movb (%rax,%rcx), %sil
cmpl $0x2, %eax
je 0x444b
incq %rax
cmpb %sil, %dl
je 0x4433
cmpb %sil, %dl
je 0x4476
xorl %eax, %eax
leaq 0x1079(%rip), %rcx      # 0x54d2
movb 0xaa(%rbx,%rax), %dl
movb (%rax,%rcx), %sil
cmpl $0x4, %eax
je 0x4471
incq %rax
cmpb %sil, %dl
je 0x4459
cmpb %sil, %dl
jne 0x447a
xorl %eax, %eax
jmp 0x447c
movb $0x2, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x24bc
movq %rax, %r12
movq %rax, (%rsp)
callq 0x24bc
movq %rax, %r14
movq %rax, 0x8(%rsp)
testq %r12, %r12
setne %al
testq %r14, %r14
setne %cl
testb %cl, %al
jne 0x11ce
callq 0x160e
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x186e
testq %rbx, %rbx
je 0x11fc
movq %rsp, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x189a
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x11e3
movq 0x8(%rsp), %r14
xorl %eax, %eax
cmpl $0x0, 0x10(%r14)
jne 0x122b
movq (%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0x1226
movq (%rcx), %rcx
movl (%rcx), %esi
movq (%rdx), %rdi
movq %rdx, %rcx
cmpl (%rdi), %esi
jge 0x120c
jmp 0x122b
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x127a
movl %esi, %ecx
decl %esi
movl $0x1, %edx
xorl %r8d, %r8d
movq %rdx, %rax
cmpq %rcx, %rax
jae 0x1266
movl (%rdi,%r8,4), %r9d
leaq 0x1(%rax), %r10
cmpl (%rdi,%rax,4), %r9d
movq %r10, %rax
jne 0x124e
jmp 0x1275
incq %r8
incq %rdx
xorl %eax, %eax
cmpq %rsi, %r8
jne 0x124b
jmp 0x127a
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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)
cmpl $0x1, %esi
je 0x13e5
movq %rdi, %rbx
jle 0x135f
movq %rdx, %r14
movq %rbx, 0x10(%rsp)
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 0x1347
movsbl %al, %edi
callq 0x24a0
movq (%rsp), %rcx
testl %eax, %eax
je 0x12e2
incq %rcx
movq %rcx, (%rsp)
jmp 0x1329
movsbl (%rcx), %edi
callq 0x1c5c
testl %eax, %eax
je 0x132f
movl $0x1, %edi
movl $0x8, %esi
callq 0x1ed0
movq %rax, %r13
testq %rax, %rax
jne 0x130a
callq 0x160e
movq %r15, %rdi
callq 0x1524
movl %eax, (%r13)
movq %r13, %rdi
callq 0x1e6c
movq %r12, %rdi
movq %rax, %rsi
callq 0x1dfc
movq (%rsp), %rax
jmp 0x12c3
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2d, %eax
je 0x12ee
cmpl $0x2b, %eax
je 0x12ee
callq 0x160e
jmp 0x1329
incq %rbx
cmpq %rbp, %rbx
jne 0x12bb
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rbx
jmp 0x1361
xorl %edi, %edi
callq 0x1eb4
movslq %eax, %rdi
movl $0x4, %esi
callq 0x1ed0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x1383
callq 0x160e
movq (%rbx), %rax
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x13e5
xorl %ebx, %ebx
movq (%rcx), %rdx
movl (%rdx), %edx
movl %edx, (%rax,%rbx,4)
incq %rbx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
jne 0x138f
cmpq $0x1, %rbx
je 0x13e7
leaq -0x1(%rbx), %rdx
movl %ebx, %ecx
movl %edx, %edx
movl $0x1, %esi
xorl %edi, %edi
movq %rsi, %r8
cmpq %rcx, %r8
jae 0x13d8
movl (%rax,%rdi,4), %r9d
leaq 0x1(%r8), %r10
cmpl (%rax,%r8,4), %r9d
movq %r10, %r8
jne 0x13c0
jmp 0x13f8
incq %rdi
incq %rsi
cmpq %rdx, %rdi
jne 0x13bd
jmp 0x13e7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x160e
jmp 0x13e7
// File: /workspace/github_c_makefile_star2_O3/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 0x1bfa(%rip), %rsi      # 0x3004
movl $0x3, %edx
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1be4(%rip), %rsi      # 0x3007
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1bcb(%rip), %rsi      # 0x300a
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1bb2(%rip), %rsi      # 0x300d
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b99(%rip), %rsi      # 0x3010
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b81(%rip), %rsi      # 0x3014
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b6d(%rip), %rsi      # 0x3018
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b59(%rip), %rsi      # 0x301c
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b38(%rip), %rsi      # 0x3013
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b24(%rip), %rsi      # 0x3017
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
leaq 0x1b10(%rip), %rsi      # 0x301b
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1522
popq %rbx
jmp 0x160e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1543
cmpl $0x2b, %r14d
jne 0x1557
movsbl 0x1(%rax), %edi
callq 0x1c5c
testl %eax, %eax
je 0x1609
movq (%rbx), %rax
leal -0x2b(%r14), %ecx
xorl %r15d, %r15d
testb $-0x3, %cl
sete %r15b
movb (%rax,%r15), %cl
testb %cl, %cl
je 0x15cf
movl $0x8000002f, %eax       # imm = 0x8000002F
leaq 0x1(%rax), %r13
cmpb $0x2d, %r14b
cmovneq %rax, %r13
xorl %r12d, %r12d
movsbl %cl, %edi
callq 0x1c5c
testl %eax, %eax
je 0x15da
leaq (%r12,%r12,4), %rcx
movq (%rbx), %rax
movsbq (%rax,%r15), %rdx
leaq (%rdx,%rcx,2), %rsi
cmpq %r13, %rsi
jg 0x1609
leaq (%rdx,%rcx,2), %r12
addq $-0x30, %r12
testq %r12, %r12
jne 0x15c1
movsbl 0x1(%rax,%r15), %edi
callq 0x1c5c
testl %eax, %eax
jne 0x1609
movq (%rbx), %rax
movb 0x1(%rax,%r15), %cl
incq %r15
testb %cl, %cl
jne 0x1581
jmp 0x15d2
xorl %r12d, %r12d
addq %rax, %r15
movq %r15, (%rbx)
jmp 0x15f2
movq (%rbx), %rax
leaq (%rax,%r15), %rcx
movq %rcx, (%rbx)
movsbl (%rax,%r15), %edi
callq 0x24a0
testl %eax, %eax
je 0x1609
movl %r12d, %eax
negl %eax
cmpb $0x2d, %r14b
cmovnel %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x160e
// File: /workspace/github_c_makefile_star2_O3/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 0x1687
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x2562
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24e3
movq (%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x24e3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16dc
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rax
movq (%rax), %r15
xorl %esi, %esi
callq 0x2562
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x24e3
movq 0x8(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x24e3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1725
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x175e
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1798
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2525
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17d2
movq 0x8(%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x2562
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2525
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x181b
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x25b1
movq (%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1854
movq (%rdi), %rax
movq (%rax), %r14
xorl %esi, %esi
callq 0x25b1
movq 0x8(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1899
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2525
addq $0x4, %rbx
decq %r15
jne 0x1880
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1759(%rip), %rsi      # 0x3004
movl $0x3, %edx
callq 0x1c70
testl %eax, %eax
jne 0x18c1
movq %rbx, %rdi
callq 0x163c
leaq 0x173f(%rip), %rsi      # 0x3007
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x18e1
movq %rbx, %rdi
callq 0x168d
leaq 0x1722(%rip), %rsi      # 0x300a
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x1901
movq %rbx, %rdi
callq 0x16e2
leaq 0x1705(%rip), %rsi      # 0x300d
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x1921
movq %rbx, %rdi
callq 0x16f4
leaq 0x16e8(%rip), %rsi      # 0x3010
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x1941
movq %rbx, %rdi
callq 0x172d
leaq 0x16cc(%rip), %rsi      # 0x3014
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x1961
movq %rbx, %rdi
callq 0x1768
leaq 0x16b0(%rip), %rsi      # 0x3018
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x1981
movq %rbx, %rdi
callq 0x17a0
leaq 0x1694(%rip), %rsi      # 0x301c
movl $0x3, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x19a1
movq %rbx, %rdi
callq 0x17da
leaq 0x166b(%rip), %rsi      # 0x3013
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x19c1
movq %rbx, %rdi
callq 0x17ec
leaq 0x164f(%rip), %rsi      # 0x3017
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
jne 0x19e1
movq %rbx, %rdi
callq 0x1823
leaq 0x1633(%rip), %rsi      # 0x301b
movl $0x4, %edx
movq %r14, %rdi
callq 0x1c70
testl %eax, %eax
je 0x1a01
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x17ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1823
// File: /workspace/github_c_makefile_star2_O3/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 0x2491
movl %eax, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl 0x10(%rax), %ebp
subl %r14d, %ebp
addl 0x10(%rcx), %ebp
movq %r15, %rdi
movl $0x1, %esi
callq 0x1ce0
testl %ebp, %ebp
jle 0x1a77
leaq 0x166d(%rip), %r15      # 0x30d3
movq %r15, %rdi
movl $0x1, %esi
callq 0x1ce0
decl %ebp
jne 0x1a66
testl %r14d, %r14d
jle 0x1b06
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x8(%rcx), %rbp
movq 0x8(%rax), %r15
leaq 0x1595(%rip), %r12      # 0x302b
leaq 0x1636(%rip), %r13      # 0x30d3
movq (%rbx), %rax
cmpl 0x10(%rax), %r14d
jle 0x1ab9
leaq 0x1578(%rip), %rdi      # 0x3025
movl $0x1, %esi
callq 0x1dc0
jmp 0x1ac7
movq (%r15), %rax
movl (%rax), %edi
callq 0x1b36
movq 0x10(%r15), %r15
movq %r12, %rdi
movl $0x1, %esi
callq 0x1dc0
movq 0x8(%rbx), %rax
cmpl 0x10(%rax), %r14d
jg 0x1aed
movq (%rbp), %rax
movl (%rax), %edi
callq 0x1b36
movq 0x10(%rbp), %rbp
decl %r14d
movq %r13, %rdi
movl $0x1, %esi
callq 0x1ce0
leal 0x1(%r14), %eax
cmpl $0x1, %eax
ja 0x1a9d
leaq 0x1524(%rip), %rdi      # 0x3031
movl $0x1, %esi
callq 0x1ce0
leaq 0x152f(%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_O3/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 0x1b74
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 0x1b4c
cmpl $0xb, %ebp
je 0x1b8a
addl $-0xb, %ebp
movl $0x20, %edi
movl $0x1, %esi
callq 0x1cb4
incl %ebp
jne 0x1b77
movl %ebx, %edi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d10
// File: /workspace/github_c_makefile_star2_O3/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 0x127b
movl %eax, %ebx
testl %eax, %eax
jne 0x1bbf
callq 0x162f
movq $0x0, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
xorl %edi, %edi
callq 0x1f0c
cmpl $0x1, %eax
jne 0x1c11
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rdi
callq 0x13ff
movq 0x8(%rsp), %rdi
callq 0x1e6c
movq %r14, %rdi
movq %rax, %rsi
callq 0x1dfc
xorl %edi, %edi
movq %r15, %rsi
callq 0x1f0c
cmpl $0x1, %eax
je 0x1be3
testl %ebx, %ebx
je 0x1c33
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl %ebx, %esi
callq 0x118c
testl %eax, %eax
je 0x1c3a
leaq 0x1438(%rip), %rdi      # 0x3069
jmp 0x1c41
callq 0x162f
jmp 0x1c4b
leaq 0x142b(%rip), %rdi      # 0x306c
movl $0x1, %esi
callq 0x1ce0
callq 0x1ef4
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
jne 0x1ca7
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
movb (%rsi,%rcx), %r8b
testl %eax, %eax
je 0x1cab
cmpb %r8b, %al
jne 0x1cab
incq %rcx
cmpq %rcx, %rdx
jne 0x1c8e
xorl %eax, %eax
jmp 0x1cb1
movzbl %r8b, %ecx
subl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x1ed0
movq %rax, %rbx
testq %rax, %rax
je 0x1e9a
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x1eab
leaq 0x11f5(%rip), %rdi      # 0x3096
movl $0x1, %esi
callq 0x1dc0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1ecc
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x1ebf
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1ed0
movq %rax, (%r14)
testq %rax, %rax
je 0x2278
movl 0x10(%rbx), %edx
cmpl %edx, 0x8(%rbx)
jle 0x2282
movq (%rbx), %rax
xorl %ecx, %ecx
movq (%rax), %rsi
movslq %edx, %rdi
movb (%rsi,%rdi), %sil
testb %sil, %sil
jne 0x2257
movq 0x8(%rax), %rax
movq (%rax), %rdx
movb (%rdx), %sil
xorl %edx, %edx
incl %edx
movq (%r14), %rdi
movb %sil, (%rdi,%rcx)
incq %rcx
movslq 0x8(%rbx), %rsi
movslq 0x10(%rbx), %rdi
subq %rdi, %rsi
cmpq %rsi, %rcx
jl 0x223c
movq (%r14), %rax
jmp 0x2284
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2391
// File: /workspace/github_c_makefile_star2_O3/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 0x233c
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x1ed0
testq %rax, %rax
je 0x233c
movq %rax, %r15
movq $0x0, 0x8(%rax)
leal 0x1(%rbx), %edi
movl $0x1, %esi
callq 0x2658
movq %rax, (%r15)
testq %rax, %rax
je 0x233c
testl %ebx, %ebx
je 0x2311
movl %ebx, %eax
xorl %ecx, %ecx
movb (%r12,%rcx), %dl
movq (%r15), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x22ff
movq (%r14), %rax
testq %rax, %rax
je 0x232f
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2319
movq %r15, 0x8(%rcx)
addl %ebx, 0x8(%r14)
jmp 0x2336
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_O3/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 0x1ed0
testq %rax, %rax
je 0x238c
xorl %ecx, %ecx
movq %rcx, (%rax)
movl %ecx, 0x8(%rax)
movl %r14d, 0xc(%rax)
movl %ecx, 0x10(%rax)
movq %rcx, 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_O3/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 0x23c7
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x1ede
movq %r14, %rdi
callq 0x1ede
movq (%rbx), %r14
jmp 0x23a6
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x23fd
movl $0x1, %eax
cmpl $0x0, 0x8(%r14)
jne 0x2477
movq (%r15), %rax
cmpq %r14, %rax
je 0x2440
movq %rax, %rcx
movq 0x18(%rax), %rax
cmpq %r14, %rax
jne 0x2405
movq 0x18(%r14), %rax
movq %rax, 0x18(%rcx)
cmpq $0x0, (%r14)
je 0x2427
movq %r14, %rdi
callq 0x2391
movq %r14, %rdi
callq 0x1ede
movl 0x4(%rbx), %ecx
cmpl $-0x1, %ecx
je 0x2472
xorl %eax, %eax
cmpl (%rbx), %ecx
sete %al
jmp 0x2477
cmpq $0x0, (%r14)
je 0x244e
movq %r14, %rdi
callq 0x2391
movq 0x18(%r14), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x1ede
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x2477
xorl %eax, %eax
cmpl $0x0, (%rbx)
setne %al
jmp 0x2477
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2600
testq %rax, %rax
je 0x251e
cmpl $0x1, 0x10(%rbx)
jne 0x250b
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x251b
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_O3/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 0x2600
testq %rax, %rax
je 0x255b
cmpl $0x1, 0x10(%rbx)
jne 0x254d
movq %rax, (%rbx)
addq $0x8, %rbx
jmp 0x2558
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_O3/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 0x25aa
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x25aa
decl %eax
movl %eax, 0x10(%rdi)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x2592
movq $0x0, 0x8(%rax)
testq %rsi, %rsi
je 0x259c
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1ede
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25f7
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x25f7
decl %eax
movl %eax, 0x10(%rdi)
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
testq %rax, %rax
je 0x25df
movq $0x0, 0x10(%rax)
testq %rsi, %rsi
je 0x25e9
movq (%rbx), %rdi
callq *%rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1ede
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1ed0
testq %rax, %rax
je 0x2627
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ed0
movq %rax, %rbx
testq %rax, %rax
je 0x2688
imulq %r15, %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x26cc
jmp 0x2699
leaq 0xa1b(%rip), %rdi       # 0x30aa
movl $0x1, %esi
callq 0x1dc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop