LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/types.c
// Function: is_file
int	is_file(char *filename)
{
	struct stat	buf;

	lstat(filename, &buf);
	return ((S_ISDIR(buf.st_mode) * -1) ^ (S_ISBLK(buf.st_mode) * 6)
		^ (S_ISLNK(buf.st_mode) * 5) ^ (S_ISREG(buf.st_mode) * 4)
		^ (S_ISCHR(buf.st_mode) * 3) ^ (S_ISSOCK(buf.st_mode) * 2)
		^ S_ISFIFO(buf.st_mode));
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rsp, %rsi
callq 0x10d0
movl 0x18(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb $0x1, %al
movzbl %al, %eax
imull $-0x1, %eax, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x6000, %ecx           # imm = 0x6000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
imull $0x6, %ecx, %ecx
xorl %ecx, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0xa000, %ecx           # imm = 0xA000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
imull $0x5, %ecx, %ecx
xorl %ecx, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x8000, %ecx           # imm = 0x8000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x2, %ecx
xorl %ecx, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x2000, %ecx           # imm = 0x2000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
imull $0x3, %ecx, %ecx
xorl %ecx, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0xc000, %ecx           # imm = 0xC000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
xorl %ecx, %eax
movl 0x18(%rsp), %ecx
andl $0xf000, %ecx           # imm = 0xF000
cmpl $0x1000, %ecx           # imm = 0x1000
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/types.c
// Function: file_type
char	file_type(mode_t st_mode)
{
	if (S_ISLNK(st_mode))
		return ('l');
	if (S_ISREG(st_mode))
		return ('-');
	if (S_ISDIR(st_mode))
		return ('d');
	if (S_ISBLK(st_mode))
		return ('b');
	if (S_ISCHR(st_mode))
		return ('c');
	if (S_ISSOCK(st_mode))
		return ('s');
	if (S_ISFIFO(st_mode))
		return ('p');
	return ('?');
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x191e
movb $0x6c, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x1935
movb $0x2d, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x194c
movb $0x64, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x6000, %eax           # imm = 0x6000
jne 0x1963
movb $0x62, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x197a
movb $0x63, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x1991
movb $0x73, -0x1(%rsp)
jmp 0x19ad
movl -0x8(%rsp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x19a8
movb $0x70, -0x1(%rsp)
jmp 0x19ad
movb $0x3f, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/types.c
// Function: is_dot
int	is_dot(char	*name)
{
	if (name[0] == '.')
	{
		if (!name[1])
			return (1);
		if (name[1] == '.' && !name[2])
			return (1);
	}
	return (0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x1a0c
movq -0x10(%rsp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x19e7
movl $0x1, -0x4(%rsp)
jmp 0x1a14
movq -0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
jne 0x1a0a
movq -0x10(%rsp), %rax
cmpb $0x0, 0x2(%rax)
jne 0x1a0a
movl $0x1, -0x4(%rsp)
jmp 0x1a14
jmp 0x1a0c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/acl.c
// Function: major_minor
void	major_minor(dev_t st_rdev, off_t st_size, t_ls *ls)
{
	t_byte			mm;
	unsigned int	major;
	unsigned int	minor;

	major = major(st_rdev);
	minor = minor(st_rdev);
	mm = (major || minor);
	if (mm)
	{
		ft_printf("%4d,", major);
		ft_repet(' ', ls->file_size - ft_sizei(minor));
		ft_printf("%d ", minor);
	}
	else
	{
		ft_putstr("     ");
		ft_repet(' ', ls->file_size - ft_sizei(st_size));
		ft_printf("%lu ", st_size);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1110
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1120
movl %eax, 0x14(%rsp)
movb $0x1, %al
cmpl $0x0, 0x18(%rsp)
movb %al, 0x13(%rsp)
jne 0x1a68
cmpl $0x0, 0x14(%rsp)
setne %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, 0x1f(%rsp)
cmpb $0x0, 0x1f(%rsp)
je 0x1ad5
movl 0x18(%rsp), %esi
leaq 0x67c9(%rip), %rdi      # 0x8250
movb $0x0, %al
callq 0x3640
movq 0x20(%rsp), %rax
movslq 0xa8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %edi
callq 0x3510
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movl %eax, %esi
movl $0x20, %edi
callq 0x33d0
movl 0x14(%rsp), %esi
leaq 0x6789(%rip), %rdi      # 0x8255
movb $0x0, %al
callq 0x3640
jmp 0x1b24
leaq 0x677d(%rip), %rdi      # 0x8259
callq 0x3450
movq 0x20(%rsp), %rax
movslq 0xa8(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x3510
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movl %eax, %esi
movl $0x20, %edi
callq 0x33d0
movq 0x28(%rsp), %rsi
leaq 0x6742(%rip), %rdi      # 0x825f
movb $0x0, %al
callq 0x3640
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/acl.c
// Function: print_element
void	print_element(char *cont, char *name, t_u_char *flags, t_ls *ls)
{
	struct stat			buf;
	security_context_t	sc;
	char				*rwx;

	ft_memset(&buf, 0, sizeof(struct stat *));
	if (lstat(cont, &buf) == -1)
	{
		ft_printf_fd(2, WLSTAT, cont, strerror(errno));
		return ;
	}
	if (flags['l'])
	{
		rwx = print_permissions(buf.st_mode, (getfilecon(cont, &sc) > 0), cont);
		ft_putstr(rwx);
		ft_repet(' ', ls->link_count - ft_sizei(buf.st_nlink) + 1);
		ft_printf("%lu ", buf.st_nlink);
		print_user(buf.st_uid);
		print_grp(buf.st_gid);
		major_minor(buf.st_rdev, buf.st_size, ls);
		ft_printf("%.12s ", &ctime(&buf.st_mtime)[4]);
	}
	element_color(cont, name, buf, flags);
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movq %rdx, 0x160(%rsp)
movq %rcx, 0x158(%rsp)
leaq 0xc8(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x7400
movq 0x170(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x10d0
cmpl $-0x1, %eax
jne 0x1bc4
movq 0x170(%rsp), %rax
movq %rax, 0xb0(%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq 0xb0(%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x66ac(%rip), %rsi      # 0x8264
movb $0x0, %al
callq 0x3570
jmp 0x1d30
movq 0x160(%rsp), %rax
cmpb $0x0, 0x6c(%rax)
je 0x1ce0
movl 0xe0(%rsp), %eax
movl %eax, 0xa4(%rsp)
movq 0x170(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1140
movl 0xa4(%rsp), %edi
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %esi
movq 0x170(%rsp), %rdx
callq 0x1d40
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3450
movq 0x158(%rsp), %rax
movslq 0xa4(%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x3510
movq %rax, %rcx
movq 0xa8(%rsp), %rax
subq %rcx, %rax
addq $0x1, %rax
movl %eax, %esi
movl $0x20, %edi
callq 0x33d0
movq 0xd8(%rsp), %rsi
leaq 0x65e1(%rip), %rdi      # 0x825f
movb $0x0, %al
callq 0x3640
movl 0xe4(%rsp), %edi
callq 0x1ee0
movl 0xe8(%rsp), %edi
callq 0x1f30
movq 0xf0(%rsp), %rdi
movq 0xf8(%rsp), %rsi
movq 0x158(%rsp), %rdx
callq 0x1a20
leaq 0xc8(%rsp), %rdi
addq $0x58, %rdi
callq 0x1090
movq %rax, %rsi
addq $0x4, %rsi
leaq 0x65a2(%rip), %rdi      # 0x827b
movb $0x0, %al
callq 0x3640
movq 0x170(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x160(%rsp), %rdx
movq %rsp, %rdi
movl $0x12, %ecx
leaq 0xc8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x1f80
addq $0x178, %rsp            # imm = 0x178
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/acl.c
// Function: print_user
static void	print_user(uid_t st_uid)
{
	struct passwd	*user;

	user = getpwuid(st_uid);
	if (user == NULL)
		ft_printf("%5d ", st_uid);
	else
		ft_printf("%5s ", user->pw_name);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x1080
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1f12
movl 0x14(%rsp), %esi
leaq 0x6399(%rip), %rdi      # 0x82a2
movb $0x0, %al
callq 0x3640
jmp 0x1f28
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x6386(%rip), %rdi      # 0x82a7
movb $0x0, %al
callq 0x3640
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/acl.c
// Function: print_grp
static void	print_grp(gid_t st_gid)
{
	struct group	*grp;

	grp = getgrgid(st_gid);
	if (grp == NULL)
		ft_printf("%5d", st_gid);
	else
		ft_printf("%5s ", grp->gr_name);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0x10b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1f62
movl 0x14(%rsp), %esi
leaq 0x6353(%rip), %rdi      # 0x82ac
movb $0x0, %al
callq 0x3640
jmp 0x1f78
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x6336(%rip), %rdi      # 0x82a7
movb $0x0, %al
callq 0x3640
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/color.c
// Function: element_color
void	element_color(char *cont, char *name, struct stat buf, t_u_char *flags)
{
	char	type;

	type = file_type(buf.st_mode);
	if (type == 'l')
	{
		color_link(cont, name, buf, flags);
		return ;
	}
	else if (type == 'd')
		ft_putstr(BOLD""CEL);
	else if (buf.st_mode & S_IXUSR)
		ft_putstr(BOLD""GREEN);
	else if (type == 'b' || type == 'c')
		ft_putstr(BOLD""YELLOW);
	ft_printf("%s"E0M, name);
}

// Assembly:
subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl 0x18(%rax), %edi
callq 0x1900
movb %al, 0xaf(%rsp)
movsbl 0xaf(%rsp), %eax
cmpl $0x6c, %eax
jne 0x201d
movq 0xa0(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0xb0(%rsp), %rdx
movq %rsp, %rdi
movl $0x12, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x20b0
jmp 0x209b
movsbl 0xaf(%rsp), %eax
cmpl $0x64, %eax
jne 0x2038
leaq 0x627f(%rip), %rdi      # 0x82b0
callq 0x3450
jmp 0x2083
movq 0xa0(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x2059
leaq 0x6276(%rip), %rdi      # 0x82c8
callq 0x3450
jmp 0x2081
movsbl 0xaf(%rsp), %eax
cmpl $0x62, %eax
je 0x2073
movsbl 0xaf(%rsp), %eax
cmpl $0x63, %eax
jne 0x207f
leaq 0x6258(%rip), %rdi      # 0x82d2
callq 0x3450
jmp 0x2081
jmp 0x2083
jmp 0x2085
movq 0xb8(%rsp), %rsi
leaq 0x6267(%rip), %rdi      # 0x82fb
movb $0x0, %al
callq 0x3640
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//dirent/color.c
// Function: color_link
static void	color_link(char *cont, char *name, struct stat buf, t_u_char *flags)
{
	char	*buf2;
	ssize_t	bufsiz;
	ssize_t	nbytes;

	bufsiz = buf.st_size + 1;
	if (buf.st_size == 0)
		bufsiz = PATH_MAX;
	buf2 = malloc(bufsiz);
	nbytes = readlink(cont, buf2, bufsiz);
	buf2[nbytes] = '\0';
	if (flags['l'])
		ft_printf(BOLD"\e[96m%s"E0M" -> %s", name, buf2);
	else
		ft_printf(BOLD"\e[96m%s"E0M, name);
	free(buf2);
}

// Assembly:
subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x20e5
movq $0x1000, 0x10(%rsp)     # imm = 0x1000
movq 0x10(%rsp), %rdi
callq 0x1100
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1050
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x6c(%rax)
je 0x2140
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x61a5(%rip), %rdi      # 0x82dc
movb $0x0, %al
callq 0x3640
jmp 0x2153
movq 0x28(%rsp), %rsi
leaq 0x61a6(%rip), %rdi      # 0x82f2
movb $0x0, %al
callq 0x3640
movq 0x18(%rsp), %rdi
callq 0x1030
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/ft_ls.c
// Function: path_file
char	*path_file(char *path, char *name, int lslash)
{
	char	*tmp;
	char	*file;

	if ((path[lslash + 1] && path[lslash] == '/')
		|| (!lslash && path[0] != '/'))
	{
		file = ft_strjoin(path, "/");
		tmp = file;
	}
	else
		file = path;
	file = ft_strjoin(file, name);
	if ((path[lslash + 1] && path[lslash] == '/')
		|| (!lslash && path[0] != '/'))
		free(tmp);
	return (file);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x21ad
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x21c1
cmpl $0x0, 0x14(%rsp)
jne 0x21e1
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x21e1
movq 0x20(%rsp), %rdi
leaq 0x6135(%rip), %rsi      # 0x8302
callq 0x6fe0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x21ea
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x6fe0
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2227
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x223b
cmpl $0x0, 0x14(%rsp)
jne 0x2245
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2245
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/ft_ls.c
// Function: last_slash
int	last_slash(char *str)
{
	int	i;
	int	slash;

	i = 0;
	slash = 0;
	while (str[i])
	{
		if (str[i] == '/')
			slash = i;
		i++;
	}
	return (slash);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x229d
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x2290
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2265
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/ft_ls.c
// Function: measure_dir
int	measure_dir(char *name, char *path, t_ls *ls)
{
	struct stat			buf;
	char				*file;
	int					file_size;
	int					link_count;

	if (!ls->flags['l'])
		return (0);
	file = path_file(path, name, ls->lslash);
	ft_memset(&buf, 0, sizeof(struct stat *));
	if (lstat(file, &buf) == -1)
	{
		ft_printf_fd(2, WLSTAT, file, strerror(errno));
		return (0);
	}
	free(file);
	file_size = ft_sizei(buf.st_size);
	if (file_size > ls->file_size)
		ls->file_size = file_size;
	link_count = ft_sizei(buf.st_nlink);
	if (link_count > ls->link_count)
		ls->link_count = link_count;
	return (buf.st_blocks);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
cmpb $0x0, 0x8c(%rax)
jne 0x22f0
movl $0x0, 0xc4(%rsp)
jmp 0x23f7
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xa8(%rsp), %rax
movl 0xa0(%rax), %edx
callq 0x2170
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x7400
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x10d0
cmpl $-0x1, %eax
jne 0x2379
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq (%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x5eff(%rip), %rsi      # 0x8264
movb $0x0, %al
callq 0x3570
movl $0x0, 0xc4(%rsp)
jmp 0x23f7
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x48(%rsp), %rdi
callq 0x3510
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0xa8(%rcx), %eax
jle 0x23b7
movl 0xc(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xa8(%rax)
movq 0x28(%rsp), %rdi
callq 0x3510
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0xa4(%rcx), %eax
jle 0x23eb
movl 0x8(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xa4(%rax)
movq 0x58(%rsp), %rax
movl %eax, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/ft_ls.c
// Function: init_lsdir
void	init_lsdir(t_ls *ls, int lslash)
{
	ls->total = 0;
	ls->lslash = lslash;
	ls->link_count = 0;
	ls->file_size = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x9c(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0xa0(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xa4(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xa8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/ft_ls.c
// Function: ft_ls
void	ft_ls(t_ls *ls)
{
	if (ls->flags['r'] && !ls->flags['t'])
	{
		strquick(ls->files, ls->size_f, &alpha_rev);
		strquick(ls->dirs, ls->size_d, &alpha_rev);
	}
	else if (ls->flags['r'] && ls->flags['t'])
	{
		strquick(ls->files, ls->size_f, &time_rev);
		strquick(ls->dirs, ls->size_d, &time_rev);
	}
	else if (ls->flags['t'])
	{
		strquick(ls->files, ls->size_f, &time_cmp);
		strquick(ls->dirs, ls->size_d, &time_cmp);
	}
	else
	{
		strquick(ls->files, ls->size_f, &alpha_cmp);
		strquick(ls->dirs, ls->size_d, &alpha_cmp);
	}
	print_files(ls->files, ls->flags, ls);
	if (ls->size_f && ls->size_d)
		ft_putchar('\n');
	print_dirs(ls->dirs, ls->flags, ls);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movzbl 0x92(%rax), %eax
cmpl $0x0, %eax
je 0x24be
movq (%rsp), %rax
cmpb $0x0, 0x94(%rax)
jne 0x24be
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x237(%rip), %rdx       # 0x26d0
callq 0x30d0
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x21c(%rip), %rdx       # 0x26d0
callq 0x30d0
jmp 0x2598
movq (%rsp), %rax
movzbl 0x92(%rax), %eax
cmpl $0x0, %eax
je 0x2517
movq (%rsp), %rax
movzbl 0x94(%rax), %eax
cmpl $0x0, %eax
je 0x2517
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x33b(%rip), %rdx       # 0x2830
callq 0x30d0
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x320(%rip), %rdx       # 0x2830
callq 0x30d0
jmp 0x2596
movq (%rsp), %rax
cmpb $0x0, 0x94(%rax)
je 0x255d
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x385(%rip), %rdx       # 0x28c0
callq 0x30d0
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x36a(%rip), %rdx       # 0x28c0
callq 0x30d0
jmp 0x2594
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x3dc(%rip), %rdx       # 0x2950
callq 0x30d0
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x3c1(%rip), %rdx       # 0x2950
callq 0x30d0
jmp 0x2596
jmp 0x2598
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rsi
addq $0x20, %rsi
movq (%rsp), %rdx
callq 0x2ab0
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x25d1
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x25d1
movl $0xa, %edi
callq 0x3420
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
addq $0x20, %rsi
movq (%rsp), %rdx
callq 0x2fc0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/sort.c
// Function: insert_content
void	insert_content(char cont[][256], t_u_char *flags, size_t c, char *str)
{
	if (flags['r'] && !flags['t'])
		binsert(cont, str, c, &alpha_rev);
	else if (flags['r'] && flags['t'])
		binsert(cont, str, c, &time_rev);
	else if (flags['t'])
		binsert(cont, str, c, &time_cmp);
	else
		binsert(cont, str, c, &alpha_cmp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x72(%rax), %eax
cmpl $0x0, %eax
je 0x2641
movq 0x18(%rsp), %rax
cmpb $0x0, 0x74(%rax)
jne 0x2641
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x99(%rip), %rcx        # 0x26d0
callq 0x3270
jmp 0x26c1
movq 0x18(%rsp), %rax
movzbl 0x72(%rax), %eax
cmpl $0x0, %eax
je 0x267a
movq 0x18(%rsp), %rax
movzbl 0x74(%rax), %eax
cmpl $0x0, %eax
je 0x267a
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x1bd(%rip), %rcx       # 0x2830
callq 0x3270
jmp 0x26bf
movq 0x18(%rsp), %rax
cmpb $0x0, 0x74(%rax)
je 0x26a2
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x225(%rip), %rcx       # 0x28c0
callq 0x3270
jmp 0x26bd
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x298(%rip), %rcx       # 0x2950
callq 0x3270
jmp 0x26bf
jmp 0x26c1
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/sort.c
// Function: alpha_rev
int	alpha_rev(char *a, char *b)
{
	char	la;
	char	lb;

	if (*a == '.')
		a++;
	if (*b == '.')
		b++;
	while (*a && *b)
	{
		la = *a;
		if ('A' <= *a && *a <= 'Z')
			la = (*a) + ('a' - 'A');
		lb = *b;
		if ('A' <= *b && *b <= 'Z')
			lb = (*b) + ('a' - 'A');
		if (la != lb)
			return ((la - lb) > 0);
		a++;
		b++;
	}
	return ((*a - *b) > 0);
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x26f5
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2710
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x2712
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1b(%rsp)
je 0x2737
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1b(%rsp)
movb -0x1b(%rsp), %al
testb $0x1, %al
jne 0x2744
jmp 0x2800
movq -0x10(%rsp), %rax
movb (%rax), %al
movb %al, -0x19(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x277c
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x277c
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
addl $0x20, %eax
movb %al, -0x19(%rsp)
movq -0x18(%rsp), %rax
movb (%rax), %al
movb %al, -0x1a(%rsp)
movq -0x18(%rsp), %rax
movsbl (%rax), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x27b4
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x27b4
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
addl $0x20, %eax
movb %al, -0x1a(%rsp)
movsbl -0x19(%rsp), %eax
movsbl -0x1a(%rsp), %ecx
cmpl %ecx, %eax
je 0x27df
movsbl -0x19(%rsp), %eax
movsbl -0x1a(%rsp), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0x2821
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x2712
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movq -0x18(%rsp), %rcx
movsbl (%rcx), %ecx
subl %ecx, %eax
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/sort.c
// Function: time_rev
int	time_rev(char *a, char *b)
{
	struct stat	buf;
	struct stat	buf_next;

	if (lstat(a, &buf) == -1)
		return (0);
	if (lstat(b, &buf_next) == -1)
		return (0);
	return (buf.st_mtime < buf_next.st_mtime);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
movq 0x128(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x10d0
cmpl $-0x1, %eax
jne 0x286e
movl $0x0, 0x134(%rsp)
jmp 0x28ac
movq 0x120(%rsp), %rdi
movq %rsp, %rsi
callq 0x10d0
cmpl $-0x1, %eax
jne 0x2890
movl $0x0, 0x134(%rsp)
jmp 0x28ac
movq 0xe8(%rsp), %rax
cmpq 0x58(%rsp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x134(%rsp)
movl 0x134(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/surfing.c
// Function: print_files
void	print_files(char **files, t_u_char *flags, t_ls *ls)
{
	while (*files)
	{
		print_element(*files, *files, flags, ls);
		if (!flags['l'] && *(files + 1))
			ft_putstr("  ");
		else
			ft_putchar('\n');
		files++;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2b2a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x1b30
movq 0x8(%rsp), %rax
cmpb $0x0, 0x6c(%rax)
jne 0x2b10
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b10
leaq 0x5753(%rip), %rdi      # 0x825c
callq 0x3450
jmp 0x2b1a
movl $0xa, %edi
callq 0x3420
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x2ac2
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/surfing.c
// Function: print_content
void	print_content(char content[][256], char *path, t_ls *ls, size_t size)
{
	size_t	i;
	char	*file;

	i = 0;
	if (ls->flags['l'])
		ft_printf("total %d\n", ls->total / 2);
	while (i < size)
	{
		file = path_file(path, content[i], ls->lslash);
		print_element(file, content[i], ls->flags, ls);
		if (!ls->flags['l'] && (i + 1 < size))
			ft_putstr("  ");
		else
			ft_putchar('\n');
		free(file);
		i++;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8c(%rax)
je 0x2b82
movq 0x20(%rsp), %rax
movl 0x9c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0x5789(%rip), %rdi      # 0x8304
movb $0x0, %al
callq 0x3640
jmp 0x2b84
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2c3b
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq $0x8, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movl 0xa0(%rax), %edx
callq 0x2170
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq $0x8, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rdx
addq $0x20, %rdx
movq 0x20(%rsp), %rcx
callq 0x1b30
movq 0x20(%rsp), %rax
cmpb $0x0, 0x8c(%rax)
jne 0x2c14
movq 0x10(%rsp), %rax
addq $0x1, %rax
cmpq 0x18(%rsp), %rax
jae 0x2c14
leaq 0x564f(%rip), %rdi      # 0x825c
callq 0x3450
jmp 0x2c1e
movl $0xa, %edi
callq 0x3420
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b84
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/surfing.c
// Function: print_dir
void	print_dir(DIR *dir, char *path, t_u_char *flags, t_ls *ls)
{
	char			content[NDIR][256];
	size_t			c;
	char			str[256];
	struct dirent	*dp;

	ft_bzero(content, sizeof(content));
	dp = readdir(dir);
	c = 0;
	init_lsdir(ls, last_slash(path));
	while (dp && c < NDIR)
	{
		str[0] = 0;
		ft_strcat(str, dp->d_name);
		if (str[0] != '.' || (str[0] == '.' && flags['a']))
		{
			insert_content(content, flags, c++, str);
			ls->total += measure_dir(str, path, ls);
		}
		dp = readdir(dir);
	}
	print_content(content, path, ls, c);
	if (flags['R'])
		print_recursive(content, c, path, ls);
}

// Assembly:
subq $0x40158, %rsp          # imm = 0x40158
movq %rdi, 0x40150(%rsp)
movq %rsi, 0x40148(%rsp)
movq %rdx, 0x40140(%rsp)
movq %rcx, 0x40138(%rsp)
leaq 0x130(%rsp), %rdi
movl $0x40000, %esi          # imm = 0x40000
callq 0x7650
movq 0x40150(%rsp), %rdi
callq 0x10f0
movq %rax, 0x18(%rsp)
movq $0x0, 0x128(%rsp)
movq 0x40138(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40148(%rsp), %rdi
callq 0x2250
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2410
xorl %eax, %eax
cmpq $0x0, 0x18(%rsp)
movb %al, 0xf(%rsp)
je 0x2cde
cmpq $0x400, 0x128(%rsp) # imm = 0x400
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2ceb
jmp 0x2da0
movb $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x13, %rsi
callq 0x7380
movsbl 0x20(%rsp), %eax
cmpl $0x2e, %eax
jne 0x2d28
movsbl 0x20(%rsp), %eax
cmpl $0x2e, %eax
jne 0x2d89
movq 0x40140(%rsp), %rax
movzbl 0x61(%rax), %eax
cmpl $0x0, %eax
je 0x2d89
leaq 0x130(%rsp), %rdi
movq 0x40140(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq %rdx, %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
leaq 0x20(%rsp), %rcx
callq 0x25f0
leaq 0x20(%rsp), %rdi
movq 0x40148(%rsp), %rsi
movq 0x40138(%rsp), %rdx
callq 0x22b0
movl %eax, %ecx
movq 0x40138(%rsp), %rax
addl 0x9c(%rax), %ecx
movl %ecx, 0x9c(%rax)
movq 0x40150(%rsp), %rdi
callq 0x10f0
movq %rax, 0x18(%rsp)
jmp 0x2cbd
leaq 0x130(%rsp), %rdi
movq 0x40148(%rsp), %rsi
movq 0x40138(%rsp), %rdx
movq 0x128(%rsp), %rcx
callq 0x2b30
movq 0x40140(%rsp), %rax
cmpb $0x0, 0x52(%rax)
je 0x2df8
leaq 0x130(%rsp), %rdi
movq 0x128(%rsp), %rsi
movq 0x40148(%rsp), %rdx
movq 0x40138(%rsp), %rcx
callq 0x2e00
addq $0x40158, %rsp          # imm = 0x40158
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/surfing.c
// Function: print_recursive
void	print_recursive(char dirs[][256], size_t c, char *path, t_ls *ls)
{
	DIR		*dir;
	size_t	i;
	char	*file;

	i = 0;
	while (i < c)
	{
		file = path_file(path, dirs[i], last_slash(path));
		if (is_file(file) == -1 && is_dir(file) && !is_dot(dirs[i]))
		{
			dir = opendir(file);
			if (dir)
			{
				ft_printf("\n%s:\n", file);
				print_dir(dir, file, ls->flags, ls);
				closedir(dir);
			}
			else
				ft_printf_fd(2, WDIROP, *dirs, strerror(errno));
		}
		else if (is_file(file) <= 0 && !is_dot(dirs[i]))
			ft_printf_fd(2, WACCESS, file, strerror(errno));
		free(file);
		i++;
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x2fb4
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2250
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %edx
callq 0x2170
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1810
cmpl $-0x1, %eax
jne 0x2f3c
movq 0x20(%rsp), %rdi
callq 0x17c0
cmpl $0x0, %eax
je 0x2f3c
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x19c0
cmpl $0x0, %eax
jne 0x2f3c
movq 0x20(%rsp), %rdi
callq 0x1070
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2f09
movq 0x20(%rsp), %rsi
leaq 0x5435(%rip), %rdi      # 0x830e
movb $0x0, %al
callq 0x3640
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq $0x20, %rdx
movq 0x38(%rsp), %rcx
callq 0x2c40
movq 0x30(%rsp), %rdi
callq 0x10c0
jmp 0x2f3a
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq 0x8(%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x53e1(%rip), %rsi      # 0x8314
movb $0x0, %al
callq 0x3570
jmp 0x2f97
movq 0x20(%rsp), %rdi
callq 0x1810
cmpl $0x0, %eax
jg 0x2f95
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rax
shlq $0x8, %rax
addq %rax, %rdi
callq 0x19c0
cmpl $0x0, %eax
jne 0x2f95
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq (%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x507d(%rip), %rsi      # 0x800b
movb $0x0, %al
callq 0x3570
jmp 0x2f97
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2e21
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/depo/.././src//eval/surfing.c
// Function: print_dirs
void	print_dirs(char **dirs, t_u_char *flags, t_ls *ls)
{
	DIR	*dir;

	while (*dirs)
	{
		dir = opendir(*dirs);
		if (dir)
		{
			if (ls->size_f || ls->size_d > 1 || ls->filerr || flags['R'])
				ft_printf("%s:\n", *dirs);
			print_dir(dir, *dirs, flags, ls);
			closedir(dir);
		}
		else
			ft_printf_fd(2, WDIROP, *dirs, strerror(errno));
		dirs++;
		if (*dirs)
			ft_putchar('\n');
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30cb
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x1070
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3071
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3033
movq 0x10(%rsp), %rax
cmpq $0x1, 0x8(%rax)
ja 0x3033
movq 0x10(%rsp), %rax
movzbl 0x98(%rax), %eax
cmpl $0x0, %eax
jne 0x3033
movq 0x18(%rsp), %rax
movzbl 0x52(%rax), %eax
cmpl $0x0, %eax
je 0x3049
movq 0x20(%rsp), %rax
movq (%rax), %rsi
leaq 0x52cd(%rip), %rdi      # 0x830f
movb $0x0, %al
callq 0x3640
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2c40
movq 0x8(%rsp), %rdi
callq 0x10c0
jmp 0x30a3
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x1040
movl (%rax), %edi
callq 0x1150
movq (%rsp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x5278(%rip), %rsi      # 0x8314
movb $0x0, %al
callq 0x3570
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30c6
movl $0xa, %edi
callq 0x3420
jmp 0x2fd3
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libalgorithm/depo/.././src//sorting/strquick.c
// Function: quick
static void	quick(char **list, int low, int high, int f(char *, char *))
{
	int	part;

	if (low < high)
	{
		part = partit(list, low, high, f);
		quick(list, low, part - 1, f);
		quick(list, part + 1, high, f);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3170
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x3180
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movq -0x18(%rbp), %rcx
callq 0x3110
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libalgorithm/depo/.././src//sorting/strquick.c
// Function: partit
static int	partit(char **list, int low, int high, int f(char *, char *))
{
	char	*pivot;
	int		i;
	int		j;

	pivot = list[high];
	i = low;
	j = low;
	while (j < high)
	{
		if (f(list[j], pivot))
		{
			swap(list, i, j);
			i++;
		}
		j++;
	}
	swap(list, i, high);
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x31fa
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x31ef
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movslq -0x28(%rbp), %rdx
callq 0x3220
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x31b2
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x3220
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libalgorithm/depo/.././src//sorting/binsert.c
// Function: binsert
void	binsert(char list[][256], char *str, size_t size, int f(char *, char *))
{
	size_t	pos;

	pos = 0;
	if (size)
		pos = binsearch(list, (t_sizes){0, size - 1}, str, f);
	strins(list, str, pos, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x32ca
movq -0x8(%rbp), %rdi
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x32f0
cltq
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x7140
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libalgorithm/depo/.././src//sorting/binsearch.c
// Function: binsearch
int	binsearch(char array[][256], t_sizes sizes, char *key,
									int f(char *, char *))
{
	size_t	start;
	size_t	end;
	size_t	mid;

	start = sizes.s1;
	end = sizes.s2;
	if ((long)end < 0 || (long)start < 0)
		return (0);
	mid = 0;
	while (start <= end && 0 <= (long)mid)
	{
		mid = (long)(start + (end - start) / 2);
		if (0 <= (long)mid)
		{
			if (f(key, array[mid]))
				end = mid - 1;
			else
				start = mid + 1;
		}
		else
			break ;
	}
	return (start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jl 0x332a
cmpq $0x0, -0x38(%rbp)
jge 0x3336
movl $0x0, -0x4(%rbp)
jmp 0x33c5
movq $0x0, -0x48(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x49(%rbp)
ja 0x3359
xorl %eax, %eax
cmpq -0x48(%rbp), %rax
setle %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3362
jmp 0x33be
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
subq -0x38(%rbp), %rcx
shrq %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq -0x48(%rbp), %rax
jg 0x33ba
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
je 0x33ac
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x33b8
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x33bc
jmp 0x33be
jmp 0x333e
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_repet.c
// Function: ft_repet
int	ft_repet(char c, int i)
{
	int	nb;

	nb = 0;
	while (nb < i)
		nb += ft_write(1, &c, 1);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x3412
movl $0x1, %edi
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x6990
movq %rax, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
jmp 0x33e8
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_putstr.c
// Function: ft_putstr
int	ft_putstr(const char *str)
{
	int	i;

	if (str)
	{
		i = 0;
		while (str[i])
			i++;
		ft_write(1, str, i);
		return (i);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349d
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3483
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x346a
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movl $0x1, %edi
callq 0x6990
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x34a4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdlib/ft_calloc.c
// Function: ft_calloc
void	*ft_calloc(size_t nmemb, size_t size)
{
	void		*mem;

	mem = malloc(size * nmemb);
	if (!mem)
		return (NULL);
	ft_bzero(mem, nmemb * size);
	return (mem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
imulq -0x10(%rbp), %rdi
callq 0x1100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x34e3
movq $0x0, -0x8(%rbp)
jmp 0x34fd
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
imulq -0x18(%rbp), %rsi
callq 0x7650
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdlib/ft_sizei.c
// Function: ft_sizei
size_t	ft_sizei(size_t nb)
{
	int	i;

	if (nb == 0)
		return (1);
	i = 0;
	while (nb)
	{
		nb /= 10;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3529
movq $0x1, -0x8(%rbp)
jmp 0x355c
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3554
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3530
movslq -0x14(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_printf.c
// Function: ft_printf_fd
int	ft_printf_fd(const int fd, const char *format, ...)
{
	va_list	args;
	int		res;

	if (format[0] == '%' && format[1] == 0)
		return (0);
	va_start(args, format);
	res = ft_vfprintf(format, args, fd);
	va_end(args);
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x35ab
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x35f0
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x35f0
movl $0x0, -0x4(%rbp)
jmp 0x3631
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl -0x8(%rbp), %edx
callq 0x3a10
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_printf.c
// Function: ft_printf
int	ft_printf(const char *format, ...)
{
	va_list	args;
	int		res;

	if (format[0] == '%' && format[1] == 0)
		return (0);
	va_start(args, format);
	res = ft_vfprintf(format, args, 1);
	va_end(args);
	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x367b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x36c4
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x36c4
movl $0x0, -0x4(%rbp)
jmp 0x3707
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x3a10
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_vfprintf.c
// Function: interpret
t_flags	interpret(const char *format, int i, int fd)
{
	t_flags	flags;

	flags = init_flags(i, fd);
	flags = ft_flags(format, flags);
	flags = no_flags(format, flags);
	flags = ft_modifiers(format, flags, flags.i - 1);
	flags.type = format[flags.i++];
	manage_exceptions(&flags);
	return (flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x1c8(%rbp)
movq %rdi, -0x1c0(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x4c(%rbp), %rdi
callq 0x3bf0
movq -0x1c8(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
movq -0x1c8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0xc8(%rbp), %rdi
movl $0x3c, %edx
callq 0x10e0
movq -0x1e8(%rbp), %rsi
movups -0xc8(%rbp), %xmm0
movups -0xb8(%rbp), %xmm1
movups -0xa8(%rbp), %xmm2
movups -0x9c(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x2c(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x88(%rbp), %rdi
callq 0x3d60
movq -0x1c8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
movq -0x1c8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x140(%rbp), %rdi
movl $0x3c, %edx
callq 0x10e0
movq -0x1e0(%rbp), %rsi
movups -0x140(%rbp), %xmm0
movups -0x130(%rbp), %xmm1
movups -0x120(%rbp), %xmm2
movups -0x114(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x2c(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x104(%rbp), %rdi
callq 0x3ff0
movq -0x1c8(%rbp), %rdi
leaq -0x104(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
movq -0x1c8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl 0x34(%rsi), %eax
subl $0x1, %eax
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
movl $0x3c, %edx
callq 0x10e0
movq -0x1d8(%rbp), %rsi
movl -0x1cc(%rbp), %edx
movups -0x1b8(%rbp), %xmm0
movups -0x1a8(%rbp), %xmm1
movups -0x198(%rbp), %xmm2
movups -0x18c(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x2c(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x17c(%rbp), %rdi
callq 0x3e60
movq -0x1c8(%rbp), %rdi
leaq -0x17c(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
movq -0x1c8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x34(%rdi), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x34(%rdi)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, 0x30(%rdi)
callq 0x4110
movq -0x1c0(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AndreIglesias[P]quick_ls/libft/libstd/depo/.././src//c/stdio/ft_printf/ft_vfprintf.c
// Function: vprint
int	vprint(const char *format, t_fdi fdi, va_list ap, int *res)
{
	t_flags	flags;

	if ((valid_conversion(format, fdi.i)) ? 1 : 0)
	{
		flags = interpret(format, fdi.i, fdi.fd);
		*res += manipulation(flags, ap);
		return (flags.i);
	}
	*res += write(fdi.fd, "%", 1);
	return (fdi.i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3c60
cmpl $0x0, %eax
je 0x3964
movb $0x1, %al
testb $0x1, %al
jne 0x396c
jmp 0x39d4
xorl %eax, %eax
testb $0x1, %al
jne 0x396c
jmp 0x39d4
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq -0xa4(%rbp), %rdi
callq 0x3720
leaq -0x68(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
movl $0x3c, %edx
callq 0x10e0
movq -0x20(%rbp), %rdi
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups -0x3c(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x2c(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x41f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x39fd
movl -0x8(%rbp), %edi
leaq 0x4967(%rip), %rsi      # 0x8345
movl $0x1, %edx
callq 0x1060
movq %rax, %rdx
movq -0x28(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)