LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_atoi.c
// Function: ft_atoi
long int			ft_atoi(const char *str)
{
	long double			res;
	int					sign;
	unsigned int		i;

	res = 0;
	sign = 1;
	i = 0;
	while (str[i] == ' ' || str[i] == '\t' || str[i] == '\n' ||
			str[i] == '\r' || str[i] == '\v' || str[i] == '\f')
		i++;
	if (str[i] == '-' || str[i] == '+')
	{
		if (str[i] == '-')
			sign = -1;
		i++;
	}
	while (str[i] >= '0' && str[i] <= '9')
	{
		res = res * 10 + str[i] - '0';
		i++;
	}
	//printf("NUM: %ld", (long int)res * sign);
	return ((long double)(res * sign));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
fldz
fstpt -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x3d(%rbp)
je 0x7a08
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x3d(%rbp)
je 0x7a08
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x3d(%rbp)
je 0x7a08
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x3d(%rbp)
je 0x7a08
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x3d(%rbp)
je 0x7a08
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0xc, %eax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x7a11
jmp 0x7a1f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x798b
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x7a3f
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
jne 0x7a5f
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x7a56
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7a61
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x3e(%rbp)
jl 0x7a8a
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x3e(%rbp)
movb -0x3e(%rbp), %al
testb $0x1, %al
jne 0x7a93
jmp 0x7ac7
fldt -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
fildl -0x38(%rbp)
flds 0x18cf(%rip)            # 0x937c
fmulp %st, %st(2)
faddp %st, %st(1)
flds 0x18c9(%rip)            # 0x9380
faddp %st, %st(1)
fstpt -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7a61
fldt -0x20(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
fildl -0x34(%rbp)
fmulp %st, %st(1)
fnstcw -0x3a(%rbp)
movzwl -0x3a(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x3c(%rbp)
fldcw -0x3c(%rbp)
fistpll -0x30(%rbp)
fldcw -0x3a(%rbp)
movq -0x30(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	int		size;
	long int	aux;
	char		*num;

	aux = n;
	size = ft_size_num(aux);
	if (!(num = (char *)malloc((size + 1) * sizeof(char))))
		return (NULL);
	num[--size + 1] = '\0';
	if (aux < 0)
		aux = -aux;
	while (size >= 0)
	{
		num[size--] = (aux % 10) + '0';
		aux = aux / 10;
	}
	if (num[0] == '0' && num[1])
		num[0] = '-';
	return (num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c80
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7bd8
movq $0x0, -0x8(%rbp)
jmp 0x7c6b
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
jge 0x7c00
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x7c02
cmpl $0x0, -0x10(%rbp)
jl 0x7c43
movq -0x18(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
addq $0x30, %rdx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
jmp 0x7c02
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x7c63
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x7c63
movq -0x20(%rbp), %rax
movb $0x2d, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_itoa.c
// Function: ft_size_num
static int	ft_size_num(long int n)
{
	size_t i;

	i = 0;
	if (n < 0)
	{
		n = -n;
		i++;
	}
	if (!n)
		return (1);
	while (n > 0)
	{
		n /= 10;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x7cad
xorl %eax, %eax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7cbd
movl $0x1, -0x4(%rbp)
jmp 0x7ced
jmp 0x7cbf
cmpq $0x0, -0x10(%rbp)
jle 0x7ce6
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7cbf
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_memset.c
// Function: ft_memset
void	*ft_memset(void *b, int c, size_t len)
{
	size_t i;

	i = 0;
	while (i < len)
		((unsigned char*)b)[i++] = c;
	return ((void*)b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7d3e
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x7d17
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char *s, int fd)
{
	char endl;

	if (s)
	{
		endl = '\n';
		write(fd, s, ft_strlen(s));
		write(fd, &endl, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7dd1
movb $0xa, -0xd(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8550
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x1040
movl -0xc(%rbp), %edi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_split.c
// Function: ft_split
char			**ft_split(char const *s, char c)
{
	char	**matrix;
	size_t	i;
	size_t	matrix_size;;

	i = 0;
	if (!s)
		return (0);
	matrix_size = ft_count_words(s, c);
	if (!(matrix = (char **)malloc((matrix_size + 1) * sizeof(char*))))
		return (NULL);
	while (i < matrix_size)
	{
		while (*s == c)
			s++;		
		if (!(matrix[i] = ft_get_word(s, c)))
			return (ft_free_all(matrix, i));
		s += ft_strlen(matrix[i]);
		i++;
	}
	matrix[i] = 0;
	return (matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7e5e
movq $0x0, -0x8(%rbp)
jmp 0x7f36
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x7f40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7e97
movq $0x0, -0x8(%rbp)
jmp 0x7f36
jmp 0x7e99
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x7f1e
jmp 0x7ea5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7ec2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7ea5
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x8010
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x7ef4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x80c0
movq %rax, -0x8(%rbp)
jmp 0x7f36
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8550
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7e99
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_split.c
// Function: ft_count_words
static size_t		ft_count_words(char const *s, char c)
{
	size_t i;
	size_t j;

	j = 0;
	i = 0;
	if (!*s)
		return (0);
	if (*s != c)
		i++;
	while (j < ft_strlen(s) - 1)
	{
		if (s[j] == c && s[j + 1] != c)
			i++;
		j++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x7f78
movq $0x0, -0x8(%rbp)
jmp 0x8001
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x7f93
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7f95
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7ff9
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7feb
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x7feb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7f95
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_split.c
// Function: ft_get_word
static	char		*ft_get_word(char const *s, char c)
{
	size_t	j;
	char	*word;

	j = 0;
	while (s[j] != c && s[j])
		j++;
	if (!(word = (char *)malloc((j + 1) * sizeof(char))))
		return (NULL);
	ft_strlcpy(word, s, j + 1);	
	return (word);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
je 0x8058
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x8061
jmp 0x806f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x802a
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8094
movq $0x0, -0x8(%rbp)
jmp 0x80b1
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x8470
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_split.c
// Function: ft_free_all
static char		**ft_free_all(char **matrix, size_t i)
{
	while (i)
		free(matrix[i--]);
	free(matrix);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x80f5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movq (%rax,%rcx,8), %rdi
callq 0x1030
jmp 0x80d0
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	unsigned const char	*p;
	unsigned char		aux;

	aux = (unsigned char)c;
	p = (unsigned const char*)s;
	while (*p)
	{
		if (*p == aux)
			return ((char *)p);
		p++;
	}
	if (aux == 0 && *p == 0)
		return ((char *)p);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8159
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movzbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x814b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8180
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8129
movzbl -0x21(%rbp), %eax
cmpl $0x0, %eax
jne 0x8178
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8178
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8180
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*cpy;

	if (!(cpy = (char *)
		malloc((ft_strlen(s1) + 1) * sizeof(char))))
		return (0);
	ft_strlcpy(cpy, s1, ft_strlen(s1) + 1);
	return (cpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x81c9
movq $0x0, -0x8(%rbp)
jmp 0x81fe
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x8470
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*joint;
	size_t	l;
	size_t	i;
	size_t	j;
	
	if (!s1 || !s2)
		return (0);
	l = ft_strlen(s1) + ft_strlen(s2) + 1;
	if (!(joint = malloc(l * sizeof(char))))
		return (NULL);
	l = 0;
	i = 0;
	j = 0;
	while (l < (ft_strlen(s1) + ft_strlen(s2)))
	{
		if (l < ft_strlen(s1))
			joint[l++] = s1[i++];
		else
			joint[l++] = s2[j++];
	}
	joint[l] = '\0';
	return (joint);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x822e
cmpq $0x0, -0x18(%rbp)
jne 0x823b
movq $0x0, -0x8(%rbp)
jmp 0x8360
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x8287
movq $0x0, -0x8(%rbp)
jmp 0x8360
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8550
movq -0x50(%rbp), %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x834c
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x831b
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x8347
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x829f
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strlcat.c
// Function: ft_strlcat
size_t	ft_strlcat(char *dst, const char *src, size_t dstsize)
{
	size_t i;
	size_t j;
	size_t l_dst;

	l_dst = ft_strlen(dst);
	j = 0;
	if (dstsize < l_dst)
		return (dstsize + ft_strlen(src));
	else
	{
		i = l_dst;
		while (src[j] != '\0' && i < dstsize - 1)
		{
			dst[i] = src[j];
			i++;
			j++;
		}
		dst[i] = '\0';
		return (l_dst + ft_strlen(src));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8550
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x83c7
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x845e
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x83fa
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x8403
jmp 0x8433
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x83cf
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8550
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strlcpy.c
// Function: ft_strlcpy
size_t	ft_strlcpy(char *dest, const char *src, size_t size)
{
	size_t	i;
	size_t	j;

	i = 0;
	j = 0;
	if (!src || !dest)
		return (0);
	i = ft_strlen(src);
	if (size == 0)
		return (i);
	while (j < size - 1 && src[j])
	{ 
		dest[j] = src[j];
		j++;
	}
	dest[j] = '\0';
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x84a2
cmpq $0x0, -0x10(%rbp)
jne 0x84af
movq $0x0, -0x8(%rbp)
jmp 0x853b
movq -0x18(%rbp), %rdi
callq 0x8550
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x84cd
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x853b
jmp 0x84cf
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jae 0x84fa
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x8503
jmp 0x8527
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x84cf
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t i;

	i = 0;
	while (s[i])
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x857c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8560
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strncmp.c
// Function: ft_strncmp
int	ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t	i;
	size_t	aux;

	aux = 1;
	i = 0;
	while (i < n && aux == 1)
	{
		if (s1[i] != s2[i])
			return ((unsigned char)s1[i] - (unsigned char)s2[i]);
		else if (s1[i] == '\0' || s2[i] == '\0')
			aux = 0;
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x85fa
cmpq $0x1, -0x30(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x8603
jmp 0x867b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x863e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8682
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x8660
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x8668
movq $0x0, -0x30(%rbp)
jmp 0x866a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x85e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
size_t	ft_strcmp(char *s1, char *s2)
{
	while (*s2)
	{
		if (*s1 != *s2)
			return (0);
		s1++;
		s2++;
	}
	if (*s1 != *s2)
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x86db
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x86c1
movq $0x0, -0x8(%rbp)
jmp 0x86ff
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x869c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x86f7
movq $0x0, -0x8(%rbp)
jmp 0x86ff
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/vdedios[P]minishell/libft/ft_strnstr.c
// Function: ft_strnstr
char	*ft_strnstr(const char *haystack, const char *needle, size_t len)
{
	int i;
	int j;

	i = 0;
	while (haystack[i] != '\0' && i < (int)len)
	{
		j = 0;
		while (needle[j] && haystack[i + j] == needle[j] && (i + j) < (int)len)
			j++;
		if (!needle[j])
			return ((char *)&haystack[i]);
		j = 0;
		i++;
	}
	if (!needle[0])
		return ((char *)haystack);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x874c
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x8758
jmp 0x87f5
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0x87ad
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x2a(%rbp)
jne 0x87ad
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
setl %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x87b6
jmp 0x87c1
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x875f
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x87e0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8810
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8727
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x8808
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8810
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/./f5pmisc.h
// Function: system_async
static inline int system_async(char* buffer) {
    int i = 0;
    int pid;               //process id
    char* arglist[MAXARG]; //store the arguments
    char* pch;             //for strtok

    pch = strtok(buffer, " \n"); //Initiate breaking into tokens

    for (i = 0; i < MAXARG; i++) { //fill the argument list

        /*if there is a tokened argument add it to the argument list*/
        if (pch != NULL) {
            arglist[i] = malloc(sizeof(char) * 256);
            strcpy(arglist[i], pch);
            pch = strtok(NULL, " \n");
        }

        /*If end of scanned string make the entries in argument list null*/
        else {
            arglist[i] = NULL;
            break;
        }
    }

    /* fork a new process. If child replace the binary. Wait parent till child exists */
    pid = fork();

    if (pid < 0) {
        perror("Fork failed");
        exit(EXIT_FAILURE);
    }
    if (pid == 0) {
        int check = execv(arglist[0], arglist);
        if (check == -1) { /* If cannot execute print an error and exit child*/
            fprintf(stderr,
                    "[%s::ERROR]\033[1;31m Execution failed : %s.\033[0m\n",
                    __func__, strerror(errno));
            exit(EXIT_FAILURE);
        }
    } else {
        return pid;
        //int status;
        //wait(&status); /*parent waits till child closes*/
    }
    return pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1433(%rip), %rsi      # 0x35c4
callq 0x1190
movq %rax, -0x828(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x2220
cmpq $0x0, -0x828(%rbp)
je 0x2201
movl $0x100, %edi            # imm = 0x100
callq 0x1140
movq %rax, %rcx
movslq -0x14(%rbp), %rax
movq %rcx, -0x820(%rbp,%rax,8)
movslq -0x14(%rbp), %rax
movq -0x820(%rbp,%rax,8), %rdi
movq -0x828(%rbp), %rsi
callq 0x1070
xorl %eax, %eax
movl %eax, %edi
leaq 0x13d1(%rip), %rsi      # 0x35c4
callq 0x1190
movq %rax, -0x828(%rbp)
jmp 0x2213
movslq -0x14(%rbp), %rax
movq $0x0, -0x820(%rbp,%rax,8)
jmp 0x2220
jmp 0x2215
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x21a4
callq 0x1210
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x2244
leaq 0x1392(%rip), %rdi      # 0x35c7
callq 0x1180
movl $0x1, %edi
callq 0x11c0
cmpl $0x0, -0x18(%rbp)
jne 0x22b4
movq -0x820(%rbp), %rdi
leaq -0x820(%rbp), %rsi
callq 0x1200
movl %eax, -0x82c(%rbp)
cmpl $-0x1, -0x82c(%rbp)
jne 0x22b2
movq 0x2d85(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, -0x838(%rbp)
callq 0x1060
movl (%rax), %edi
callq 0x11e0
movq -0x838(%rbp), %rdi
movq %rax, %rcx
leaq 0x1339(%rip), %rsi      # 0x35d3
leaq 0x1361(%rip), %rdx      # 0x3602
movb $0x0, %al
callq 0x1130
movl $0x1, %edi
callq 0x11c0
jmp 0x22bc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x22c2
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hasindu2008[P]f5p/./f5pmisc.h
// Function: wait_async
static inline int wait_async(int pid) {
    int status = 0;
    int ret = waitpid(pid, &status, 0);
    if (ret < 0) {
        perror("Waiting failed. Premature exit of a child?");
        exit(EXIT_FAILURE);
    }
    if (WIFEXITED(status)) {
        return WEXITSTATUS(status);
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x1170
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x230f
leaq 0x130f(%rip), %rdi      # 0x360f
callq 0x1180
movl $0x1, %edi
callq 0x11c0
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x232a
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0x2331
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-linearize.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		clean_up_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17360
movq %rax, %rdi
callq 0x11520
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11487
jmp 0x11504
jmp 0x11489
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x114f0
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x114d4
cmpq $0x0, -0x20(%rbp)
jne 0x114d4
jmp 0x114e5
movq -0x20(%rbp), %rdi
callq 0x177d0
movq %rax, %rdi
callq 0x11520
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11490
jmp 0x114f2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x11489
callq 0x3f760
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/test-linearize.c
// Function: clean_up_symbols
static void clean_up_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;

		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			show_entry(ep);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11550
jmp 0x11601
jmp 0x11552
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x115e9
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1159d
cmpq $0x0, -0x10(%rbp)
jne 0x1159d
jmp 0x115db
movq -0x10(%rbp), %rdi
callq 0x11aa0
movq -0x10(%rbp), %rdi
callq 0x1aad0
movq %rax, -0x38(%rbp)
leaq 0x7cd3e(%rip), %rax     # 0x8e2f8
movq (%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
jne 0x115c9
jmp 0x115db
cmpq $0x0, -0x38(%rbp)
je 0x115d9
movq -0x38(%rbp), %rdi
callq 0x19d60
jmp 0x115db
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11559
jmp 0x115eb
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11552
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::add(char const*, Intrinsic)
void Parser::add(const char *token, Intrinsic value) {
  Token t;
  t.asStr = token;
  t.filename = "(intrinsic)";
  t.curLine = 0;
  Symbol *symbol = find(t);
  symbol->isKnown = true;
  symbol->definedLine = symbol->referencedLine;
  symbol->definedFile = symbol->referencedFile;
  symbol->kind = isIntrinsic;
  symbol->asIntrinsic = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6860
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3360
jmp 0x4739
leaq -0x40(%rbp), %rdi
leaq 0xc930(%rip), %rsi      # 0x11074
callq 0x3360
jmp 0x474b
movq -0x90(%rbp), %rdi
movl $0x0, -0x20(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x4800
movq %rax, -0x98(%rbp)
jmp 0x476b
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x88(%rbp), %rax
movl 0x2c(%rax), %ecx
movl %ecx, 0x50(%rax)
movq -0x88(%rbp), %rdi
movq %rdi, %rsi
addq $0x30, %rsi
addq $0x58, %rdi
callq 0x3050
jmp 0x47aa
movq -0x88(%rbp), %rax
movl $0x0, 0x78(%rax)
movl -0x14(%rbp), %ecx
movq -0x88(%rbp), %rax
movl %ecx, 0x80(%rax)
leaq -0x70(%rbp), %rdi
callq 0x68a0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x68a0
movq -0x78(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::find(Token const&)
Symbol *Parser::find(const Token &t) {
  std::string key = t.asStr;
  if (symbols.count(key) == 0) {
    Symbol s;
    s.name = key;
    s.referencedLine = t.curLine;
    s.referencedFile = t.filename;
    symbols.insert(std::pair<std::string, Symbol>(key, s));
  }
  return &symbols[key];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x190(%rbp)
callq 0x3110
movq -0x198(%rbp), %rdi
movq -0x190(%rbp), %rsi
callq 0x69a0
movq %rax, -0x188(%rbp)
jmp 0x4852
movq -0x188(%rbp), %rax
cmpq $0x0, %rax
jne 0x496a
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x6a00
movq -0x1a0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3050
jmp 0x4888
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x9c(%rbp)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
leaq -0x98(%rbp), %rdi
callq 0x3050
jmp 0x48ab
movq -0x198(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x6aa0
jmp 0x48d2
movq -0x1a8(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x6a60
movb %dl, -0x1b1(%rbp)
movq %rax, -0x1b0(%rbp)
jmp 0x48f4
movb -0x1b1(%rbp), %al
movq -0x1b0(%rbp), %rcx
movq %rcx, -0x180(%rbp)
movb %al, -0x178(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x6b00
leaq -0xc8(%rbp), %rdi
callq 0x4350
jmp 0x496a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x499c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x495c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x6b00
leaq -0xc8(%rbp), %rdi
callq 0x4350
jmp 0x499c
movq -0x198(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6b30
movq %rax, -0x1c0(%rbp)
jmp 0x4983
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x1c0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3160
movq -0x38(%rbp), %rdi
callq 0x3490
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::run(std::string directory) {
  DIR *dir = opendir(directory.c_str());
  if (!dir) {
    std::cerr << "Couldn't open directory: " << directory << std::endl;
    return false;
  }
  struct dirent *file;
  while ((file = readdir(dir)) != nullptr) {
    if (file->d_name[0] == '.') {
      continue;
    }
    std::string filename = directory + "/" + file->d_name;
    if (!load(filename)) {
      closedir(dir);
      return false;
    }
  }
  closedir(dir);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdi, %rax
movq -0xb8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x3100
movq %rax, %rdi
callq 0x33f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a38
movq 0x145eb(%rip), %rdi     # 0x18ff0
leaq 0xc674(%rip), %rsi      # 0x11080
callq 0x3230
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
callq 0x3200
movq %rax, %rdi
movq 0x1458e(%rip), %rsi     # 0x18fb8
callq 0x3280
movb $0x0, -0x1(%rbp)
jmp 0x4b8c
jmp 0x4a3a
movq -0x20(%rbp), %rdi
callq 0x3400
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b7f
movq -0x28(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x4a60
jmp 0x4a3a
movq -0xb0(%rbp), %rsi
leaq 0xc62c(%rip), %rdx      # 0x1109a
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6920
movq -0xc0(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x13, %rdx
leaq -0x48(%rbp), %rdi
callq 0x68d0
jmp 0x4a98
leaq -0x68(%rbp), %rdi
callq 0x3160
leaq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3110
jmp 0x4ab3
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4bb0
movb %al, -0xc1(%rbp)
jmp 0x4ace
movb -0xc1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xc2(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3160
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x4af4
jmp 0x4b4e
movq -0x20(%rbp), %rdi
callq 0x3440
jmp 0x4aff
movb $0x0, -0x1(%rbp)
movl $0x1, -0x9c(%rbp)
jmp 0x4b58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3160
jmp 0x4b9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4b74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3160
jmp 0x4b74
movl $0x0, -0x9c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
movl -0x9c(%rbp), %eax
testl %eax, %eax
je 0x4b6f
jmp 0x4b6d
jmp 0x4b8c
jmp 0x4a3a
leaq -0x48(%rbp), %rdi
callq 0x3160
jmp 0x4b9a
movq -0x20(%rbp), %rdi
callq 0x3440
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::load(std::string filename) {
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return false;
  }
  std::streamoff len = f.tellg();
  char *data = new char[len + 1];
  f.seekg(0, std::ios::beg);
  f.read(data, len);
  f.close();

  data[len] = 0;

  File file;
  file.p = data;
  file.end = data + len;
  file.name = filename;
  file.curLine = 1;

  bool okay = parse(&file);
  delete [] data;
  return okay;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rsi, -0x2a8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x6c10
movl %eax, %edi
movl $0x2, %esi
callq 0x6c10
movq -0x2a8(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x3450
movq -0x2a0(%rbp), %rdi
callq 0x3420
movb %al, -0x292(%rbp)
jmp 0x4c20
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x4c56
jmp 0x4c2c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x4e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x4e1c
leaq -0x220(%rbp), %rdi
callq 0x3480
movq %rdx, -0x2c0(%rbp)
movq %rax, -0x2b8(%rbp)
jmp 0x4c72
movq -0x2c0(%rbp), %rax
movq -0x2b8(%rbp), %rcx
movq %rcx, -0x248(%rbp)
movq %rax, -0x240(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x6c30
movq %rax, -0x2c8(%rbp)
jmp 0x4ca3
movq -0x2c8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
incq %rdi
callq 0x3030
movq %rax, -0x2d0(%rbp)
jmp 0x4cc9
movq -0x2d0(%rbp), %rax
movq %rax, -0x250(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x220(%rbp), %rdi
callq 0x3350
jmp 0x4ce9
movq -0x250(%rbp), %rsi
movq -0x238(%rbp), %rdx
leaq -0x220(%rbp), %rdi
callq 0x3310
jmp 0x4d05
leaq -0x220(%rbp), %rdi
callq 0x3090
jmp 0x4d13
movq -0x250(%rbp), %rax
movq -0x238(%rbp), %rcx
movb $0x0, (%rax,%rcx)
leaq -0x290(%rbp), %rdi
callq 0x6c50
movq -0x2a8(%rbp), %rsi
movq -0x250(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x250(%rbp), %rax
movq -0x238(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x280(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x3050
jmp 0x4d6c
movq -0x2b0(%rbp), %rdi
movl $0x1, -0x258(%rbp)
leaq -0x290(%rbp), %rsi
callq 0x4e40
movb %al, -0x2d1(%rbp)
jmp 0x4d91
movb -0x2d1(%rbp), %al
andb $0x1, %al
movb %al, -0x291(%rbp)
movq -0x250(%rbp), %rax
movq %rax, -0x2e0(%rbp)
cmpq $0x0, %rax
je 0x4dbf
movq -0x2e0(%rbp), %rdi
callq 0x3320
movb -0x291(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x6c70
jmp 0x4e02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x6c70
jmp 0x4e1c
leaq -0x220(%rbp), %rdi
callq 0x30b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x30b0
movq -0x228(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parse(File*)
bool Parser::parse(File *file) {
  Token token;
  while ((token = file->token()).type != END) {
    switch (token.type) {
      case VAR:
        if (!addDefinition(token, file)) {
          return false;
        }
        break;
      default:
        error(file, "Expected a definition\n");
        return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6860
movq -0x18(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0xc500
jmp 0x4e79
leaq -0x70(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x6c90
movl (%rax), %eax
movl %eax, -0xe4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x68a0
movl -0xe4(%rbp), %eax
cmpl $0x0, %eax
je 0x4f40
movl -0x70(%rbp), %eax
subl $0x7, %eax
je 0x4ed6
jmp 0x4f10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x68a0
jmp 0x4f65
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x70(%rbp), %rsi
callq 0x4f80
movb %al, -0xe5(%rbp)
jmp 0x4ef2
movb -0xe5(%rbp), %al
testb $0x1, %al
jne 0x4f0e
jmp 0x4efe
movb $0x0, -0x1(%rbp)
movl $0x1, -0xd8(%rbp)
jmp 0x4f4e
jmp 0x4f3b
movq -0xe0(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xc17a(%rip), %rdx      # 0x1109c
xorl %eax, %eax
callq 0x52f0
jmp 0x4f2b
movb $0x0, -0x1(%rbp)
movl $0x1, -0xd8(%rbp)
jmp 0x4f4e
jmp 0x4e67
movb $0x1, -0x1(%rbp)
movl $0x1, -0xd8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x68a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::error(File*, char const*, ...)
void Parser::error(File *f, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", f->name.c_str(), f->curLine);
  vfprintf(stderr, format, args);

  va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5328
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq 0x13c5f(%rip), %rax     # 0x18fd0
movq %rax, -0xe8(%rbp)
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x3100
movq -0xf0(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
leaq 0xbdca(%rip), %rsi      # 0x11171
xorl %eax, %eax
callq 0x33a0
movq -0xe8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3340
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseAlias(Symbol*, File*)
bool Parser::parseAlias(Symbol *s, File *f) {
  Ref *ref = new Ref();
  s->asAlias = ref;
  s->kind = isAlias;
  if (!parseRef(ref, f)) {
    return false;
  }
  return f->token().expect(';');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x30, %edi
callq 0x3240
movq %rax, %rdi
movq %rdi, -0xa0(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x3140
movq -0xa0(%rbp), %rdi
callq 0x6f20
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x78(%rax)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6320
testb $0x1, %al
jne 0x5ec1
movb $0x0, -0x1(%rbp)
jmp 0x5f21
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xc500
movq -0xb0(%rbp), %rdi
movl $0x3b, %esi
callq 0xc990
movb %al, -0xa1(%rbp)
jmp 0x5eee
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
jmp 0x5f21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
jmp 0x5f2f
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3490
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseArgument(Argument*, Token const&, File*)
bool Parser::parseArgument(Argument *arg, const Token &def, File *f) {
  arg->key = def.asStr;
  if (!f->token().expect(':')) {
    return false;
  }
  return parseRef(&arg->ref, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdi
callq 0x3050
movq -0x28(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc500
movq -0x98(%rbp), %rdi
movl $0x3a, %esi
callq 0xc990
movb %al, -0x8d(%rbp)
jmp 0x6294
movb -0x8d(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa1(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x62b7
jmp 0x62da
movb $0x0, -0x1(%rbp)
jmp 0x62f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x68a0
jmp 0x6305
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x28(%rbp), %rdx
callq 0x6320
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)