LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_tool_minishell.c
// Function: ft_shlvl
void	ft_shlvl(t_list_ex **lst)
{
	char	*tmp;
	char	*tmp2;
	int		lvl;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
		ft_dprintf(2, "minishell: shell path not found\n");
	ft_lst_changevalue(lst, "SHELL", tmp2);
	ft_strdel(&tmp2);
	if ((tmp = ft_lst_returnvalue(*lst, "SHLVL")))
		lvl = ft_atoi(tmp) + 1;
	else
		lvl = 1;
	tmp = ft_itoa(lvl);
	ft_lst_changevalue(lst, "SHLVL", tmp);
	ft_strdel(&tmp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x17d7
leaq 0x58ff(%rip), %rsi      # 0x70ca
movl $0x2, %edi
xorl %eax, %eax
callq 0x3af8
leaq 0x10(%rsp), %r14
movq (%r14), %rdx
leaq 0x5905(%rip), %rsi      # 0x70eb
movq %rbx, %rdi
callq 0x2378
movq %r14, %rdi
callq 0x2d88
movq (%rbx), %rdi
leaq 0x58f1(%rip), %rsi      # 0x70f1
callq 0x2417
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x181d
movq %rax, %rdi
callq 0x325c
movl %eax, %edi
incl %edi
jmp 0x1822
movl $0x1, %edi
callq 0x32b8
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x58bb(%rip), %rsi      # 0x70f1
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2378
movq %r14, %rdi
callq 0x2d88
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_echo.c
// Function: ft_echo
void		ft_echo(char **tab)
{
	int		i;
	int		flag_n;
	char	*s;

	flag_n = 0;
	i = 0;
	s = NULL;
	ft_quote(tab);
	if (tab[0] && !ft_strcmp(tab[0], "-n"))
	{
		flag_n = 1;
		i++;
	}
	while (tab[i])
	{
		s = ft_strjoinfree(s, tab[i++], FIRST);
		if (tab[i])
			s = ft_strjoinfree(s, " ", FIRST);
	}
	if (!flag_n)
		s = ft_strjoinfree(s, "\n", FIRST);
	ft_putstr(s);
	ft_strdel(&s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
movl $0x27, %esi
callq 0x2e5c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d88
movq %r14, (%rbx)
movq %r14, %rdi
movl $0x22, %esi
callq 0x2e5c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d88
movq %r14, (%rbx)
testq %r14, %r14
je 0x18bf
leaq 0x584d(%rip), %rsi      # 0x70f7
movq %r14, %rdi
callq 0x2a9c
xorl %ecx, %ecx
testl %eax, %eax
setne %bpl
sete %cl
jmp 0x18c4
movb $0x1, %bpl
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rsi
testq %rsi, %rsi
je 0x1917
leaq (%rbx,%rcx,8), %r14
addq $0x8, %r14
leaq 0x57ec(%rip), %rbx      # 0x70c8
movq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x2ccd
movq %rax, 0x8(%rsp)
cmpq $0x0, (%r14)
je 0x190b
movq %rax, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x2ccd
movq %rax, 0x8(%rsp)
movq (%r14), %rsi
addq $0x8, %r14
testq %rsi, %rsi
jne 0x18dc
testb %bpl, %bpl
je 0x1937
movq 0x8(%rsp), %rdi
leaq 0x5827(%rip), %rsi      # 0x714f
movl $0x1, %edx
callq 0x2ccd
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
callq 0x31c8
movq %rbx, %rdi
callq 0x2d88
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_unsetenv
void		ft_unsetenv(t_list_ex **lst, char **tab)
{
	int		i;

	i = 0;
	while (tab[i])
		ft_lstexpop(lst, tab[i++]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x1982
movq %rdi, %r14
addq $0x8, %rbx
movq %r14, %rdi
callq 0x22ca
movq (%rbx), %rsi
addq $0x8, %rbx
testq %rsi, %rsi
jne 0x196e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_env.c
// Function: ft_setenv
void		ft_setenv(t_list_ex **lst, char **tab)
{
	char	*tmp;
	char	*tmp2;

	if (!tab || !tab[0])
		return ;
	if (tab[0] && (tmp = ft_strchr(tab[0], '=')))
	{
		tmp2 = ft_strcdup(tab[0], '=');
		tmp = ft_strdup(tmp + 1);
		if (tmp && *(tmp) == '~')
			if (!ft_tilde(&tmp, *lst, NULL, 0))
				return ;
		ft_lst_changevalue(lst, tmp2, tmp);
		ft_strdel(&tmp2);
		ft_strdel(&tmp);
	}
	else if (tab[0] && tab[1])
	{
		tmp2 = ft_strcdup(tab[0], '=');
		if (tab[1][0] == '~')
			if (!ft_tilde(tab, *lst, NULL, 1))
				return ;
		ft_lst_changevalue(lst, tmp2, tab[1]);
		ft_strdel(&tmp2);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x1a2b
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1a22
movl $0x3d, %esi
callq 0x2b10
movq %rax, (%rsp)
movq (%r14), %rdi
testq %rax, %rax
je 0x1a2c
movl $0x3d, %esi
callq 0x2bd8
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
incq %rdi
callq 0x2bb0
movq %rax, (%rsp)
testq %rax, %rax
je 0x19fc
cmpb $0x7e, (%rax)
jne 0x19fc
movq (%rbx), %rsi
movq %rsp, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x24c4
testl %eax, %eax
je 0x1a22
leaq 0x8(%rsp), %r14
movq (%r14), %rsi
movq %rsp, %r15
movq (%r15), %rdx
movq %rbx, %rdi
callq 0x2378
movq %r14, %rdi
callq 0x2d88
movq %r15, %rdi
callq 0x2d88
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
testq %rdi, %rdi
je 0x1a22
cmpq $0x0, 0x8(%r14)
je 0x1a22
movl $0x3d, %esi
callq 0x2bd8
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rax
cmpb $0x7e, (%rax)
jne 0x1a66
movq (%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x24c4
testl %eax, %eax
je 0x1a22
leaq 0x8(%rsp), %r15
movq (%r15), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2378
jmp 0x1a1a
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_lst_to_tab
char		**ft_lst_to_tab(t_list_ex *lst)
{
	char	**tab;
	int		count;
	int		i;

	count = ft_lstexsize(lst);
	if (!(tab = (char **)malloc(sizeof(char *) * (count + 1))))
		return (NULL);
	tab[count] = NULL;
	i = 0;
	while (lst)
	{
		tab[i] = ft_strnew(ft_strlen(lst->name) + ft_strlen(lst->value) + 2);
		ft_strcat(tab[i], lst->name);
		ft_strcat(tab[i], "=");
		ft_strcat(tab[i], lst->value);
		lst = lst->next;
		i++;
	}
	return (tab);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x2366
movslq %eax, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x1130
testq %rax, %rax
je 0x1d82
movq %rax, %r14
movq $0x0, (%rax,%r15,8)
testq %rbx, %rbx
je 0x1d85
leaq 0x5449(%rip), %r15      # 0x716e
movq %r14, %r13
movq 0x10(%rbx), %rdi
callq 0x2d5c
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x2d5c
leaq (%r12,%rax), %rdi
addq $0x2, %rdi
callq 0x2e1c
movq %rax, %r12
movq %rax, (%r13)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2a64
movq %r12, %rdi
movq %r15, %rsi
callq 0x2a64
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x2a64
movq (%rbx), %rbx
addq $0x8, %r13
testq %rbx, %rbx
jne 0x1d28
jmp 0x1d85
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_env_extend.c
// Function: ft_dup_env
t_list_ex	*ft_dup_env(char **env)
{
	t_list_ex	*lst;
	char		*tmp;
	char		*tmp2;

	lst = NULL;
	while (*env)
	{
		ft_lstexadd(&lst, ft_lstexnew((tmp = ft_strcdup(*env, '=')),
					(tmp2 = ft_strchr(*env, '=')) ? tmp2 + 1 : NULL));
		ft_strdel(&tmp);
		env++;
	}
	return (lst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1e11
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movl $0x3d, %esi
callq 0x2bd8
movq %rax, %r12
movq %rax, 0x10(%rsp)
movq -0x8(%rbx), %rdi
movl $0x3d, %esi
callq 0x2b10
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0x2254
movq %r14, %rdi
movq %rax, %rsi
callq 0x2342
movq %r15, %rdi
callq 0x2d88
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x1dbf
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_curdir
char	*ft_curdir(void)
{
	char	*tmp;
	char	*tmp2;

	tmp = NULL;
	if (!(tmp2 = getcwd(tmp, 0)))
	{
		ft_dprintf(2, "minishell: current dir not found\n");
		return (NULL);
	}
	tmp = ft_strdup(ft_strrchr(tmp2, '/'));
	ft_strdel(&tmp2);
	if (tmp && *(tmp + 1))
	{
		tmp2 = ft_strdup(tmp + 1);
		ft_strdel(&tmp);
		return (tmp2);
	}
	return (tmp);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x10b0
movq %rax, (%rsp)
testq %rax, %rax
je 0x1e95
movq %rax, %rdi
movl $0x2f, %esi
callq 0x2b48
movq %rax, %rdi
callq 0x2bb0
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
callq 0x2d88
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x1eaa
cmpb $0x0, 0x1(%rbx)
je 0x1eaa
incq %rbx
movq %rbx, %rdi
callq 0x2bb0
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2d88
movq (%rsp), %rbx
jmp 0x1eaa
leaq 0x5183(%rip), %rsi      # 0x701f
xorl %ebx, %ebx
movl $0x2, %edi
xorl %eax, %eax
callq 0x3af8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd_access
int		ft_cd_access(t_list_ex *lst, char *tmp, char *s)
{
	DIR		*dir;
	int		ret;

	ret = 0;
	if (access(tmp, F_OK) == -1)
		ret = 1;
	else if (access(tmp, R_OK) == -1)
		ret = -1;
	else if (!(dir = opendir(tmp)))
		ret = -2;
	else
	{
		closedir(dir);
		ft_lst_changevalue(&lst, "PWD", tmp);
		ft_strdel(&tmp);
		return (ft_process_cd(lst, ft_strchr(s, '/')));
	}
	ft_strdel(&tmp);
	g_glob.ret = ret;
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1150
cmpl $-0x1, %eax
je 0x1f41
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x1150
cmpl $-0x1, %eax
je 0x1f48
movq (%rsp), %rdi
callq 0x1060
testq %rax, %rax
je 0x1f4f
movq %rax, %rdi
callq 0x10c0
movq %rsp, %r14
movq (%r14), %rdx
leaq 0x5137(%rip), %rsi      # 0x7044
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2378
movq %r14, %rdi
callq 0x2d88
movq (%r15), %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x2b10
movq %r14, %rdi
movq %rax, %rsi
callq 0x1f72
movl %eax, %ebx
jmp 0x1f66
movl $0x1, %ebx
jmp 0x1f54
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1f54
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq %rsp, %rdi
callq 0x2d88
leaq 0xa175(%rip), %rax      # 0xc0d8
movl %ebx, 0x4(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_process_cd
int		ft_process_cd(t_list_ex *lst, char *s)
{
	char	*new;
	char	*tmp;
	char	*tmp2;

	new = NULL;
	tmp = ft_lst_returnvalue(lst, "PWD");
	if (!s || !s[0])
		return (0);
	else if (s[0] == '/')
		return (ft_process_cd(lst, s + 1));
	else if (!ft_strncmp(s, "..", 2))
	{
		tmp2 = ft_strrchr(tmp + 1, '/');
		new = tmp2 ? ft_strsub(tmp, 0, tmp2 - tmp) : ft_strdup("/");
		ft_lst_changevalue(&lst, "PWD", new);
		ft_strdel(&new);
		return (ft_process_cd(lst, s + 2));
	}
	else if (!ft_strncmp(s, ".", 1) && (*(s + 1) == '/' || !*(s + 1)))
		return (ft_process_cd(lst, s + 1));
	tmp = ft_strcmp(tmp, "/") ? ft_strjoin(tmp, "/") : ft_strdup(tmp);
	tmp2 = ft_strchr(s, '/');
	new = tmp2 ? ft_strsub(s, 0, tmp2 - s) : ft_strdup(s);
	tmp = ft_strjoinfree_n(&tmp, &new, BOTH);
	return (ft_cd_access(lst, tmp, s));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
leaq 0x50b1(%rip), %rsi      # 0x7044
callq 0x2417
movq %rax, 0x8(%rsp)
testq %rbx, %rbx
je 0x1fcb
movzbl (%rbx), %eax
testl %eax, %eax
je 0x211d
cmpl $0x2f, %eax
jne 0x1fd2
movq 0x10(%rsp), %rdi
incq %rbx
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1f72
xorl %eax, %eax
jmp 0x211d
leaq 0x51a7(%rip), %rsi      # 0x7180
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2abc
testl %eax, %eax
je 0x202a
leaq 0x5190(%rip), %rsi      # 0x7181
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2abc
testl %eax, %eax
je 0x205c
movq 0x8(%rsp), %rdi
leaq 0x5175(%rip), %rsi      # 0x7183
callq 0x2a9c
movq 0x8(%rsp), %rdi
testl %eax, %eax
je 0x2076
leaq 0x5160(%rip), %rsi      # 0x7183
callq 0x2bf0
jmp 0x207b
movq 0x8(%rsp), %rdi
incq %rdi
movl $0x2f, %esi
callq 0x2b48
testq %rax, %rax
je 0x20db
movq 0x8(%rsp), %rdi
subq %rdi, %rax
xorl %esi, %esi
movq %rax, %rdx
callq 0x2d18
jmp 0x20e7
movzbl 0x1(%rbx), %eax
cmpl $0x2f, %eax
je 0x2069
testl %eax, %eax
jne 0x2002
incq %rbx
movq 0x10(%rsp), %rdi
jmp 0x1fba
callq 0x2bb0
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x2b10
testq %rax, %rax
je 0x20a4
subq %rbx, %rax
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2d18
jmp 0x20ac
movq %rbx, %rdi
callq 0x2bb0
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %edx
callq 0x2c80
movq %rax, (%r14)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1eb3
jmp 0x211d
leaq 0x50a1(%rip), %rdi      # 0x7183
callq 0x2bb0
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x4f4e(%rip), %rsi      # 0x7044
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x2378
movq %r14, %rdi
callq 0x2d88
movq (%r15), %rdi
addq $0x2, %rbx
movq %rbx, %rsi
callq 0x1f72
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_cd.c
// Function: ft_cd
void	ft_cd(t_list_ex *lst, char *s)
{
	int				ret;
	char			*tru;
	struct passwd	*pwd;

	tru = ft_lst_returnvalue(lst, "PWD");
	if (!s)
	{
		pwd = getpwuid(geteuid());
		if (!(s = ft_lst_returnvalue(lst, "HOME")))
			s = pwd->pw_dir;
	}
	else if (!ft_strcmp(s, "."))
		return ;
	else if (!ft_strcmp(s, "-"))
		s = ft_lst_returnvalue(lst, "OLDPWD");
	if (s && s[0] == '/')
		ft_lst_changevalue(&lst, "PWD", "/");
	if ((ret = ft_process_cd(lst, s)) == 1)
		ft_dprintf(2, "cd: %s: No such file or directory\n", s);
	else if (ret == -1)
		ft_dprintf(2, "cd: %s: Permission denied\n", s);
	else if (ret == -2)
		ft_dprintf(2, "cd: %s: Not a directory\n", s);
	if (ret)
		ft_lst_changevalue(&lst, "PWD", ft_strdup(tru));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x4f05(%rip), %rsi      # 0x7044
callq 0x2417
movq %rax, %rbx
testq %r14, %r14
je 0x218c
leaq 0x502e(%rip), %rsi      # 0x7181
movq %r14, %rdi
callq 0x2a9c
testl %eax, %eax
je 0x2248
leaq 0x5020(%rip), %rsi      # 0x718a
movq %r14, %rdi
callq 0x2a9c
testl %eax, %eax
jne 0x21b8
movq 0x8(%rsp), %rdi
leaq 0x4ebf(%rip), %rsi      # 0x7041
callq 0x2417
movq %rax, %r14
jmp 0x21b8
callq 0x10a0
movl %eax, %edi
callq 0x1070
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x4fde(%rip), %rsi      # 0x7185
callq 0x2417
movq %rax, %r14
testq %rax, %rax
jne 0x21b8
movq 0x20(%r15), %r14
testq %r14, %r14
je 0x21db
cmpb $0x2f, (%r14)
jne 0x21db
leaq 0x4e7a(%rip), %rsi      # 0x7044
leaq 0x4fb2(%rip), %rdx      # 0x7183
leaq 0x8(%rsp), %rdi
callq 0x2378
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1f72
movl %eax, %r15d
leal 0x2(%r15), %eax
leaq 0x4f7a(%rip), %rcx      # 0x7170
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4fc4(%rip), %rsi      # 0x71ca
jmp 0x2218
leaq 0x4fa0(%rip), %rsi      # 0x71af
jmp 0x2218
leaq 0x4f74(%rip), %rsi      # 0x718c
movl $0x2, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3af8
testl %r15d, %r15d
je 0x2248
movq %rbx, %rdi
callq 0x2bb0
leaq 0x4e09(%rip), %rsi      # 0x7044
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
callq 0x2378
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexnew
t_list_ex	*ft_lstexnew(char *name, char *value)
{
	t_list_ex	*list;

	if (!(list = (t_list_ex *)malloc(sizeof(t_list_ex))))
		return (NULL);
	list->next = NULL;
	list->name = ft_strdup(name);
	list->value = ft_strdup(value);
	return (list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1130
testq %rax, %rax
je 0x2292
movq %rax, %rbx
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x2bb0
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x2bb0
movq %rax, 0x8(%rbx)
jmp 0x2294
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_free_node
void		ft_free_node(t_list_ex **lst)
{
	ft_strdel(&(*lst)->name);
	ft_strdel(&(*lst)->value);
	free(*lst);
	*lst = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x2d88
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x2d88
movq (%rbx), %rdi
callq 0x1030
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_list.c
// Function: ft_lstexpop
void		ft_lstexpop(t_list_ex **lst, char *name)
{
	t_list_ex	*before;
	t_list_ex	*tmp;
	int			first;

	before = *lst;
	tmp = *lst;
	first = 0;
	while (tmp)
	{
		if (tmp->name && !ft_strcmp(tmp->name, name))
		{
			if (first != 0)
				before->next = tmp->next;
			else
			{
				before = tmp->next;
				*lst = before;
			}
			ft_free_node(&tmp);
			return ;
		}
		before = tmp;
		first++;
		tmp = tmp->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x230a
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movq %r12, %r14
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x22fa
movq %r15, %rsi
callq 0x2a9c
testl %eax, %eax
je 0x2313
movq %r14, %r12
movq (%r14), %rax
decl %ebp
movq %rax, %r14
testq %rax, %rax
jne 0x22e5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%r14), %rdi
testl %ebp, %ebp
movq (%r14), %rax
cmoveq %rbx, %r12
movq %rax, (%r12)
callq 0x2d88
leaq 0x8(%r14), %rdi
callq 0x2d88
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]minishell_42/srcs/ft_list_extend.c
// Function: ft_lst_changevalue
int			ft_lst_changevalue(t_list_ex **lst, char *name, char *value)
{
	t_list_ex	*tmp;

	tmp = *lst;
	while (tmp)
	{
		if (!ft_strcmp(tmp->name, name))
		{
			ft_strdel(&tmp->value);
			tmp->value = ft_strdup(value);
			return (TRUE);
		}
		tmp = tmp->next;
	}
	ft_lstexadd(lst, ft_lstexnew(name, value));
	return (FALSE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x23c4
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x2a9c
testl %eax, %eax
jne 0x238c
leaq 0x8(%r12), %rdi
callq 0x2d88
movq %rbx, %rdi
callq 0x2bb0
movq %rax, 0x8(%r12)
movl $0x1, %eax
jmp 0x23dc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2254
movq %r14, %rdi
movq %rax, %rsi
callq 0x2342
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2416
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
callq 0x31c8
movl $0x3d, %edi
callq 0x31ac
movq 0x8(%rbx), %rdi
callq 0x31e8
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x23f1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2443
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2a9c
testl %eax, %eax
je 0x2447
movq (%r14), %r14
testq %r14, %r14
jne 0x2429
jmp 0x244b
xorl %ebx, %ebx
jmp 0x244b
movq 0x8(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2480
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2454
leaq 0x10(%rbx), %rdi
callq 0x2d88
leaq 0x8(%rbx), %rdi
callq 0x2d88
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x24b8
movq %rdi, %rbx
movq %rsp, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x2254
movq %r14, %rdi
movq %rax, %rsi
callq 0x2342
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2498
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x10a0
movl %eax, %edi
callq 0x1070
movq %rax, %r14
leaq 0x4c97(%rip), %rsi      # 0x7185
movq %r15, %rdi
callq 0x2417
testq %rax, %rax
jne 0x24ff
movq 0x20(%r14), %rax
movq %rax, %rdi
callq 0x2bb0
movq %rax, %r14
movslq %ebp, %r12
movq (%rbx,%r12,8), %rax
leaq 0x1(%rax), %rsi
movzbl 0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x2522
testl %ecx, %ecx
jne 0x254e
movq %rsp, %r15
movq %rax, (%r15)
movl $0x1, %ebp
movq %r14, %rdi
movl $0x1, %edx
callq 0x2ccd
movq %rax, %r14
movq %r15, %rdi
callq 0x2d88
movq %r14, (%rbx,%r12,8)
jmp 0x25df
movq %rsi, %rdi
movl $0x2f, %esi
callq 0x2bd8
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x1100
testq %rax, %rax
je 0x25b3
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
callq 0x2d88
movq (%rbx,%r12,8), %rdi
movl $0x2f, %esi
callq 0x2b10
movq %rax, (%r14)
movq 0x20(%r15), %rdi
callq 0x2bb0
movq %rax, (%rbx,%r12,8)
movq (%r14), %rsi
movl $0x1, %ebp
movq %rax, %rdi
movl $0x1, %edx
callq 0x2ccd
movq %rax, (%rbx,%r12,8)
jmp 0x25df
movq (%rbx,%r12,8), %rdx
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
incq %rdx
leaq 0x4c1a(%rip), %rsi      # 0x71e3
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x3af8
movq %rbx, %rdi
callq 0x2d88
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x2788
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rbx
leaq 0x18(%rsp), %rbp
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x2788
movl $0x24, %esi
callq 0x2b10
testq %rax, %rax
je 0x2757
cmpb $0x0, 0x1(%rax)
je 0x2774
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%r14,%r15,8), %r12
movq %r12, %rdi
movl $0x24, %esi
callq 0x2bd8
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movl $0x24, %esi
callq 0x2b10
testq %rax, %rax
je 0x273b
movq %rax, %r12
cmpb $0x0, (%r12)
je 0x273b
movzbl 0x1(%r12), %eax
cmpl $0x3f, %eax
je 0x26af
cmpl $0x24, %eax
jne 0x26de
callq 0x1050
movl %eax, %edi
jmp 0x26b9
leaq 0x9a22(%rip), %rax      # 0xc0d8
movl 0x4(%rax), %edi
callq 0x32b8
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x3, %edx
callq 0x2c80
movq %rax, 0x8(%rsp)
addq $0x2, %r12
jmp 0x2732
incq %r12
movq %r12, %rdi
movl $0x24, %esi
callq 0x2bd8
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %r13
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x2417
movq %r13, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2ccd
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x2d88
movq %r12, %rdi
movl $0x24, %esi
callq 0x2b10
movq %rax, %r12
testq %r12, %r12
jne 0x268b
leaq (%r14,%r15,8), %r12
movq %r12, %rdi
callq 0x2d88
movq 0x8(%rsp), %rax
movq %rax, (%r12)
leaq 0x10(%rsp), %r12
jmp 0x2774
movq (%r14,%r15,8), %rax
cmpb $0x7e, (%rax)
jne 0x2774
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl %r15d, %ecx
callq 0x24c4
testl %eax, %eax
je 0x279c
movq %r12, %rdi
callq 0x2d88
incq %r15
testq %r14, %r14
jne 0x2628
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x278d
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2d5c
movb (%r14), %cl
testb %cl, %cl
je 0x2a8d
incq %r14
movb %cl, (%rbx,%rax)
incq %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x2a7d
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
orq %rsi, %rax
je 0x2b01
testq %rdi, %rdi
je 0x2b04
testq %rsi, %rsi
je 0x2b0a
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x2ae1
cmpq %rdx, %rcx
jb 0x2aee
jmp 0x2b01
xorl %eax, %eax
cmpq %rdx, %rcx
jae 0x2b00
cmpb $0x0, (%rsi,%rcx)
je 0x2b00
movzbl (%rsi,%rcx), %eax
incq %rcx
cmpb %al, %r8b
je 0x2ad0
subl %eax, %r8d
movl %r8d, %eax
retq
xorl %eax, %eax
retq
movsbl (%rsi), %eax
negl %eax
retq
movsbl (%rdi), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
andl $0xff, %esi
je 0x2b97
movb (%rbx), %dil
testb %dil, %dil
je 0x2ba4
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
movsbl %dil, %edi
cmpl %edi, %esi
jne 0x2b85
movq %rcx, %rdi
movsbl (%rdi), %r8d
testl %r8d, %r8d
je 0x2b80
incq %rdi
cmpl %r8d, %esi
jne 0x2b6f
testb %r8b, %r8b
je 0x2ba8
movb 0x1(%rbx,%rdx), %dil
incq %rdx
incq %rcx
testb %dil, %dil
jne 0x2b64
jmp 0x2bae
movq %rbx, %rdi
callq 0x2d5c
addq %rbx, %rax
jmp 0x2bae
xorl %eax, %eax
jmp 0x2bae
addq %rdx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2edc
movl %esi, %ebp
movq %rdi, %rbx
decq %rbx
movb 0x1(%rbx), %al
incq %rbx
testb %al, %al
je 0x2e80
cmpb %bpl, %al
je 0x2e71
movq %rbx, %rdi
callq 0x2d5c
movq %rax, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
decq %r12
testq %rax, %rax
je 0x2ea1
cmpb %bpl, -0x1(%rbx,%rax)
je 0x2e8e
cmpq $-0x1, %r12
je 0x2eeb
leaq (%r14,%r12), %rdi
addq $0x2, %rdi
callq 0x1130
testq %rax, %rax
je 0x2edc
movq %rax, %r15
leaq (%r14,%r12), %rdx
incq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6758
movq %r15, %rax
addq %r14, %rax
movb $0x0, 0x1(%r12,%rax)
jmp 0x2edf
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2bb0
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x318c
movq %rdi, %r12
movzbl (%r12), %ebp
cmpl $0x9, %ebp
je 0x3076
cmpl $0x20, %ebp
jne 0x307b
incq %r12
jmp 0x3067
testl %ebp, %ebp
je 0x30bf
movb (%rdi), %dl
testb %dl, %dl
je 0x30bf
incq %rdi
xorl %r14d, %r14d
movabsq $0x100000201, %rax      # imm = 0x100000201
movzbl (%rdi), %ecx
cmpq $0x20, %rcx
ja 0x30b4
btq %rcx, %rax
jae 0x30b4
cmpb $0x9, %dl
je 0x30b4
movzbl %dl, %edx
cmpl $0x20, %edx
je 0x30b4
incq %r14
incq %rdi
movl %ecx, %edx
testb %cl, %cl
jne 0x3095
jmp 0x30c2
xorl %r14d, %r14d
leaq 0x8(,%r14,8), %rdi
callq 0x1130
testq %rax, %rax
je 0x318c
movq %rax, %rbx
movq $0x0, (%rax,%r14,8)
testq %r14, %r14
sete %al
testb %bpl, %bpl
sete %cl
orb %al, %cl
jne 0x318e
movl $0x1, %ebp
xorl %r13d, %r13d
xorl %r14d, %r14d
movzbl (%r12,%rbp), %eax
cmpq $0x20, %rax
ja 0x3169
movabsq $0x100000201, %rcx      # imm = 0x100000201
btq %rax, %rcx
jae 0x3169
movq %rbp, %r15
subq %r14, %r15
leaq 0x1(%r15), %rdi
callq 0x1130
movq %rax, (%rbx,%r13,8)
testq %rax, %rax
je 0x3187
addq %r12, %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6758
movq (%rbx,%r13,8), %rax
movb $0x0, (%rax,%r15)
movzbl (%r12,%rbp), %eax
cmpl $0x20, %eax
je 0x315e
cmpl $0x9, %eax
jne 0x3163
incq %rbp
jmp 0x314f
incq %r13
movq %rbp, %r14
cmpb $0x0, (%r12,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x3102
jmp 0x318e
movq (%rbx,%r13,8), %rdi
callq 0x1030
movq $0x0, (%rbx,%r13,8)
decq %r13
jne 0x3176
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl $0x0, 0xc(%rsp)
xorl %r15d, %r15d
testl %edi, %edi
setle %r15b
je 0x32fa
movl %ebx, %eax
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rax
addl %edx, %eax
incq %r15
addl $0x9, %ecx
cmpl $0x12, %ecx
ja 0x32d8
movl %ebx, %eax
negl %eax
jno 0x3315
leaq 0x3fe6(%rip), %rdi      # 0x72ed
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2bb0
leaq 0x1(%r15), %rdi
callq 0x1130
testq %rax, %rax
je 0x333c
movq %rax, %r14
leaq 0xc(%rsp), %rdx
movl %ebx, %edi
movq %rax, %rsi
callq 0x334c
movb $0x0, (%r14,%r15)
jmp 0x333f
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
testl %ebp, %ebp
js 0x338f
cmpl $0x9, %ebp
jle 0x339d
movl %ebp, %r15d
imulq %r12, %r15
shrq $0x23, %r15
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x334c
addl %r15d, %r15d
leal (%r15,%r15,4), %eax
subl %eax, %ebp
jmp 0x3362
movslq (%rbx), %rax
movb $0x2d, (%r14,%rax)
incl (%rbx)
negl %ebp
jmp 0x3362
addb $0x30, %bpl
movslq (%rbx), %rax
movb %bpl, (%r14,%rax)
incl (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
jle 0x24ed
movq %rdi, %r14
testq %rcx, %rcx
je 0x24e2
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
movb $0x0, 0x10(%rsi)
movl $0x10, %edx
movq %rcx, %rdi
callq 0x2260
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x24fe
movq (%rbx), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq $-0x1, %rsi
callq 0x791c
movq %rax, %r15
movq %rax, %rdi
callq 0x2200
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2722
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xfc(%rdi), %eax
cmpl $0x80, %eax
jl 0x277e
movslq 0x12c(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x12c(%rbx)
movq 0x118(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2240
movq %rax, 0x118(%rbx)
movslq 0x12c(%rbx), %rcx
movq %r14, -0x8(%rax,%rcx,8)
jmp 0x27f7
movl %edx, %r15d
incl %eax
movl %eax, 0xfc(%rbx)
movl $0x148, %edi            # imm = 0x148
callq 0x2200
movq %rax, %r12
movq %r14, 0x140(%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x20a0
leaq -0x30(%rbp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq 0xf0(%rbx), %rdi
movl 0xf8(%rbx), %esi
leaq -0x40(%rbp), %r15
movq %r15, %rdx
callq 0x20e0
leaq 0x8(%rbx), %rsi
leaq 0x1a03(%rip), %r9       # 0x41da
movq %r12, %rdi
movq %r14, %rdx
movl $0x1, %ecx
movq %r15, %r8
callq 0x2150
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x2310
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_create
bridge_t *br_create(uri_t uri)
{
    bridge_t *br = (bridge_t*)calloc(1,sizeof(bridge_t));

    br->loop = (uv_loop_t*)calloc(1, sizeof(uv_loop_t));
    uv_loop_init(br->loop);

    uv_udp_init(br->loop, &br->socket);
    int no_collide = rand()%1000;
    for(int offset=0; offset < 1000; ++offset) {
        struct sockaddr_in recv_addr;
        recv_addr.sin_family = AF_INET;
        recv_addr.sin_port = htons(1338+(offset+no_collide)%1000);
        recv_addr.sin_addr.s_addr = INADDR_ANY;
        if(!uv_udp_bind(&br->socket, (const struct sockaddr *)&recv_addr, 0))
            break;
    }
    br->socket.data = br;

    uv_udp_recv_start(&br->socket, alloc_buffer, on_read);

    //parse the url to read
    if(strstr(uri, "osc.udp://") != uri) {
        fprintf(stderr, "[ERROR] Unknown protocol in '%s'\n", uri);
        fprintf(stderr, "[ERROR] Try something like osc.udp://localhost:1234\n");
        exit(1);
    }
    uri = uri+10;
    char *tmp = br->address = strdup(uri);
    while(*tmp && *tmp != ':') ++tmp;
    if(*tmp == ':')
        *tmp++ = 0;

    br->port = atoi(tmp);

    return br;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
movl $0x1, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x2180
movq %rax, %rbx
movl $0x1, %edi
movl $0x350, %esi            # imm = 0x350
callq 0x2180
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rdi
movq %rbx, %r15
addq $0x8, %r15
movq %r15, %rsi
callq 0x21d0
callq 0x22e0
movslq %eax, %r13
imulq $0x10624dd3, %r13, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %r13d
xorl %r14d, %r14d
leaq -0x40(%rbp), %r12
movw $0x2, -0x40(%rbp)
leal (%r14,%r13), %eax
cltq
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x26, %rcx
addl %edx, %ecx
imull $0x3e8, %ecx, %ecx      # imm = 0x3E8
subl %ecx, %eax
addl $0x53a, %eax            # imm = 0x53A
rolw $0x8, %ax
movw %ax, -0x3e(%rbp)
movl $0x0, -0x3c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2190
testl %eax, %eax
je 0x28e0
leal 0x1(%r14), %eax
cmpl $0x3e7, %r14d           # imm = 0x3E7
movl %eax, %r14d
jne 0x2883
movq %rbx, 0x8(%rbx)
leaq 0x7d(%rip), %rsi        # 0x2968
leaq -0x446(%rip), %rdx      # 0x24ac
movq %r15, %rdi
callq 0x2210
leaq 0x6757(%rip), %rsi      # 0x9058
movl $0xa, %edx
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2050
testl %eax, %eax
jne 0x2960
addq $0xa, %r14
movq %r14, %rdi
callq 0x22c0
movq %rax, 0xf0(%rbx)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x2940
cmpl $0x3a, %ecx
je 0x293a
incq %rax
jmp 0x2929
movb $0x0, (%rax)
incq %rax
movq %rax, %rdi
callq 0x2280
movl %eax, 0xf8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_destroy
void br_destroy(bridge_t *br)
{
    int close;
    close = uv_udp_recv_stop(&br->socket);
    if(close)
        fprintf(stderr, "[Warning] UV UDP cannot be stopped [%d] (UV_EBUSY=%d)\n", close, UV_EBUSY);
    else
        fprintf(stderr, "[INFO] UV UDP Stopped\n");
    uv_close((uv_handle_t*)&br->socket, NULL);

    //Flush Events
    int i=100;
    while(uv_run(br->loop, UV_RUN_NOWAIT) > 1)
        if(i-- < 0)
            break;

    close = uv_loop_close(br->loop);
    if(close)
        fprintf(stderr, "[Warning] UV Loop Cannot be closed [%d] (UV_EBUSY=%d)\n", close, UV_EBUSY);
    else
        fprintf(stderr, "[INFO] UV Loop Stopped\n");
    free(br->loop);

    for(int i=0; i<br->cache_len; ++i) {
        free((void*)br->cache[i].path);
        if(br->cache[i].type == 'v') {
            declone_vec_value(br->cache[i].vec_type, br->cache[i].vec_value);
            //free((void*)br->cache[i].vec_type);
            //free((void*)br->cache[i].vec_value);
        } else
            declone_value(br->cache[i].type, br->cache[i].val);
    }
    free(br->cache);
    free(br->bounce);
    for(int i=0; i<br->callback_len; ++i) {
        free((void*)br->callback[i].data);
        free((void*)br->callback[i].path);
    }
    free(br->callback);
    free(br->address);
    free(br);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2060
movq 0xa644(%rip), %r15      # 0xcff8
movq (%r15), %rdi
testl %eax, %eax
jne 0x29c2
callq 0x236e
jmp 0x29d7
leaq 0x66f1(%rip), %rsi      # 0x90ba
movl %eax, %edx
movl $0xfffffff0, %ecx       # imm = 0xFFFFFFF0
xorl %eax, %eax
callq 0x21b0
movq %r14, %rdi
xorl %esi, %esi
callq 0x2070
movl $0x64, %r14d
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x2310
cmpl $0x2, %eax
jl 0x2a05
leal -0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
jns 0x29e7
movq (%rbx), %rdi
callq 0x21f0
movq (%r15), %rdi
testl %eax, %eax
jne 0x2a1b
callq 0x2396
jmp 0x2a30
leaq 0x66e6(%rip), %rsi      # 0x9108
movl %eax, %edx
movl $0xfffffff0, %ecx       # imm = 0xFFFFFFF0
xorl %eax, %eax
callq 0x21b0
movq (%rbx), %rdi
callq 0x2030
cmpl $0x0, 0x120(%rbx)
jle 0x2a9c
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x100(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2030
movq 0x100(%rbx), %rax
movzbl 0x9(%rax,%r14), %ecx
cmpl $0x62, %ecx
je 0x2a7f
cmpl $0x76, %ecx
jne 0x2a89
movq 0x20(%rax,%r14), %rdi
movq 0x28(%rax,%r14), %rsi
callq 0x2b21
jmp 0x2a89
movq 0x28(%rax,%r14), %rdi
callq 0x2030
incq %r15
movslq 0x120(%rbx), %rax
addq $0x30, %r14
cmpq %rax, %r15
jl 0x2a47
movq 0x100(%rbx), %rdi
callq 0x2030
movq 0x108(%rbx), %rdi
callq 0x2030
cmpl $0x0, 0x128(%rbx)
jle 0x2af7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x110(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2030
movq 0x110(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2030
incq %r15
movslq 0x128(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x2ac3
movq 0x110(%rbx), %rdi
callq 0x2030
movq 0xf0(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r15
testl %r15d, %r15d
jle 0x2b6c
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
leaq 0x8(%r14), %r12
xorl %r13d, %r13d
cmpb $0x62, (%rbx,%r13)
jne 0x2b60
movq (%r12), %rdi
callq 0x2030
incq %r13
addq $0x10, %r12
cmpq %r13, %r15
jne 0x2b50
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x65c2(%rip), %rdi      # 0x916b
leaq 0x6cae(%rip), %rsi      # 0x985e
callq 0x2270
movq %rax, %r14
testq %rax, %rax
jne 0x2c04
movq 0xe8(%r15), %rcx
testq %rcx, %rcx
je 0x2c01
leaq 0x6587(%rip), %rdx      # 0x9157
leaq 0x6594(%rip), %r8       # 0x916b
leaq -0x120(%rbp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
leaq 0x6c6a(%rip), %rsi      # 0x985e
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
jmp 0x2c04
xorl %r14d, %r14d
testq %r14, %r14
jne 0x2c1f
leaq 0x654c(%rip), %rdi      # 0x915c
leaq 0x6c47(%rip), %rsi      # 0x985e
callq 0x2270
movq %rax, %r14
testq %r14, %r14
je 0x2caf
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2230
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
movq %r14, %rdi
callq 0x2100
leaq 0x1(%r15), %rsi
movl $0x1, %edi
callq 0x2180
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2090
movq %r14, %rdi
callq 0x20c0
leaq 0x6845(%rip), %rdi      # 0x94c2
callq 0x2080
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5a1f
leaq 0x6848(%rip), %rdi      # 0x94dc
callq 0x2080
movq %r12, (%rbx)
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67a6(%rip), %rdi      # 0x945c
callq 0x2080
leaq 0x67c8(%rip), %rdi      # 0x948a
callq 0x2080
movl $0x1, %edi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x646c
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x672d
testl %eax, %eax
je 0x2d73
movb -0x28(%rbp), %al
cmpb $0x69, %al
sete %cl
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2d4e
callq 0x2280
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2d81
jmp 0x2d73
testq %rdi, %rdi
setne %cl
cmpb $0x66, %al
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x2d73
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e06
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq