LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x23a4
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x2a50
testl %eax, %eax
jne 0x236c
leaq 0x8(%r12), %rdi
callq 0x2d50
movq %rbx, %rdi
callq 0x2b6c
movq %rax, 0x8(%r12)
movl $0x1, %eax
jmp 0x23bc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2238
movq %r14, %rdi
movq %rax, %rsi
callq 0x2322
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x23f6
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
callq 0x31c4
movl $0x3d, %edi
callq 0x31a8
movq 0x8(%rbx), %rdi
callq 0x31e4
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x23d1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2423
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x2a50
testl %eax, %eax
je 0x2427
movq (%r14), %r14
testq %r14, %r14
jne 0x2409
jmp 0x242b
xorl %ebx, %ebx
jmp 0x242b
movq 0x8(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2460
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2434
leaq 0x10(%rbx), %rdi
callq 0x2d50
leaq 0x8(%rbx), %rdi
callq 0x2d50
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x249e
movq %rdi, %rbx
movq %rsp, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x2238
movq %r14, %rdi
movq %rax, %rsi
callq 0x2322
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2478
movq (%rsp), %rax
jmp 0x24a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4cb3(%rip), %rsi      # 0x7185
movq %r15, %rdi
callq 0x23f7
testq %rax, %rax
jne 0x24e3
movq 0x20(%r14), %rax
movq %rax, %rdi
callq 0x2b6c
movq %rax, %r14
movslq %ebp, %r12
movq (%rbx,%r12,8), %rax
leaq 0x1(%rax), %rsi
movzbl 0x1(%rax), %ecx
cmpl $0x2f, %ecx
je 0x2506
testl %ecx, %ecx
jne 0x2532
movq %rsp, %r15
movq %rax, (%r15)
movl $0x1, %ebp
movq %r14, %rdi
movl $0x1, %edx
callq 0x2c89
movq %rax, %r14
movq %r15, %rdi
callq 0x2d50
movq %r14, (%rbx,%r12,8)
jmp 0x25c3
movq %rsi, %rdi
movl $0x2f, %esi
callq 0x2b94
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x1100
testq %rax, %rax
je 0x2597
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
callq 0x2d50
movq (%rbx,%r12,8), %rdi
movl $0x2f, %esi
callq 0x2ad4
movq %rax, (%r14)
movq 0x20(%r15), %rdi
callq 0x2b6c
movq %rax, (%rbx,%r12,8)
movq (%r14), %rsi
movl $0x1, %ebp
movq %rax, %rdi
movl $0x1, %edx
callq 0x2c89
movq %rax, (%rbx,%r12,8)
jmp 0x25c3
movq (%rbx,%r12,8), %rdx
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
incq %rdx
leaq 0x4c36(%rip), %rsi      # 0x71e3
xorl %ebp, %ebp
movl $0x2, %edi
xorl %eax, %eax
callq 0x3ad4
movq %rbx, %rdi
callq 0x2d50
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movl $0x1, %eax
testq %rdi, %rdi
je 0x2776
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2776
xorl %r15d, %r15d
leaq 0x10(%rsp), %rbx
leaq 0x18(%rsp), %rbp
leaq (%r14,%r15,8), %r12
movl $0x24, %esi
callq 0x2ad4
testq %rax, %rax
je 0x273b
cmpb $0x0, 0x1(%rax)
je 0x2758
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%r12), %r13
movq %r13, %rdi
movl $0x24, %esi
callq 0x2b94
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movl $0x24, %esi
callq 0x2ad4
testq %rax, %rax
je 0x2723
movq %rax, %r13
cmpb $0x0, (%r13)
je 0x2723
movzbl 0x1(%r13), %eax
cmpl $0x3f, %eax
je 0x2695
cmpl $0x24, %eax
jne 0x26c6
callq 0x1050
movl %eax, %edi
jmp 0x269f
leaq 0x9a3c(%rip), %rax      # 0xc0d8
movl 0x4(%rax), %edi
callq 0x32b4
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movl $0x3, %edx
callq 0x2c3c
movq %rax, 0x8(%rsp)
addq $0x2, %r13
jmp 0x271a
incq %r13
movq %r13, %rdi
movl $0x24, %esi
callq 0x2b94
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x23f7
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x2c89
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x2d50
movq %r13, %rdi
movl $0x24, %esi
callq 0x2ad4
movq %rax, %r13
testq %r13, %r13
jne 0x2672
movq %r12, %rdi
callq 0x2d50
movq 0x8(%rsp), %rax
movq %rax, (%r12)
leaq 0x10(%rsp), %rbx
jmp 0x2758
movq (%r12), %rax
cmpb $0x7e, (%rax)
jne 0x2758
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movl %r15d, %ecx
callq 0x24a8
testl %eax, %eax
je 0x2785
movq %rbx, %rdi
callq 0x2d50
movq 0x8(%r14,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x2618
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x2776
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2d18
movb (%r14), %cl
testb %cl, %cl
je 0x2a41
incq %r14
movb %cl, (%rbx,%rax)
incq %rax
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x2a31
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac4
testq %rdi, %rdi
je 0x2ac7
testq %rsi, %rsi
je 0x2acd
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdi,%rcx), %r8d
testl %r8d, %r8d
je 0x2aa3
cmpq %rdx, %rcx
jae 0x2ac4
movb (%rsi,%rcx), %r9b
jmp 0x2ab1
cmpq %rdx, %rcx
jae 0x2ac3
movb (%rsi,%rcx), %r9b
testb %r9b, %r9b
je 0x2ac3
incq %rcx
cmpb %r9b, %r8b
je 0x2a8e
movzbl %r9b, %eax
subl %eax, %r8d
movl %r8d, %eax
retq
xorl %eax, %eax
retq
movsbl (%rsi), %eax
negl %eax
retq
movsbl (%rdi), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2b53
movb (%rbx), %dil
testb %dil, %dil
je 0x2b60
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
xorl %edx, %edx
movsbl %dil, %edi
cmpl %edi, %esi
jne 0x2b41
movq %rcx, %rdi
movsbl (%rdi), %r8d
testl %r8d, %r8d
je 0x2b3c
incq %rdi
cmpl %r8d, %esi
jne 0x2b2b
testb %r8b, %r8b
je 0x2b64
movb 0x1(%rbx,%rdx), %dil
incq %rdx
incq %rcx
testb %dil, %dil
jne 0x2b20
jmp 0x2b6a
movq %rbx, %rdi
callq 0x2d18
addq %rbx, %rax
jmp 0x2b6a
xorl %eax, %eax
jmp 0x2b6a
addq %rdx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e90
movl %esi, %ebp
movq %rdi, %rbx
decq %rbx
movb 0x1(%rbx), %al
incq %rbx
testb %al, %al
je 0x2e34
cmpb %bpl, %al
je 0x2e25
movq %rbx, %rdi
callq 0x2d18
movq %rax, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rax
decq %r12
testq %rax, %rax
je 0x2e55
cmpb %bpl, -0x1(%rbx,%rax)
je 0x2e42
cmpq $-0x1, %r12
je 0x2e9f
leaq (%r14,%r12), %rdi
addq $0x2, %rdi
callq 0x1130
testq %rax, %rax
je 0x2e90
movq %rax, %r15
leaq (%r14,%r12), %rdx
incq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6c74
movq %r15, %rax
addq %r14, %rax
movb $0x0, 0x1(%r12,%rax)
jmp 0x2e93
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 0x2b6c
nop
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x3166
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movzbl (%r13), %ebp
cmpl $0x9, %ebp
je 0x3062
cmpl $0x20, %ebp
jne 0x3067
incq %r13
jmp 0x3053
testl %ebp, %ebp
je 0x30aa
movb (%rdi), %dl
testb %dl, %dl
je 0x30aa
incq %rdi
xorl %ebx, %ebx
movabsq $0x100000201, %rax      # imm = 0x100000201
movzbl (%rdi), %ecx
cmpq $0x20, %rcx
ja 0x309f
btq %rcx, %rax
jae 0x309f
cmpb $0x9, %dl
je 0x309f
movzbl %dl, %edx
cmpl $0x20, %edx
je 0x309f
incq %rbx
incq %rdi
movl %ecx, %edx
testb %cl, %cl
jne 0x3080
jmp 0x30ac
xorl %ebx, %ebx
leaq 0x8(,%rbx,8), %rdi
callq 0x1130
testq %rax, %rax
je 0x3188
movq $0x0, (%rax,%rbx,8)
testq %rbx, %rbx
sete %dl
testb %bpl, %bpl
sete %cl
orb %dl, %cl
jne 0x318a
movq %rax, (%rsp)
movl $0x1, %r15d
xorl %ebp, %ebp
xorl %r14d, %r14d
movzbl (%r13,%r15), %eax
cmpq $0x20, %rax
ja 0x3159
movabsq $0x100000201, %rcx      # imm = 0x100000201
btq %rax, %rcx
jae 0x3159
movq %r15, %rbx
subq %r14, %rbx
leaq 0x1(%rbx), %rdi
callq 0x1130
movq %rax, %r12
movq (%rsp), %rax
movq %r12, (%rax,%rbp,8)
testq %r12, %r12
je 0x3169
addq %r13, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6c74
movb $0x0, (%r12,%rbx)
movzbl (%r13,%r15), %eax
cmpl $0x20, %eax
je 0x314e
cmpl $0x9, %eax
jne 0x3153
incq %r15
jmp 0x313e
incq %rbp
movq %r15, %r14
incq %r15
testb %al, %al
jne 0x30ed
movq (%rsp), %rax
jmp 0x318a
xorl %eax, %eax
retq
decq %rbp
je 0x3188
movq (%rsp), %rbx
movq (%rbx,%rbp,8), %rdi
callq 0x1030
movq $0x0, (%rbx,%rbp,8)
decq %rbp
jne 0x3172
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x3311
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 0x32d4
movl %ebx, %eax
negl %eax
jno 0x3311
leaq 0x3fe9(%rip), %rdi      # 0x72ec
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2b6c
leaq 0x1(%r15), %rdi
callq 0x1130
testq %rax, %rax
je 0x3338
movq %rax, %r14
leaq 0xc(%rsp), %rdx
movl %ebx, %edi
movq %rax, %rsi
callq 0x3348
movb $0x0, (%r14,%r15)
jmp 0x333b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x338b
cmpl $0x9, %ebp
jbe 0x3399
movl %ebp, %r15d
imulq %r12, %r15
shrq $0x23, %r15
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3348
addl %r15d, %r15d
leal (%r15,%r15,4), %eax
subl %eax, %ebp
jmp 0x335e
movslq (%rbx), %rax
movb $0x2d, (%r14,%rax)
incl (%rbx)
negl %ebp
jmp 0x335e
orb $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_O3/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 0x787b
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 0x2725
// File: /workspace/github_c_makefile_star2_O3/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 0x2781
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 0x27fa
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 0x19ea(%rip), %r9       # 0x41c4
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_O3/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, %r12
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x2160
movq %rbx, %r15
addq $0x8, %r15
movq %r12, %rdi
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 0x28e6
leal 0x1(%r14), %eax
cmpl $0x3e7, %r14d           # imm = 0x3E7
movl %eax, %r14d
jne 0x2889
movq %rbx, 0x8(%rbx)
leaq 0x7d(%rip), %rsi        # 0x296e
leaq -0x44c(%rip), %rdx      # 0x24ac
movq %r15, %rdi
callq 0x2210
leaq 0x6751(%rip), %rsi      # 0x9058
movl $0xa, %edx
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2050
testl %eax, %eax
jne 0x2966
addq $0xa, %r14
movq %r14, %rdi
callq 0x22c0
movq %rax, 0xf0(%rbx)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x2946
cmpl $0x3a, %ecx
je 0x2940
incq %rax
jmp 0x292f
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_O3/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 0xa63e(%rip), %r15      # 0xcff8
movq (%r15), %rdi
testl %eax, %eax
jne 0x29c8
callq 0x236e
jmp 0x29dd
leaq 0x66eb(%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 0x2a0b
leal -0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
jns 0x29ed
movq (%rbx), %rdi
callq 0x21f0
movq (%r15), %rdi
testl %eax, %eax
jne 0x2a21
callq 0x2396
jmp 0x2a36
leaq 0x66e0(%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 0x2aa2
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 0x2a85
cmpl $0x76, %ecx
jne 0x2a8f
movq 0x20(%rax,%r14), %rdi
movq 0x28(%rax,%r14), %rsi
callq 0x2b27
jmp 0x2a8f
movq 0x28(%rax,%r14), %rdi
callq 0x2030
incq %r15
movslq 0x120(%rbx), %rax
addq $0x30, %r14
cmpq %rax, %r15
jl 0x2a4d
movq 0x100(%rbx), %rdi
callq 0x2030
movq 0x108(%rbx), %rdi
callq 0x2030
cmpl $0x0, 0x128(%rbx)
jle 0x2afd
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 0x2ac9
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_O3/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 0x2b72
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
leaq 0x8(%r14), %r12
xorl %r13d, %r13d
cmpb $0x62, (%rbx,%r13)
jne 0x2b66
movq (%r12), %rdi
callq 0x2030
incq %r13
addq $0x10, %r12
cmpq %r13, %r15
jne 0x2b56
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_O3/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 0x65bc(%rip), %rdi      # 0x916b
leaq 0x6ca8(%rip), %rsi      # 0x985e
callq 0x2270
testq %rax, %rax
jne 0x2c20
movq 0xe8(%r15), %rcx
testq %rcx, %rcx
je 0x2c04
leaq 0x6584(%rip), %rdx      # 0x9157
leaq 0x6591(%rip), %r8       # 0x916b
leaq -0x120(%rbp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
leaq 0x6c67(%rip), %rsi      # 0x985e
movq %r14, %rdi
callq 0x2270
testq %rax, %rax
jne 0x2c20
leaq 0x6551(%rip), %rdi      # 0x915c
leaq 0x6c4c(%rip), %rsi      # 0x985e
callq 0x2270
testq %rax, %rax
je 0x2caa
movq %rax, %r14
movq %rax, %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 0x684a(%rip), %rdi      # 0x94c2
callq 0x2080
movq %r12, %rdi
movq %rbx, %rsi
callq 0x59f7
leaq 0x684d(%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 0x67ab(%rip), %rdi      # 0x945c
callq 0x2080
leaq 0x67cd(%rip), %rdi      # 0x948a
callq 0x2080
movl $0x1, %edi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O3/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 0x63a8
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x6665
testl %eax, %eax
je 0x2d6e
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 0x2d49
callq 0x2280
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2d7c
jmp 0x2d6e
testq %rdi, %rdi
setne %cl
cmpb $0x66, %al
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x2d6e
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2e01
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %ecx
movl $0x69, %edx
movl $0x1, %r9d
callq 0x325e
testl %eax, %eax
je 0x2df1
leaq 0x63d5(%rip), %rcx      # 0x9189
leaq -0x420(%rbp), %r12
movl $0x400, %esi            # imm = 0x400
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x6750
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3171
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3071
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %rbx
movd %xmm0, -0x1c(%rbp)
movd %xmm0, %ecx
movl $0x66, %edx
movl $0x1, %r9d
callq 0x325e
testl %eax, %eax
je 0x2e7d
xorps %xmm0, %xmm0
cvtss2sd -0x1c(%rbp), %xmm0
leaq 0x683f(%rip), %rcx      # 0x9682
leaq -0x420(%rbp), %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movb $0x1, %al
callq 0x6750
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3171
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3071
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2f04
testl %eax, %eax
je 0x2ef2
leaq -0x2030(%rbp), %r13
movl $0x2000, %esi           # imm = 0x2000
movq %r13, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x6acf
movq %rbx, %rdi
movq %r13, %rsi
callq 0x26d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3171
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3071
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_set_vector
static int cache_set_vector(bridge_t *br, uri_t uri, char *types, rtosc_arg_t *args)
{
    param_cache_t *line = cache_get(br, uri);
    assert(line);
    line->pending = false;

    int line_size = line->type == 'v' ? strlen(line->vec_type) : 0;

    //If the line is invalid OR
    //the cache isn't a vector field OR
    //the vector fields differ in type OR
    //the vector fields differ in value
    if(!line->valid || line->type != 'v' || strcmp(line->vec_type, types) ||
            memcmp(&line->vec_value, &args, sizeof(args[0])*line_size))
    {
        if(line->type == 'v')
            declone_vec_value(line->vec_type, line->vec_value);
        else
            declone_value(line->type, line->val);

        line->valid     = true;
        line->type      = 'v';
        line->vec_type  = strdup(types);
        line->vec_value = clone_vec_value(types, args);
        line->requests = 0;

        //check if cache line is currently debounced...
        //int debounced = false;
        //for(int i=0; i<br->debounce_len; ++i)
        //    if(!strcmp(br->bounce[i].path, line->path))
        //        debounced = true;

        //if(!debounced)
            run_callbacks(br, line);

        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rcx, -0x40(%rbp)
callq 0x3171
testq %rax, %rax
je 0x3052
movq %rax, %r13
movq %rbx, -0x38(%rbp)
movb 0x8(%rax), %r12b
movl %r12d, %eax
andb $-0x3, %al
movb %al, 0x8(%r13)
movzbl 0x9(%r13), %eax
cmpl $0x62, %eax
je 0x2fa7
cmpl $0x76, %eax
jne 0x2fb0
movq 0x20(%r13), %rbx
movq %rbx, %rdi
callq 0x20d0
testb $0x1, %r12b
je 0x2f99
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %r12
callq 0x21a0
testl %eax, %eax
jne 0x2f99
movq %r12, %rax
movslq %eax, %rdx
shlq $0x4, %rdx
movq %r13, %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0x2220
testl %eax, %eax
je 0x304e
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x2b27
jmp 0x2fb0
movq 0x28(%r13), %rdi
callq 0x2030
orb $0x1, 0x8(%r13)
movb $0x76, 0x9(%r13)
movq %r15, %rdi
callq 0x22c0
movq %r13, -0x30(%rbp)
movq %rax, 0x20(%r13)
movq %r15, %rdi
callq 0x20d0
movq %rax, %r13
movslq %r13d, %r12
movl $0x10, %edi
movq %r12, %rsi
callq 0x2180
movq %rax, %rbx
testl %r12d, %r12d
jle 0x3022
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
shlq $0x4, %r13
xorl %r12d, %r12d
movsbl (%r15), %edi
movq (%r14,%r12), %rsi
movq 0x8(%r14,%r12), %rdx
callq 0x41e7
movq %rax, (%rbx,%r12)
movq %rdx, 0x8(%rbx,%r12)
addq $0x10, %r12
incq %r15
cmpq %r12, %r13
jne 0x2ffb
movq -0x30(%rbp), %rsi
movq %rbx, 0x28(%rsi)
movl $0x0, 0x18(%rsi)
movq -0x38(%rbp), %rdi
callq 0x3f56
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x303f
leaq 0x62a1(%rip), %rdi      # 0x92fa
leaq 0x611c(%rip), %rsi      # 0x917c
leaq 0x6298(%rip), %rcx      # 0x92ff
movl $0x95, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x2290
movq (%r15), %rdi
callq 0x2170
movq %rax, %r14
movslq 0x124(%r15), %r12
testq %r12, %r12
jle 0x30eb
movq %r14, -0x30(%rbp)
movq %rbx, -0x40(%rbp)
movq (%rbx), %r13
movq 0x108(%r15), %rax
movq %rax, -0x38(%rbp)
leaq 0x8(%rax), %rbx
movq %r12, %r14
movq -0x8(%rbx), %rsi
movq %r13, %rdi
callq 0x21a0
testl %eax, %eax
je 0x3131
addq $0x10, %rbx
decq %r14
jne 0x30c4
movq -0x40(%rbp), %rbx
movq -0x30(%rbp), %r14
movq -0x38(%rbp), %rdi
jmp 0x30f2
movq 0x108(%r15), %rdi
movq %r12, %rsi
shlq $0x4, %rsi
leal 0x1(%r12), %eax
movl %eax, 0x124(%r15)
addq $0x10, %rsi
callq 0x2240
movq %rax, 0x108(%r15)
movslq 0x124(%r15), %rcx
shlq $0x4, %rcx
movq (%rbx), %rdx
leaq (%rax,%rcx), %rbx
addq $-0x8, %rbx
movq %rdx, -0x8(%rbx)
jmp 0x3135
movq -0x30(%rbp), %r14
movq %r14, %xmm0
punpckldq 0x5ece(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5ed6(%rip), %xmm0     # 0x9020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x5ed2(%rip), %xmm1     # 0x9030
movsd %xmm1, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x120(%r14), %r12
testq %r12, %r12
jle 0x31ad
movq 0x100(%r14), %r15
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21a0
testl %eax, %eax
je 0x31ba
addq $0x30, %r15
decq %r12
jne 0x3195
movq %r14, %rdi
movq %rbx, %rsi
callq 0x370e
jmp 0x3182
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_bool
void br_set_value_bool(bridge_t *br, uri_t uri, int value)
{
    rtosc_arg_t arg = {.i = value};
    char type = value ? 'T' : 'F';
    if(cache_set(br, uri, type, arg, 1)) {
        char buffer[1024];
        char typestr[2] = {type, '\0'};
        rtosc_message(buffer, 1024, uri, typestr, value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %ecx
testl %edx, %edx
movl $0x46, %eax
movl $0x54, %r12d
cmovel %eax, %r12d
movl %r12d, %edx
movl $0x1, %r9d
callq 0x325e
testl %eax, %eax
je 0x324e
leaq -0x22(%rbp), %rcx
movb %r12b, (%rcx)
movb $0x0, 0x1(%rcx)
leaq -0x430(%rbp), %r12
movl $0x400, %esi            # imm = 0x400
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x6750
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3171
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3071
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_set
static int cache_set(bridge_t *br, uri_t uri, char type, rtosc_arg_t val, int skip_debounce)
{
    param_cache_t *line = cache_get(br, uri);
    assert(line);
    line->pending = false;
    if(!line->valid || line->type != type || memcmp(&line->val, &val, sizeof(val)))
    {
        if(line->type == 'v')
            declone_vec_value(line->vec_type, line->vec_value);
        else
            declone_value(line->type, line->val);
        line->valid = true;
        line->type  = type;
        line->val   = clone_value(type, val);
        line->requests = 0;

        //check if cache line is currently debounced...
        int debounced = false;
        for(int i=0; i<br->debounce_len; ++i)
            if(!strcmp(br->bounce[i].path, line->path))
                debounced = true;

        if(!debounced || skip_debounce)
            run_callbacks(br, line);

        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r14d
movq %rdi, %r15
movq %rcx, -0x50(%rbp)
movq %r8, -0x48(%rbp)
callq 0x3171
testq %rax, %rax
je 0x33a6
movb 0x8(%rax), %cl
movb 0x9(%rax), %sil
movl %ecx, %edx
andb $-0x3, %dl
movb %dl, 0x8(%rax)
cmpb %r14b, %sil
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x32d1
movdqu 0x20(%rax), %xmm0
movdqu -0x50(%rbp), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
movl %r14d, %esi
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x3395
cmpb $0x62, %sil
movq %rax, -0x30(%rbp)
je 0x32f7
movzbl %sil, %ecx
cmpl $0x76, %ecx
jne 0x3304
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2b27
jmp 0x3300
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x30(%rbp), %rax
orb $0x1, 0x8(%rax)
movb %r14b, 0x9(%rax)
movsbl %r14b, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0x41e7
movq -0x30(%rbp), %rsi
movq %rax, 0x20(%rsi)
movq %rdx, 0x28(%rsi)
movl $0x0, 0x18(%rsi)
movslq 0x124(%r15), %r12
testq %r12, %r12
jle 0x3386
movl %ebx, -0x34(%rbp)
movq %r15, -0x40(%rbp)
movq 0x108(%r15), %r13
movq (%rsi), %r14
shlq $0x4, %r12
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r13,%r15), %rdi
movq %r14, %rsi
callq 0x21a0
testl %eax, %eax
movl $0x1, %eax
cmovel %eax, %ebx
addq $0x10, %r15
cmpq %r15, %r12
jne 0x3354
cmpl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %r15
movq -0x30(%rbp), %rsi
jne 0x3386
testl %ebx, %ebx
jne 0x3397
movq %r15, %rdi
callq 0x3f56
movl $0x1, %eax
jmp 0x3397
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f4d(%rip), %rdi      # 0x92fa
leaq 0x5dc8(%rip), %rsi      # 0x917c
leaq 0x5f83(%rip), %rcx      # 0x933e
movl $0x77, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_has_callback
int br_has_callback(bridge_t *br, uri_t uri)
{
    for(int i=0; i < br->callback_len; ++i)
        if(!strcmp(br->callback[i].path, uri))
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x128(%rdi), %r14
testq %r14, %r14
jle 0x3495
movq %rsi, %rbx
movq 0x110(%rdi), %r15
movq (%r15), %rdi
callq 0x21a0
testl %eax, %eax
je 0x3499
addq $0x18, %r15
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %r14
je 0x348b
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x1(%r12), %rcx
addq $0x18, %r15
testl %eax, %eax
jne 0x346b
xorl %eax, %eax
cmpq %r14, %r12
setb %al
jmp 0x349e
xorl %eax, %eax
jmp 0x349e
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_push
static void cache_push(bridge_t *br, uri_t uri)
{
    if(!uri)
        return;
    assert(uri);
    br->cache_len += 1;
    br->cache = realloc(br->cache, br->cache_len*sizeof(param_cache_t));
    param_cache_t *ch = br->cache + (br->cache_len - 1);
    memset(ch, 0, sizeof(param_cache_t));
    ch->path    = strdup(uri);
    cache_update(br, ch);
}

// Assembly:
testq %rsi, %rsi
je 0x379b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x120(%rdi), %rax
incq %rax
movl %eax, 0x120(%rdi)
movq 0x100(%rdi), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0x2240
movq %rax, 0x100(%rbx)
movslq 0x120(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r15
addq $-0x30, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movq $0x0, 0x28(%r15)
movq %r14, %rdi
callq 0x22c0
movq %rax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x379c
retq
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_update
static void cache_update(bridge_t *br, param_cache_t *ch)
{
    double now  = 1e-3*uv_now(br->loop);
    uri_t uri   = ch->path;
    ch->valid   = 0;
    ch->type    = 0;
    ch->usable  = 1;
    ch->pending = 1;
    ch->force_refresh = 0;
    ch->request_time = now;
    ch->requests++;
    memset(&ch->val, 0, sizeof(ch->val));

    if(osc_request_hook) {
        char buffer[128];
        const int len = rtosc_message(buffer, 128, uri, "");
        if(len <= 0)
            fprintf(stderr, "[ERROR] Osc Bridge Could Not Request Update For \"%s\"\n", uri);
    	osc_request_hook(br, buffer);
    } else
        osc_request(br, uri);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2170
movq %rax, %xmm0
punpckldq 0x5849(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5851(%rip), %xmm0     # 0x9020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x584d(%rip), %xmm1     # 0x9030
movq (%r15), %r14
movb 0x8(%r15), %al
movb $0x0, 0x9(%r15)
andb $-0x10, %al
orb $0x6, %al
movb %al, 0x8(%r15)
movsd %xmm1, 0x10(%r15)
incl 0x18(%r15)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%r15)
cmpq $0x0, 0x99fd(%rip)      # 0xd210
je 0x3854
leaq 0x5b90(%rip), %rcx      # 0x93ac
leaq -0xa0(%rbp), %rdi
movl $0x80, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6750
testl %eax, %eax
jle 0x386c
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq *0x99ca(%rip)           # 0xd210
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3a5a
movq 0x9785(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x5afa(%rip), %rsi      # 0x9377
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
jmp 0x3836
// File: /workspace/github_c_makefile_star2_O3/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_damage
void br_damage(bridge_t *br, uri_t dmg)
{
    //printf("Damage of parameters...\n");
    //printf("path is %s\n", dmg);
    for(int i=0; i<br->cache_len; ++i) {
        if(strstr(br->cache[i].path, dmg)) {
            int current = br_has_callback(br, br->cache[i].path);
            if(current) {
                osc_request(br, br->cache[i].path);
                br->cache[i].pending = true;
            } else
                br->cache[i].usable = false;
            br->cache[i].requests = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movl 0x120(%rdi), %ebx
testl %ebx, %ebx
jle 0x3a4b
movq %rdi, %r14
movq 0x100(%rdi), %rdx
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rdx, -0x30(%rbp)
movq (%rdx,%r12), %r15
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x22d0
testq %rax, %rax
je 0x3a15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3435
testl %eax, %eax
je 0x3a1b
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a5a
movq 0x100(%r14), %rax
orb $0x2, 0x8(%rax,%r12)
jmp 0x3a25
movq -0x30(%rbp), %rdx
jmp 0x3a3c
movq -0x30(%rbp), %rax
andb $-0x5, 0x8(%rax,%r12)
movq 0x100(%r14), %rdx
movl $0x0, 0x18(%rdx,%r12)
movl 0x120(%r14), %ebx
incq %r13
movslq %ebx, %rax
addq $0x30, %r12
cmpq %rax, %r13
jl 0x39d3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq