LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_printenv
void		ft_lst_printenv(t_list_ex *lst)
{
	while (lst)
	{
		ft_putstr(lst->name);
		ft_putchar('=');
		ft_putendl(lst->value);
		lst = lst->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2b84
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4760
movl $0x3d, %edi
callq 0x4730
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b4c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_returnvalue
char		*ft_lst_returnvalue(t_list_ex *lst, char *name)
{
	while (lst)
	{
		if (!ft_strcmp(lst->name, name))
			return (lst->value);
		lst = lst->next;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bd8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3640
cmpl $0x0, %eax
jne 0x2bcb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2be0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ba0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_freelistex
void		ft_freelistex(t_list_ex *lst)
{
	if (lst)
	{
		ft_freelistex(lst->next);
		ft_strdel(&lst->name);
		ft_strdel(&lst->value);
		free(lst);
		lst = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c3a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2bf0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x3d50
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x3d50
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_duplist
t_list_ex	*ft_duplist(t_list_ex *lst)
{
	t_list_ex	*new;

	new = NULL;
	while (lst)
	{
		ft_lstexadd(&new, ft_lstexnew(lst->name, lst->value));
		lst = lst->next;
	}
	return (new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c89
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2860
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x29e0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c54
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_expansion.c
// Function: ft_tilde
int			ft_tilde(char **tab, t_list_ex *lst, char *value, int i)
{
	char			*tmp;
	struct passwd	*pwd;

	pwd = getpwuid(geteuid());
	value = ft_lst_returnvalue(lst, "HOME");
	value = ft_strdup(value
			? value : pwd->pw_dir);
	if (!tab[i][1] || tab[i][1] == '/')
	{
		tmp = tab[i];
		value = ft_strjoinfree(value, tab[i] + 1, FIRST);
		ft_strdel(&tmp);
		tab[i] = value;
		return (TRUE);
	}
	tmp = ft_strcdup(tab[i] + 1, '/');
	if (!(pwd = getpwnam(tmp)))
		return (ft_error_tilde(tab[i], value));
	ft_strdel(&tmp);
	tmp = ft_strchr(tab[i], '/');
	tab[i] = ft_strdup(pwd->pw_dir);
	tab[i] = ft_strjoinfree(tab[i], tmp, FIRST);
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
callq 0x1090
movl %eax, %edi
callq 0x1070
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x94a3(%rip), %rsi      # 0xc175
callq 0x2b90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2cec
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2cf8
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3990
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpb $0x0, 0x1(%rax)
je 0x2d2c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x2d83
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x1, %rsi
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3d50
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x4(%rbp)
jmp 0x2e3d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x1, %rdi
movl $0x2f, %esi
callq 0x39f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10f0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x2dce
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x2e50
movl %eax, -0x4(%rbp)
jmp 0x2e3d
leaq -0x30(%rbp), %rdi
callq 0x3d50
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x2f, %esi
callq 0x37d0
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3990
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq 0x3ba0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_expansion.c
// Function: ft_change_dollar_and_tild
int			ft_change_dollar_and_tild(char **tab, t_list_ex *lst)
{
	int		i;
	char	*value;
	char	*tmp;

	i = 0;
	value = NULL;
	while (tab && tab[i])
	{
		if ((tmp = ft_strchr(tab[i], '$')))
		{
			if (*(tmp + 1))
				ft_dollar(tab, lst, value, i);
		}
		else if (tab[i][0] == '~')
		{
			if (!(ft_tilde(tab, lst, value, i)))
				return (FALSE);
		}
		ft_strdel(&value);
		i++;
	}
	return (TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x31(%rbp)
je 0x2ece
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2eda
jmp 0x2f6b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x24, %esi
callq 0x37d0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2f1a
movq -0x30(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x2f18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x2f80
jmp 0x2f54
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x2f52
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x2ca0
cmpl $0x0, %eax
jne 0x2f50
movl $0x0, -0x4(%rbp)
jmp 0x2f72
jmp 0x2f52
jmp 0x2f54
leaq -0x28(%rbp), %rdi
callq 0x3d50
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2eaf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_expansion.c
// Function: ft_dollar
static void	ft_dollar(char **tab, t_list_ex *lst, char *value, int i)
{
	char	*tmp;
	char	*out;

	tmp = tab[i];
	out = ft_strcdup(tmp, '$');
	tmp = ft_strchr(tmp, '$');
	while (tmp && *tmp)
	{
		if (*(tmp + 1) == '$' || *(tmp + 1) == '?')
		{
			value = ft_itoa(*(tmp + 1) == '$' ? getpid() : g_glob.ret);
			out = ft_strjoinfree_n(&out, &value, BOTH);
			tmp += 2;
		}
		else
		{
			value = ft_strcdup(tmp + 1, '$');
			out = ft_strjoinfree(out, ft_lst_returnvalue(lst, value), FIRST);
			ft_strdel(&value);
			tmp = ft_strchr(tmp + 1, '$');
		}
	}
	ft_strdel(&tab[i]);
	tab[i] = out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x24, %esi
callq 0x39f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movl $0x24, %esi
callq 0x37d0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x2fe7
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2ff3
jmp 0x30c5
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x24, %eax
je 0x300d
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3f, %eax
jne 0x3061
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x24, %eax
jne 0x3024
callq 0x1050
movl %eax, -0x38(%rbp)
jmp 0x3031
leaq 0xe0a5(%rip), %rax      # 0x110d0
movl 0x4(%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edi
callq 0x4970
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x3b40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x30c0
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movl $0x24, %esi
callq 0x39f0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3d50
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movl $0x24, %esi
callq 0x37d0
movq %rax, -0x28(%rbp)
jmp 0x2fcb
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x3d50
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_process_out.c
// Function: ft_process_out
void		ft_process_out(t_list_ex *lst, char *process, char **tab)
{
	char		**env;
	char		*exec;
	int			status;

	env = ft_lst_to_tab(lst);
	exec = NULL;
	if (!(exec = ft_bin(lst, tab[0])))
		exec = ft_strdup(tab[0]);
	if ((g_glob.pid = fork()) == -1)
		ft_dprintf(2, "%s: %s: Command failed\n", process, tab[0]);
	else if (g_glob.pid == 0)
	{
		ft_strdel(&tab[0]);
		tab[0] = ft_strdup(exec);
		if ((g_glob.ret = execve(exec, tab, env)) == -1)
			ft_rights(process, exec);
		exit(g_glob.ret);
	}
	else
	{
		waitpid(g_glob.pid, &status, 0);
		ft_signal(status);
	}
	ft_free_tab_str(env);
	ft_strdel(&exec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x3220
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3143
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3990
movq %rax, -0x28(%rbp)
callq 0x1160
leaq 0xdf81(%rip), %rcx      # 0x110d0
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x3179
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movl $0x2, %edi
leaq 0x9096(%rip), %rsi      # 0xc203
movb $0x0, %al
callq 0x5630
jmp 0x31fb
leaq 0xdf50(%rip), %rax      # 0x110d0
cmpl $0x0, (%rax)
jne 0x31dd
movq -0x18(%rbp), %rdi
callq 0x3d50
movq -0x28(%rbp), %rdi
callq 0x3990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10d0
leaq 0xdf17(%rip), %rcx      # 0x110d0
movl %eax, 0x4(%rcx)
cmpl $-0x1, %eax
jne 0x31ce
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3300
leaq 0xdefb(%rip), %rax      # 0x110d0
movl 0x4(%rax), %edi
callq 0x1150
leaq 0xdeec(%rip), %rax      # 0x110d0
movl (%rax), %edi
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq 0x1130
movl -0x2c(%rbp), %edi
callq 0x3380
jmp 0x31fb
movq -0x20(%rbp), %rdi
callq 0x3d90
leaq -0x28(%rbp), %rdi
callq 0x3d50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_process_out.c
// Function: ft_bin
static char	*ft_bin(t_list_ex *lst, char *command)
{
	char			**bin;
	int				i;
	DIR				*dir;
	char			*ret;

	if (!(bin = ft_strsplit(ft_lst_returnvalue(lst, "PATH"), ':')))
		return (NULL);
	i = 0;
	while (bin[i])
	{
		if ((dir = opendir(bin[i])))
		{
			if ((ret = ft_check_dir(dir, command, bin, i)))
			{
				ft_free_tab_str(bin);
				return (ret);
			}
			closedir(dir);
		}
		i++;
	}
	ft_free_tab_str(bin);
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8f2e(%rip), %rsi      # 0xc169
callq 0x2b90
movq %rax, %rdi
movl $0x3a, %esi
callq 0x4010
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3264
movq $0x0, -0x8(%rbp)
jmp 0x32eb
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x32da
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x32cf
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x34b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x32c6
movq -0x20(%rbp), %rdi
callq 0x3d90
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x32eb
movq -0x30(%rbp), %rdi
callq 0x10b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x326b
movq -0x20(%rbp), %rdi
callq 0x3d90
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_process_out.c
// Function: ft_signal
static void	ft_signal(int status)
{
	g_glob.pid = 0;
	g_glob.ret = WEXITSTATUS(status);
	if (WIFSIGNALED(status))
	{
		if (WTERMSIG(status) == SIGKILL)
			ft_putendl_fd("Killed", 2);
		else if (WTERMSIG(status) == SIGSEGV)
			ft_putendl_fd("Segmentation Fault", 2);
		else if (WTERMSIG(status) == SIGFPE)
			ft_putendl_fd("Floating Point Exception", 2);
		else if (WTERMSIG(status) == SIGABRT)
			ft_putendl_fd("ABORT", 2);
		else if (WTERMSIG(status) == SIGINT)
			ft_putendl_fd("Stopped", 2);
		else if (WTERMSIG(status) == SIGILL)
			ft_putendl_fd("Illegal Instruction", 2);
		else if (WTERMSIG(status) == SIGQUIT)
			ft_putendl_fd("Exit proccess", 2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xdd3e(%rip), %rax      # 0x110d0
movl $0x0, (%rax)
movl -0x4(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
leaq 0xdd25(%rip), %rax      # 0x110d0
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x34a9
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x9, %eax
jne 0x33e6
leaq 0x8e7a(%rip), %rdi      # 0xc251
movl $0x2, %esi
callq 0x4800
jmp 0x34a7
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0xb, %eax
jne 0x3407
leaq 0x8e60(%rip), %rdi      # 0xc258
movl $0x2, %esi
callq 0x4800
jmp 0x34a5
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x8, %eax
jne 0x3425
leaq 0x8e52(%rip), %rdi      # 0xc26b
movl $0x2, %esi
callq 0x4800
jmp 0x34a3
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x6, %eax
jne 0x3443
leaq 0x8e4d(%rip), %rdi      # 0xc284
movl $0x2, %esi
callq 0x4800
jmp 0x34a1
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x2, %eax
jne 0x3461
leaq 0x8e35(%rip), %rdi      # 0xc28a
movl $0x2, %esi
callq 0x4800
jmp 0x349f
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x4, %eax
jne 0x347f
leaq 0x8e1f(%rip), %rdi      # 0xc292
movl $0x2, %esi
callq 0x4800
jmp 0x349d
movl -0x4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x3, %eax
jne 0x349b
leaq 0x8e15(%rip), %rdi      # 0xc2a6
movl $0x2, %esi
callq 0x4800
jmp 0x349d
jmp 0x349f
jmp 0x34a1
jmp 0x34a3
jmp 0x34a5
jmp 0x34a7
jmp 0x34a9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/srcs/ft_process_out.c
// Function: ft_check_dir
static char	*ft_check_dir(DIR *dir, char *command, char **bin, int i)
{
	struct dirent	*mydir;
	char			*path_ex;

	while ((mydir = readdir(dir)))
	{
		if (mydir->d_name[0] != '.'
				&& !ft_strcmp(command, mydir->d_name))
		{
			if (bin[i][ft_strlen(bin[i]) - 1] == '/')
				path_ex = ft_strjoin(bin[i], command);
			else
			{
				path_ex = ft_strjoin(bin[i], "/");
				path_ex = ft_strjoinfree(path_ex, command, FIRST);
			}
			closedir(dir);
			return (path_ex);
		}
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1110
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x35a3
movq -0x30(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
je 0x359e
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x13, %rsi
callq 0x3640
cmpl $0x0, %eax
jne 0x359e
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3c90
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x3559
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a40
movq %rax, -0x38(%rbp)
jmp 0x358b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8c07(%rip), %rsi      # 0xc173
callq 0x3a40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x3ba0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x35ab
jmp 0x34c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/string/ft_strcat.c
// Function: ft_strcat
char	*ft_strcat(char *s1, const char *s2)
{
	size_t		i;
	size_t		j;

	i = ft_strlen(s1);
	j = 0;
	while (s2[j])
		s1[i++] = s2[j++];
	s1[i] = '\0';
	return (s1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c90
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3621
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x35e5
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/string/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36f2
cmpq $0x0, -0x18(%rbp)
jne 0x36f2
movl $0x0, -0x4(%rbp)
jmp 0x37bf
cmpq $0x0, -0x10(%rbp)
jne 0x3711
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x37bf
cmpq $0x0, -0x18(%rbp)
jne 0x372c
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x37bf
jmp 0x372e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3755
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x3763
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x376c
jmp 0x37b8
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 0x37a7
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 0x37bf
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x372e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/string/ft_strrchr.c
// Function: ft_strrchr
char	*ft_strrchr(const char *s, int c)
{
	size_t			i;
	size_t			j;
	unsigned char	c_cp;

	i = 0;
	c_cp = (unsigned char)c;
	if (!c_cp)
		return ((char *)s + ft_strlen(s));
	while (s[i])
	{
		if (c_cp == s[i])
		{
			j = i + 1;
			while (s[j] && s[j] != c_cp)
				j++;
			if (!s[j])
				return ((char *)(s + i));
		}
		i++;
	}
	return ((s[i] == c_cp) ? ((char *)s + i) : NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x38a7
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c90
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3981
jmp 0x38a9
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x394f
movzbl -0x29(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x393e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x3909
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3912
jmp 0x3920
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x38db
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x393c
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3981
jmp 0x393e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x38a9
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3971
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3979
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x3979
movq -0x48(%rbp), %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/ffoissey[P]minishell_42/libft/srcs/string/ft_strctrim.c
// Function: ft_strctrim
char			*ft_strctrim(char const *s, char c)
{
	char	*tmp;
	char	*new_str;
	size_t	len;
	size_t	cp_len;

	tmp = (char *)s;
	if (!s)
		return (NULL);
	while (*tmp && *tmp == c)
		tmp++;
	len = ft_strlen(tmp);
	cp_len = len;
	while ((tmp[len - 1] == c) && len >= 1)
		len--;
	if (len == cp_len)
		return (ft_strdup(tmp));
	if (!(new_str = (char *)malloc(sizeof(char) * (len + 1))))
		return (NULL);
	ft_strncpy(new_str, tmp, len);
	new_str[len] = '\0';
	return (new_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f0e
movq $0x0, -0x8(%rbp)
jmp 0x4002
jmp 0x3f10
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x3f34
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3f3d
jmp 0x3f4b
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3f10
movq -0x20(%rbp), %rdi
callq 0x3c90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x3a(%rbp)
jne 0x3f88
cmpq $0x1, -0x30(%rbp)
setae %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x3f91
jmp 0x3f9f
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3f60
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x3fb8
movq -0x20(%rbp), %rdi
callq 0x3990
movq %rax, -0x8(%rbp)
jmp 0x4002
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1120
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3fdd
movq $0x0, -0x8(%rbp)
jmp 0x4002
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xac80
movq -0x28(%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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/string/ft_strsplit_whitespaces.c
// Function: ft_strsplit_whitespaces
char			**ft_strsplit_whitespaces(char const *s)
{
	char				**tab;
	size_t				count;
	size_t				i;

	if (!s)
		return (NULL);
	i = 0;
	count = 0;
	while (s[i] == ' ' || s[i] == '\t')
		i++;
	if (s[i])
		count = ft_count_words(s);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	if (count)
	{
		if (!(tab = ft_fill_table(s + i, tab)))
		{
			free(tab);
			tab = NULL;
			return (NULL);
		}
	}
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x43a0
movq $0x0, -0x8(%rbp)
jmp 0x4489
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x29(%rbp)
je 0x43db
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x43e4
jmp 0x43f2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x43b0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x440d
movq -0x10(%rbp), %rdi
callq 0x44a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x3, %rdi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4432
movq $0x0, -0x8(%rbp)
jmp 0x4489
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, -0x20(%rbp)
je 0x4481
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4550
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x447f
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x4489
jmp 0x4481
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/string/ft_strsplit_whitespaces.c
// Function: ft_count_words
static size_t	ft_count_words(char const *s)
{
	size_t	count;
	size_t	i;

	count = 0;
	i = 0;
	while (s[i++])
	{
		if (s[i] == ' ' || s[i] == '\t' || !s[i])
		{
			if (s[i - 1] != ' ' && s[i - 1] != '\t')
				count++;
		}
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
cmpb $0x0, (%rax,%rcx)
je 0x453e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x4501
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x4501
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x4539
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x4537
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x4537
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4539
jmp 0x44b8
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/conversion/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	int		tmp;
	size_t	size;
	char	*str;
	int		i;

	i = 0;
	tmp = n;
	size = 0;
	if (n <= 0)
		size = 1;
	while (tmp)
	{
		tmp /= 10;
		size++;
	}
	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	if (!(str = (char *)malloc(sizeof(char) * (size + 1))))
		return (NULL);
	ft_strnbr(n, str, &i);
	str[size] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x499e
movq $0x1, -0x18(%rbp)
jmp 0x49a0
cmpl $0x0, -0x10(%rbp)
je 0x49c2
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x49a0
movslq -0xc(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x49e0
leaq 0x78df(%rip), %rdi      # 0xc2b4
callq 0x3990
movq %rax, -0x8(%rbp)
jmp 0x4a29
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4a05
movq $0x0, -0x8(%rbp)
jmp 0x4a29
movl -0xc(%rbp), %edi
movq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x4a40
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]minishell_42/libft/srcs/conversion/ft_itoa.c
// Function: ft_strnbr
static void	ft_strnbr(int nbr, char *str, int *i)
{
	if (nbr < 0)
	{
		str[*i] = '-';
		(*i)++;
		ft_strnbr(-nbr, str, i);
	}
	else if (nbr <= 9)
	{
		str[*i] = (char)(nbr + '0');
		(*i)++;
	}
	else
	{
		ft_strnbr(nbr / 10, str, i);
		ft_strnbr(nbr % 10, str, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x4a87
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb $0x2d, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
xorl %edi, %edi
subl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a40
jmp 0x4ae6
cmpl $0x9, -0x4(%rbp)
jg 0x4ab0
movl -0x4(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4ae4
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a40
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4a40
jmp 0x4ae6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: on_read
void on_read(uv_udp_t *req, ssize_t nread, const uv_buf_t *buf,
             const struct sockaddr *addr, unsigned flags) {
    (void) flags;
    if(nread > 0) {

        const struct sockaddr_in *addr_in = (const struct sockaddr_in *)addr;
        if(addr) {
            char sender[17] = { 0 };
            uv_ip4_name(addr_in, sender, 16);
            //printf("Recv from %s\n", sender);
            //printf("port = %d\n", addr_in->sin_port);
        }
        //printf("buffer[%d] = %s\n", nread, buf->base);
        //hexdump(buf->base, 0, nread);
        bridge_t *br = (bridge_t*)req->data;
        br_recv(br, buf->base);
    }
    free(buf->base);
    //free(req);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jle 0x246f
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2454
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0x2130
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x10, %edx
callq 0x2250
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x2490
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: osc_send
void osc_send(bridge_t *br, const char *message)
{
    size_t   len   = rtosc_message_length(message, -1);
    char     *copy = (char*)malloc(len);
    memcpy(copy, message, len);
    do_send(br, copy, len);
    //printf("osc sent...<%s>?\n", message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
callq 0xa5d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21e0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
callq 0x2730
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: do_send
static void do_send(bridge_t *br, char *buffer, unsigned len)
{
    if(br->frame_messages >= BR_RATE_LIMIT) {
        br->rlimit_len++;
        br->rlimit = (char**)realloc(br->rlimit, sizeof(char**)*br->rlimit_len);
        br->rlimit[br->rlimit_len-1] = buffer;
        return;
    }
    br->frame_messages++;
    req_t *request = (req_t*)malloc(sizeof(req_t));
    request->data  = buffer;
    uv_buf_t buf   = uv_buf_init((char*)buffer, len);

    struct sockaddr_in send_addr;
    uv_ip4_addr(br->address, br->port, &send_addr);
    uv_udp_send(&request->send_req, &br->socket, &buf, 1, (const struct sockaddr *)&send_addr, send_cb);
    uv_run(br->loop, UV_RUN_NOWAIT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x80, 0xfc(%rax)
jl 0x27bb
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x12c(%rax)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x12c(%rax), %rsi
shlq $0x3, %rsi
callq 0x2230
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x12c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x2853
movq -0x8(%rbp), %rax
movl 0xfc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xfc(%rax)
movl $0x148, %edi            # imm = 0x148
callq 0x2200
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x140(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2080
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xf8(%rax), %esi
leaq -0x40(%rbp), %rdx
callq 0x20c0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdx
movl $0x1, %ecx
leaq -0x40(%rbp), %r8
leaq 0x26c3(%rip), %r9       # 0x4f00
callq 0x2140
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x2, %esi
callq 0x22f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: declone_vec_value
static void
declone_vec_value(const char *type, rtosc_arg_t *val)
{
    int n = strlen(type);
    for(int i=0; i<n; ++i)
        declone_value(type[i], val[i]);
    free(val);
    free((void*)type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2d9f
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movsbl %al, %edi
callq 0x2dc0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2d63
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: declone_value
static void
declone_value(char type, rtosc_arg_t val)
{
    if(type == 'b')
        free(val.b.data);
    else if(type == 's')
        free(strdup(val.s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
jne 0x2dea
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x2e06
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
jne 0x2e04
movq -0x10(%rbp), %rdi
callq 0x22a0
movq %rax, %rdi
callq 0x2030
jmp 0x2e06
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_get_schema
schema_t br_get_schema(bridge_t *br, uri_t uri)
{
    (void) uri;
    schema_t sch;

    //printf("[debug] loading json file\n");
    FILE *f = fopen("schema/test.json", "r");
    if(!f && br->search_path) {
        char tmp[256];
        snprintf(tmp, sizeof(tmp), "%s%s", br->search_path, "schema/test.json");
        f = fopen(tmp, "r");
    }
    if(!f)
        f = fopen("src/osc-bridge/schema/test.json", "r");
    if(!f) {
        printf("[ERROR:Zyn] schema/test.json file is missing.\n");
        printf("[ERROR:Zyn] Please check your installation for problems\n");
        exit(1);
    }
    assert(f && "opening json file");
    fseek(f, 0, SEEK_END);
    size_t len = ftell(f);
    rewind(f);
    char *json = (char*)calloc(1, len+1);
    fread(json, 1, len, f);
    fclose(f);

    printf("[debug] parsing json file\n");
    parse_schema(json, &sch);
    printf("[debug] json parsed succesfully\n");
    sch.json = json;


	return sch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
leaq 0x9333(%rip), %rdi      # 0xc16b
leaq 0x9a57(%rip), %rsi      # 0xc896
callq 0x2260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ea0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
je 0x2ea0
leaq -0x120(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x92dc(%rip), %rdx      # 0xc157
leaq 0x92e9(%rip), %r8       # 0xc16b
movb $0x0, %al
callq 0x2100
leaq -0x120(%rbp), %rdi
leaq 0x99ff(%rip), %rsi      # 0xc896
callq 0x2260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ebe
leaq 0x92ae(%rip), %rdi      # 0xc15c
leaq 0x99e1(%rip), %rsi      # 0xc896
callq 0x2260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2eeb
leaq 0x92b0(%rip), %rdi      # 0xc17c
movb $0x0, %al
callq 0x20e0
leaq 0x92d1(%rip), %rdi      # 0xc1ab
movb $0x0, %al
callq 0x20e0
movl $0x1, %edi
callq 0x2290
cmpq $0x0, -0x18(%rbp)
je 0x2efc
movb $0x1, %al
testb $0x1, %al
jne 0x2efa
jmp 0x2efc
jmp 0x2f1b
leaq 0x92f3(%rip), %rdi      # 0xc1f6
leaq 0x9305(%rip), %rsi      # 0xc20f
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x9306(%rip), %rcx      # 0xc21c
callq 0x2120
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2220
movq -0x18(%rbp), %rdi
callq 0x21c0
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movq -0x128(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x2180
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2070
movq -0x18(%rbp), %rdi
callq 0x20a0
leaq 0x92b8(%rip), %rdi      # 0xc246
movb $0x0, %al
callq 0x20e0
movq -0x140(%rbp), %rsi
movq -0x130(%rbp), %rdi
callq 0x7640
leaq 0x92b2(%rip), %rdi      # 0xc261
movb $0x0, %al
callq 0x20e0
movq -0x140(%rbp), %rcx
movq -0x138(%rbp), %rax
movq -0x130(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_default
void br_default(bridge_t *br, schema_t s, uri_t uri)
{
    schema_handle_t handle = sm_get(s, uri);
    if(!sm_valid(handle))
        return;
    if(handle.type == 'i' && handle.default_)
        br_set_value_int(br, uri, atoi(handle.default_));
    else if(handle.type == 'f' && handle.default_)
        br_set_value_float(br, uri, atof(handle.default_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8280
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x50(%rax)
movups -0x28(%rbp), %xmm0
movups %xmm0, 0x40(%rax)
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups -0x48(%rbp), %xmm2
movups -0x38(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8720
cmpl $0x0, %eax
jne 0x306b
jmp 0x30e7
movsbl -0x20(%rbp), %eax
cmpl $0x69, %eax
jne 0x30a5
cmpq $0x0, -0x28(%rbp)
je 0x30a5
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2270
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl %eax, %edx
callq 0x30f0
jmp 0x30e7
movsbl -0x20(%rbp), %eax
cmpl $0x66, %eax
jne 0x30e5
cmpq $0x0, -0x28(%rbp)
je 0x30e5
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2090
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
cvtsd2ss %xmm0, %xmm0
callq 0x31a0
jmp 0x30e7
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_int
void br_set_value_int(bridge_t *br, uri_t uri, int value)
{
    rtosc_arg_t arg = {.i = value};
    if(cache_set(br, uri, 'i', arg, 1)) {
        char buffer[1024];
        rtosc_message(buffer, 1024, uri, "i", value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x69, %edx
movl $0x1, %r9d
callq 0x36f0
cmpl $0x0, %eax
je 0x318a
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %r8d
movl $0x400, %esi            # imm = 0x400
leaq 0x934c(%rip), %rcx      # 0xc498
movb $0x0, %al
callq 0x8900
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x26d0
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq -0x438(%rbp), %rdi
movq %rax, %rsi
callq 0x3490
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_float
void br_set_value_float(bridge_t *br, uri_t uri, float value)
{
    rtosc_arg_t arg = {.f = value};
    if(cache_set(br, uri, 'f', arg, 1)) {
        char buffer[1024];
        rtosc_message(buffer, 1024, uri, "f", value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x66, %edx
movl $0x1, %r9d
callq 0x36f0
cmpl $0x0, %eax
je 0x3245
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x400, %esi            # imm = 0x400
leaq 0x94b3(%rip), %rcx      # 0xc6ba
movb $0x1, %al
callq 0x8900
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x26d0
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq -0x438(%rbp), %rdi
movq %rax, %rsi
callq 0x3490
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_array
void br_set_array(bridge_t *br, uri_t uri, char *type, rtosc_arg_t*args)
{
    if(cache_set_vector(br, uri, type, args)) {
        char buffer[1024*8];
        int len = rtosc_amessage(buffer, sizeof(buffer), uri, type, args);
        (void) len;
        //hexdump(buffer, 0, len);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x32f0
cmpl $0x0, %eax
je 0x32df
leaq -0x2020(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2000, %esi           # imm = 0x2000
callq 0x8f70
movl %eax, -0x2024(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x2020(%rbp), %rsi
callq 0x26d0
movq -0x8(%rbp), %rax
movq %rax, -0x2030(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq -0x2030(%rbp), %rdi
movq %rax, %rsi
callq 0x3490
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: debounce_update
static void debounce_update(bridge_t *br, param_cache_t *line)
{
    uv_update_time(br->loop);
    uint64_t now = uv_now(br->loop);
    double obs   = 1e-3*now;
    for(int i=0; i<br->debounce_len; ++i) {
        if(!strcmp(line->path, br->bounce[i].path)) {
            br->bounce[i].last_set = obs;
            return;
        }
    }
    debounce_push(br, line, obs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2280
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq %rax, -0x18(%rbp)
movaps 0x8b4d(%rip), %xmm0     # 0xc010
movq -0x18(%rbp), %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x8b4c(%rip), %xmm0     # 0xc020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x8b45(%rip), %xmm0     # 0xc030
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jge 0x3563
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x3556
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
jmp 0x3575
jmp 0x3558
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x34fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
callq 0x5070
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_get
static param_cache_t *cache_get(bridge_t *br, uri_t uri)
{
    for(int i=0; i<br->cache_len; ++i)
        if(!strcmp(br->cache[i].path, uri))
	    return br->cache + i;
    cache_push(br, uri);
    return cache_get(br, uri);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0x35f6
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x35e9
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3614
jmp 0x35eb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3597
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3d60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3580
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop