LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*new_str;
	size_t	i;
	size_t	j;
	size_t	s1_len;
	size_t	s2_len;

	if (!s1 || !s2)
		return (s1 ? ft_strdup(s1) : ft_strdup(s2));
	s1_len = ft_strlen(s1);
	s2_len = ft_strlen(s2);
	if (!(new_str = ft_strnew(s1_len + s2_len)))
		return (NULL);
	i = -1;
	while (++i < s1_len)
		new_str[i] = s1[i];
	j = -1;
	while (++j < s2_len)
		new_str[i++] = s2[j];
	return (new_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
je 0x7833
movq %r14, %rdi
callq 0x7952
movq %rax, %r12
movq %rbx, %rdi
callq 0x7952
movq %rax, %r15
leaq (%rax,%r12), %rdi
callq 0x79ec
testq %rax, %rax
je 0x783d
testq %r12, %r12
je 0x7814
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x7805
testq %r15, %r15
je 0x783f
movq %rax, %rcx
addq %r12, %rcx
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %r15
jne 0x7821
jmp 0x783f
testq %r14, %r14
je 0x784b
movq %r14, %rdi
jmp 0x784e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7ab8
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strjoin.c
// Function: str_3join
char	*str_3join(char const *s1, char const *s2, char const *s3)
{
	char	*new_str;
	size_t	i[3];
	size_t	len[3];

	if (!s1 || !s2 || !s3)
		return (NULL);
	len[0] = ft_strlen(s1);
	len[1] = ft_strlen(s2);
	len[2] = ft_strlen(s3);
	if (!(new_str = ft_strnew(len[0] + len[1] + len[2])))
		return (NULL);
	i[0] = -1;
	i[1] = -1;
	i[2] = -1;
	while (++i[0] < len[0])
		new_str[i[0]] = s1[i[0]];
	while (++i[1] < len[1])
		new_str[i[0]++] = s2[i[1]];
	while (++i[2] < len[2])
		new_str[i[0]++] = s3[i[2]];
	new_str[i[0]] = '\0';
	return (new_str);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
jne 0x78d1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %rbp
callq 0x7952
movq %rax, %r14
movq %r12, %rdi
callq 0x7952
movq %rax, %r13
movq %rbx, %rdi
callq 0x7952
movq %rax, %r15
leaq (%r14,%r13), %rdi
addq %rax, %rdi
callq 0x79ec
testq %rax, %rax
je 0x78d4
testq %r14, %r14
je 0x78d8
xorl %ecx, %ecx
movb (%rbp,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x78c0
jmp 0x78db
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x790e
xorl %r14d, %r14d
testq %r13, %r13
je 0x78f3
movb (%r12), %cl
movb %cl, (%rax,%r14)
incq %r14
incq %r12
decq %r13
jne 0x78e0
testq %r15, %r15
je 0x7909
movb (%rbx), %cl
movb %cl, (%rax,%r14)
incq %r14
incq %rbx
decq %r15
jne 0x78f8
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_intlen
int		ft_intlen(int num)
{
	int		n;

	n = 1;
	while (num /= 10)
		n++;
	return (n);
}

// Assembly:
leal 0x9(%rdi), %ecx
movl $0x1, %eax
cmpl $0x13, %ecx
jb 0x7951
movslq %edi, %rcx
imulq $0x66666667, %rcx, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
leal (%rcx,%rdx), %edi
incl %eax
addl %edx, %ecx
addl $0x9, %ecx
cmpl $0x12, %ecx
ja 0x792d
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *str)
{
	size_t	i;

	i = 0;
	if (str && *str)
		while (str[i])
			i++;
	return (i);
}

// Assembly:
testq %rdi, %rdi
je 0x7972
cmpb $0x0, (%rdi)
je 0x7972
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x7963
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striter
void	ft_striter(char *s, void (*f)(char *))
{
	int		i;

	i = 0;
	if (s && f)
		while (*(s + i))
			f(s + i++);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x79ab
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x79a4
movq %rsi, %rbx
movq %r14, %rdi
callq *%rbx
cmpb $0x0, 0x1(%r14)
leaq 0x1(%r14), %r14
jne 0x7994
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strlen.c
// Function: ft_striteri
void	ft_striteri(char *s, void (*f)(unsigned int, char *))
{
	int		i;

	i = -1;
	if (s && f)
		while (*(s + ++i))
			f(i, s + i);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x79e9
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x79e4
movq %rsi, %rbx
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
movl %r15d, %edi
callq *%rbx
cmpb $0x0, 0x1(%r14,%r15)
leaq 0x1(%r15), %r15
jne 0x79cf
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strcnew
char	*ft_strcnew(size_t len, char c)
{
	char	*new;
	size_t	i;

	if (len)
		if (!(new = (char *)malloc(sizeof(char) * len + 1)))
			return (NULL);
	i = -1;
	while (++i < len)
		new[i] = c;
	new[i] = '\0';
	return (new);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7a44
leaq 0x1(%rbx), %rdi
callq 0x10d0
movq %rax, %r14
testq %rax, %rax
jne 0x7a44
xorl %r14d, %r14d
jmp 0x7a61
testq %rbx, %rbx
je 0x7a5a
movzbl %bpl, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1070
jmp 0x7a5c
xorl %ebx, %ebx
movb $0x0, (%r14,%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char	*new_str;
	size_t	i;

	if (!s)
		return (NULL);
	if (!(new_str = ft_strnew(len)))
		return (NULL);
	i = 0;
	while (i < len && *s)
		new_str[i++] = s[start++];
	return (new_str);
}

// Assembly:
testq %rdi, %rdi
je 0x7aae
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x79ec
testq %rax, %rax
je 0x7ab1
testq %rbx, %rbx
je 0x7ab3
movl %ebp, %ecx
xorl %edx, %edx
cmpb $0x0, (%r14)
je 0x7ab3
leaq (%rcx,%rdx), %rsi
movl %esi, %esi
movb (%r14,%rsi), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rbx
jne 0x7a90
jmp 0x7ab3
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*dup;
	size_t	i;

	if (!s1)
		return (NULL);
	i = ft_strlen(s1) + 1;
	if (!(dup = (char *)malloc(i)))
		return (NULL);
	dup[--i] = '\0';
	while (i-- > 0)
		dup[i] = s1[i];
	return (dup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7af9
movq %rdi, %rbx
callq 0x7952
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x10d0
testq %rax, %rax
je 0x7af9
movb $0x0, (%rax,%r14)
testq %r14, %r14
je 0x7afb
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strnew.c
// Function: ft_strndup
char	*ft_strndup(const char *s, size_t len)
{
	char	*dup;

	if (!s)
		return (NULL);
	if (!(dup = (char *)malloc(len + 1)))
		return (NULL);
	dup[len] = '\0';
	while (len-- > 0)
		dup[len] = s[len];
	return (dup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7b3e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x10d0
testq %rax, %rax
je 0x7b3e
movb $0x0, (%rax,%rbx)
testq %rbx, %rbx
je 0x7b40
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_countwords
int				ft_countwords(char const *str, char c)
{
	int count;
	int	i;

	i = 0;
	count = 0;
	while (str[i])
	{
		while (str[i] == c)
			i++;
		if (str[i] != c && str[i] != '\0')
			count++;
		while (str[i] != c && str[i] != '\0')
			i++;
	}
	return (count);
}

// Assembly:
cmpb $0x0, (%rdi)
je 0x7bbc
pushq %rbx
xorl %r8d, %r8d
movabsq $0x100000000, %rcx      # imm = 0x100000000
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
xorl %eax, %eax
movslq %r8d, %r10
decq %r10
shlq $0x20, %r8
addq %rdx, %r8
movq %r8, %rbx
movq %r10, %r8
movq %rbx, %r9
movb 0x1(%rdi,%r10), %r11b
incq %r10
addq %rcx, %rbx
cmpb %sil, %r11b
je 0x7b77
xorl %r10d, %r10d
testb %r11b, %r11b
setne %r10b
movb 0x1(%rdi,%r8), %r11b
addq %rcx, %r9
incq %r8
cmpb %sil, %r11b
je 0x7bac
testb %r11b, %r11b
jne 0x7b97
addl %r10d, %eax
sarq $0x20, %r9
cmpb $0x0, (%rdi,%r9)
jne 0x7b67
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char	**arr;
	int		i;
	int		j;

	if (!s || !(arr = (char **)malloc(sizeof(*arr) * ft_countwords(s, c) + 1)))
		return (NULL);
	i = -1;
	j = 0;
	while (++i < ft_countwords(s, c))
	{
		while (s[j] == c)
			j++;
		if (!(arr[i] = ft_strsub(s, j, word_len(&s[j], c))))
			arr[i] = NULL;
		j += (int)word_len(&s[j], c);
	}
	arr[i] = 0;
	return (arr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x7d25
movl %esi, %ebp
movq %rdi, %r14
movsbl %bpl, %r15d
movl %r15d, %esi
callq 0x7b48
cltq
leaq 0x1(,%rax,8), %rdi
callq 0x10d0
testq %rax, %rax
je 0x7d25
movq %rax, %rbx
movq %r14, %rdi
movl %r15d, %esi
callq 0x7b48
testl %eax, %eax
jle 0x7d29
movq %rbx, 0x10(%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x18(%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %r14, 0x8(%rsp)
movl %r15d, 0x4(%rsp)
movslq %r12d, %rcx
addq %rcx, %r14
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rsp)
addq %rcx, %rax
xorl %ebx, %ebx
movq %rbx, %rcx
movq %rax, %r15
incq %rbx
incq %rax
cmpb %bpl, (%r14,%rcx)
je 0x7c48
addq %rbx, %r14
movq $-0x1, %rcx
movq %r15, %rsi
movq %rsi, %rax
movb (%r14,%rcx), %dl
incq %rcx
incq %rsi
cmpb %bpl, %dl
je 0x7c67
testb %dl, %dl
je 0x7c92
xorl %edx, %edx
incq %rdx
movb (%rax), %cl
cmpb %bpl, %cl
je 0x7c94
incq %rax
testb %cl, %cl
jne 0x7c7f
jmp 0x7c94
xorl %edx, %edx
decl %r12d
addq %rbx, %r12
movq 0x8(%rsp), %rdi
movl %r12d, %esi
callq 0x7a69
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r13,8)
movq $-0x1, %rcx
movq %r15, %rax
movb (%r14,%rcx), %dl
incq %rcx
incq %r15
cmpb %bpl, %dl
je 0x7cb7
xorl %ecx, %ecx
testb %dl, %dl
je 0x7cec
movq 0x8(%rsp), %r14
movl 0x4(%rsp), %r15d
incq %rcx
movb (%rax), %dl
cmpb %bpl, %dl
je 0x7cf6
incq %rax
testb %dl, %dl
jne 0x7cd9
jmp 0x7cf6
movq 0x8(%rsp), %r14
movl 0x4(%rsp), %r15d
addq 0x20(%rsp), %rcx
leaq (%rbx,%rcx), %r12
decq %r12
incq %r13
movq %r14, %rdi
movl %r15d, %esi
callq 0x7b48
cltq
cmpq %rax, %r13
jl 0x7c33
movslq %r13d, %rax
movq 0x10(%rsp), %rbx
jmp 0x7d2b
xorl %ebx, %ebx
jmp 0x7d33
xorl %eax, %eax
movq $0x0, (%rbx,%rax,8)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_strsplit.c
// Function: ft_strtrim
char			*ft_strtrim(char const *s)
{
	char	*new;
	size_t	start;
	size_t	end;
	size_t	new_len;

	if (!s)
		return (NULL);
	start = 0;
	end = ft_strlen(s) - 1;
	if (!has_whitespace((char *)s, &start, &end))
		return (ft_strdup(s));
	new_len = (start == ft_strlen(s)) ? 0 : ft_strlen(s) - start - \
											(ft_strlen(s) - end);
	if (!(new = ft_strnew(new_len + 1)))
		return (NULL);
	ft_strncpy(new, &s[start], new_len + 1);
	return (new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x7e26
movq %rdi, %rbx
callq 0x7952
movq %rax, %r14
xorl %r13d, %r13d
movabsq $0x100003600, %r15      # imm = 0x100003600
movzbl (%rbx,%r13), %eax
cmpq $0x20, %rax
ja 0x7d85
btq %rax, %r15
jae 0x7d85
incq %r13
jmp 0x7d6f
movq %rbx, %rdi
callq 0x7952
cmpq %rax, %r13
ja 0x7d80
leaq (%rbx,%r13), %r15
movzbl (%rbx,%r13), %eax
leaq -0x1(%r14), %r12
subq %r13, %r14
movl %eax, %ecx
movabsq $0x100003200, %rdx      # imm = 0x100003200
cmpl $0x20, %eax
ja 0x7dc1
btq %rcx, %rdx
jae 0x7dc1
decq %r14
decq %r12
jmp 0x7dae
cmpb $0xa, (%rbx,%r12)
je 0x7db9
testq %r13, %r13
jne 0x7dda
movq %rbx, %rdi
callq 0x7952
cmpq %rax, %r12
jae 0x7e35
movq %rbx, %rdi
callq 0x7952
movl $0x1, %r12d
cmpq %r13, %rax
je 0x7e06
movq %rbx, %rdi
callq 0x7952
movq %rax, %r12
movq %rbx, %rdi
callq 0x7952
subq %rax, %r12
addq %r14, %r12
movq %r12, %rdi
callq 0x79ec
testq %rax, %rax
je 0x7e26
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x7718
jmp 0x7e28
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7ab8
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/finders.c
// Function: get_type_specifier
int		get_type_specifier(char x)
{
	char	*str;
	int		i;

	i = -1;
	str = "%dcspouxfb";
	while (str[++i])
		if (x == str[i])
			return (i + 1);
	str = ".i...OUXFB";
	while (--i >= 0)
		if (x == str[i])
			return (i + 11);
	return (0);
}

// Assembly:
xorl %ecx, %ecx
leaq 0x5a76(%rip), %rdx      # 0xd90c
cmpq $0xa, %rcx
je 0x7eaa
leaq 0x1(%rcx), %rax
cmpb %dil, (%rcx,%rdx)
movq %rax, %rcx
jne 0x7e96
retq
movl $0xa, %edx
movl $0x15, %eax
leaq 0x5a5c(%rip), %rcx      # 0xd917
movl $0xa, %esi
subq $0x1, %rsi
jb 0x7ed4
decl %eax
cmpb %dil, -0x1(%rdx,%rcx)
movq %rsi, %rdx
jne 0x7ec0
jmp 0x7ea9
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: get_pre_float
int			get_pre_float(long double number, int ret)
{
	long double		tmp;

	tmp = number - (int)number;
	tmp = number - tmp;
	ret = (int)tmp;
	return (ret);
}

// Assembly:
fldt 0x8(%rsp)
fnstcw -0x12(%rsp)
movzwl -0x12(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0xe(%rsp)
fldcw -0xe(%rsp)
fistl -0xc(%rsp)
fldcw -0x12(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x8(%rsp)
fld %st(0)
fisubl -0x8(%rsp)
fsubrp %st, %st(1)
fnstcw -0x14(%rsp)
movzwl -0x14(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x10(%rsp)
fldcw -0x10(%rsp)
fistpl -0x4(%rsp)
fldcw -0x14(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: set_flags
void		set_flags(t_flag *fl, char c)
{
	if (c == ' ')
		fl->space = 1;
	else if (c == '#')
		fl->pound = 1;
	else if (c == '+')
		fl->fplus = 1;
	else if (c == '-')
		fl->minus = 1;
	else if (c == '0')
		fl->fzero = 1;
}

// Assembly:
cmpl $0x2a, %esi
jle 0x7f5d
cmpl $0x2b, %esi
je 0x7f6d
cmpl $0x2d, %esi
je 0x7f73
cmpl $0x30, %esi
jne 0x7f7d
addq $0x10, %rdi
jmp 0x7f77
cmpl $0x20, %esi
je 0x7f77
cmpl $0x23, %esi
jne 0x7f7d
addq $0x4, %rdi
jmp 0x7f77
addq $0xc, %rdi
jmp 0x7f77
addq $0x8, %rdi
movl $0x1, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_u_base
char		*num_string_u_base(unsigned long long num, int base)
{
	unsigned long long	tmp;
	int					len;
	char				*str;

	len = 0;
	tmp = num;
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
testq %rdi, %rdi
je 0x7fe2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r15
xorl %r14d, %r14d
movq %rdi, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r15
incq %r14
cmpq %r15, %rcx
movq %rax, %rcx
jae 0x7f94
movq %r14, %rdi
callq 0x79ec
testq %rax, %rax
je 0x7fee
movq %rax, %rcx
movslq %r14d, %rax
leaq (%rcx,%rax), %rsi
decq %rsi
leaq 0x5978(%rip), %rdi      # 0xd940
movq %rbx, %rax
xorl %edx, %edx
divq %r15
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
cmpq %r15, %rbx
movq %rax, %rbx
jae 0x7fc8
jmp 0x7ff0
leaq 0x4dd3(%rip), %rdi      # 0xcdbc
jmp 0x7ab8
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/do_things.c
// Function: num_string_base
char		*num_string_base(long long num, int base)
{
	long long	tmp;
	int			len;
	char		*str;

	len = 0;
	tmp = num;
	if ((tmp + 1) * -1 == 9223372036854775807)
		return ((str = ft_strdup("9223372036854775808")));
	if (tmp == 0)
		return ((str = ft_strdup("0")));
	while (tmp > 0)
	{
		len++;
		tmp /= base;
	}
	if (!(str = ft_strnew(len)))
		return (NULL);
	len--;
	while (num > 0)
	{
		str[len] = g_base[(num % base)];
		num /= base;
		len--;
	}
	return (str);
}

// Assembly:
movq %rdi, %rax
negq %rax
jo 0x800f
jb 0x801b
leaq 0x4db2(%rip), %rdi      # 0xcdbc
jmp 0x7ab8
leaq 0x590c(%rip), %rdi      # 0xd922
jmp 0x7ab8
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
xorl %ebp, %ebp
testq %rdi, %rdi
jle 0x803b
movq %rbx, %rax
incl %ebp
cqto
idivq %r14
testq %rax, %rax
jg 0x802f
movl %ebp, %edi
callq 0x79ec
testq %rax, %rax
je 0x807a
movq %rax, %rcx
testq %rbx, %rbx
jle 0x807c
movslq %ebp, %rax
leaq (%rax,%rcx), %rsi
decq %rsi
leaq 0x58e0(%rip), %rdi      # 0xd940
movq %rbx, %rax
cqto
idivq %r14
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
decq %rsi
movq %rax, %rbx
testq %rax, %rax
jg 0x8060
jmp 0x807c
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_b.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, char *num)
{
	char	*pad_char;

	if ((pad_char = " ") && (len > mod.prcsn || mod.prcsn == -1))
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (mod.fl.space && mod.fl.fzero && !nbyte)
				nbyte += write(1, " ", 1);
			if (mod.fl.pound && !nbyte && num[0] != '0')
				len += 2;
			while (mod.width - len > nbyte)
				nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
	{
		if (mod.fl.pound && !nbyte && num[0] == '\0')
			;
		else if (mod.fl.pound && !nbyte)
			mod.prcsn += 2;
		while (mod.width - mod.prcsn > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	}
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
leaq 0x40(%rsp), %r13
movl 0x18(%r13), %eax
cmpl %edi, %eax
setge %cl
cmpl $-0x1, %eax
setne %dl
testb %dl, %cl
jne 0x86cb
movl %edi, %r15d
movl 0x14(%r13), %ebp
cmpl %edi, %ebp
jle 0x871a
movl 0x10(%r13), %ecx
testl %ecx, %ecx
leaq 0x4763(%rip), %r14      # 0xcdbc
leaq 0x4cfa(%rip), %rdx      # 0xd35a
cmoveq %rdx, %r14
cmpl $-0x1, %eax
cmovneq %rdx, %r14
testl %ebx, %ebx
jne 0x8693
cmpl $0x0, (%r13)
je 0x8693
testl %ecx, %ecx
je 0x8693
leaq 0x4cd9(%rip), %rsi      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
testl %ebx, %ebx
jne 0x86ae
cmpl $0x0, 0x4(%r13)
je 0x86ae
cmpb $0x30, (%r12)
leal 0x2(%r15), %eax
cmovel %r15d, %eax
movl %eax, %r15d
subl %r15d, %ebp
cmpl %ebx, %ebp
jle 0x871a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
jmp 0x86b1
cmpl $0x0, 0x4(%r13)
sete %dl
testl %ebx, %ebx
setne %cl
orb %dl, %cl
jne 0x86ef
cmpb $0x0, (%r12)
sete %dl
orb %dl, %cl
jne 0x86ef
addl $0x2, %eax
movl %eax, 0x18(%r13)
movl 0x14(%r13), %ebp
subl 0x18(%r13), %ebp
cmpl %ebx, %ebp
jle 0x871a
leaq 0x4c58(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebx, %ebp
jg 0x8702
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_c.c
// Function: convert_c
int				convert_c(t_mods modifiers, va_list ap)
{
	unsigned char	c;

	c = va_arg(ap, int);
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(modifiers.width, c));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(modifiers.width, modifiers.fl.fzero, c));
	}
	return ((int)write(1, &c, 1));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x30(%rsp), %rax
movl (%rdi), %edx
cmpq $0x28, %rdx
ja 0x874f
movq %rdx, %rcx
addq 0x10(%rdi), %rcx
addl $0x8, %edx
movl %edx, (%rdi)
jmp 0x875b
movq 0x8(%rdi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb (%rcx), %cl
movb %cl, 0xd(%rsp)
movl 0x14(%rax), %ebp
cmpl $0x1, 0x8(%rax)
jne 0x87af
leaq 0xf(%rsp), %rsi
movb %cl, (%rsi)
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
cmpl %ebx, %ebp
jle 0x8843
leaq 0x4bc8(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebp, %ebx
jl 0x8792
jmp 0x8843
cmpl $0x2, %ebp
jl 0x87e8
cmpl $0x0, 0x10(%rax)
movb %cl, 0xe(%rsp)
je 0x8801
incl %ebp
xorl %r14d, %r14d
leaq 0x45f2(%rip), %rbx      # 0xcdbc
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
addl %eax, %r14d
decl %ebp
cmpl $0x2, %ebp
jg 0x87ca
jmp 0x8829
leaq 0xd(%rsp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
jmp 0x8843
incl %ebp
xorl %r14d, %r14d
leaq 0x4b4d(%rip), %rbx      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
addl %eax, %r14d
decl %ebp
cmpl $0x2, %ebp
jg 0x880d
leaq 0xe(%rsp), %rsi
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
addl %r14d, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_i.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, int neg)
{
	char	*pad_char;

	pad_char = " ";
	if (len > mod.prcsn || mod.prcsn == -1)
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (nbyte == 0)
			{
				if (mod.fl.space && mod.fl.fzero)
					nbyte += write(1, " ", 1);
				while (mod.width - len - neg > nbyte)
					nbyte += (int)write(1, pad_char, 1);
			}
			else
				while (mod.width - len > nbyte)
					nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
		while (mod.width - mod.prcsn - neg > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movl 0x54(%rsp), %r12d
movl 0x58(%rsp), %eax
cmpl %edi, %eax
setl %cl
cmpl $-0x1, %eax
sete %dl
orb %cl, %dl
je 0x8cb0
movl %edi, %r15d
movl %r12d, %r13d
subl %edi, %r13d
jle 0x8cda
leaq 0x40(%rsp), %rcx
movl 0x10(%rcx), %edx
testl %edx, %edx
leaq 0x413d(%rip), %r14      # 0xcdbc
leaq 0x46d4(%rip), %rsi      # 0xd35a
cmoveq %rsi, %r14
cmpl $-0x1, %eax
cmovneq %rsi, %r14
testl %ebx, %ebx
je 0x8ceb
cmpl %ebx, %r13d
jle 0x8cda
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
jmp 0x8c95
addl %ebp, %eax
subl %eax, %r12d
cmpl %ebx, %r12d
jle 0x8cda
leaq 0x4699(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebx, %r12d
jg 0x8cc1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %edx, %edx
setne %al
cmpl $0x0, (%rcx)
setne %cl
andb %al, %cl
xorl %ebx, %ebx
cmpb $0x1, %cl
jne 0x8d18
leaq 0x4654(%rip), %rsi      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
addl %r15d, %ebp
subl %ebp, %r12d
cmpl %ebx, %r12d
jle 0x8cda
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
jmp 0x8d1e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_p.c
// Function: pad_width
static int		pad_width(t_mods mod, int len, int nbyte, int neg)
{
	char	*pad_char;

	pad_char = " ";
	if (len > mod.prcsn || mod.prcsn == -1)
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (nbyte == 0)
			{
				while (mod.width - len - neg > nbyte)
					nbyte += (int)write(1, pad_char, 1);
			}
			else
				while (mod.width - len > nbyte)
					nbyte += (int)write(1, pad_char, 1);
		}
	}
	else
		while (mod.width - mod.prcsn - neg > nbyte)
			nbyte += (int)write(1, pad_char, 1);
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl 0x44(%rsp), %ebp
movl 0x48(%rsp), %eax
cmpl %edi, %eax
setl %cl
cmpl $-0x1, %eax
sete %sil
orb %cl, %sil
je 0x9371
movl %ebp, %r15d
subl %edi, %r15d
jle 0x9398
leaq 0x30(%rsp), %rcx
cmpl $0x0, 0x10(%rcx)
leaq 0x3a7c(%rip), %r14      # 0xcdbc
leaq 0x4013(%rip), %rcx      # 0xd35a
cmoveq %rcx, %r14
cmpl $-0x1, %eax
cmovneq %rcx, %r14
testl %ebx, %ebx
je 0x93a5
cmpl %ebx, %r15d
jle 0x9398
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
jmp 0x9356
addl %edx, %eax
subl %eax, %ebp
cmpl %ebx, %ebp
jle 0x9398
leaq 0x3fda(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebx, %ebp
jg 0x9380
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addl %edi, %edx
subl %edx, %ebp
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0x9398
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebx, %ebp
jg 0x93af
jmp 0x9398
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_s.c
// Function: convert_s
int			convert_s(t_mods modifiers, va_list ap)
{
	char	*s;
	char	*s2;
	int		nbyte;
	int		len;

	s = va_arg(ap, char *);
	!s ? s = "(null)" : 0;
	nbyte = 0;
	if (modifiers.prcsn >= 0 && modifiers.prcsn < (int)ft_strlen(s))
		s2 = ft_strndup(s, modifiers.prcsn);
	else
		s2 = ft_strdup(s);
	if ((len = ft_strlen(s2)) && modifiers.fl.minus == 1)
	{
		if (modifiers.width <= len)
			nbyte += (int)write(1, s2, len);
		else
			nbyte += left_justify(modifiers, s2, len);
		return ((ft_pipewrench("-s", &s2) + nbyte) - 1);
	}
	if (modifiers.width > len)
		nbyte += right_justify(modifiers, s2, len);
	else
		nbyte += (int)write(1, s2, len);
	return ((ft_pipewrench("-s", &s2) + nbyte) - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x40(%rsp), %r15
movl (%rdi), %ecx
cmpq $0x28, %rcx
ja 0x93f3
movq %rcx, %rax
addq 0x10(%rdi), %rax
addl $0x8, %ecx
movl %ecx, (%rdi)
jmp 0x93ff
movq 0x8(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
testq %rax, %rax
leaq 0x4556(%rip), %rbx      # 0xd962
cmovneq %rax, %rbx
movslq 0x18(%r15), %r14
testq %r14, %r14
js 0x9433
movq %rbx, %rdi
callq 0x7952
cmpl %eax, %r14d
jge 0x9433
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b03
jmp 0x943b
movq %rbx, %rdi
callq 0x7ab8
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x7952
movq %rax, %r14
movl 0x14(%r15), %ebp
movq 0x8(%rsp), %rbx
testl %r14d, %r14d
je 0x94a4
cmpl $0x1, 0x8(%r15)
jne 0x94a4
movslq %r14d, %rdx
cmpl %r14d, %ebp
jle 0x94db
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
cmpl %ebx, %ebp
jle 0x9529
leaq 0x3ed3(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebp, %ebx
jl 0x9487
jmp 0x9529
cmpl %r14d, %ebp
jle 0x94d8
cmpl $0x1, 0x10(%r15)
jne 0x94ed
xorl %r12d, %r12d
leaq 0x3902(%rip), %r15      # 0xcdbc
decl %ebp
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1050
addl %eax, %r12d
cmpl %r14d, %ebp
jg 0x94ba
jmp 0x9513
movslq %r14d, %rdx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
jmp 0x9529
xorl %r12d, %r12d
leaq 0x3e63(%rip), %r15      # 0xd35a
decl %ebp
movl $0x1, %edx
movl $0x1, %edi
movq %r15, %rsi
callq 0x1050
addl %eax, %r12d
cmpl %r14d, %ebp
jg 0x94f7
movslq %r14d, %rdx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
movq %rax, %rbx
addl %r12d, %ebx
leaq 0x3879(%rip), %rdi      # 0xcda9
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x6d18
addl %ebx, %eax
decl %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_printf/convert_percent.c
// Function: convert_percent
int				convert_percent(t_mods modifiers)
{
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(modifiers.width, modifiers.fl.fzero));
	}
	return ((int)write(1, "%", 1));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x34(%rsp), %ebp
cmpl $0x1, 0x28(%rsp)
jne 0x9d00
leaq 0x3caa(%rip), %rsi      # 0xd96c
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
cmpl %ebx, %ebp
jle 0x9d99
leaq 0x3677(%rip), %r14      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %r14, %rsi
callq 0x1050
addl %eax, %ebx
cmpl %ebp, %ebx
jl 0x9ce3
jmp 0x9d99
cmpl $0x2, %ebp
jl 0x9d3a
leaq 0x20(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x9d55
incl %ebp
xorl %r14d, %r14d
leaq 0x30a0(%rip), %rbx      # 0xcdbc
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
addl %eax, %r14d
decl %ebp
cmpl $0x2, %ebp
jg 0x9d1c
jmp 0x9d7d
leaq 0x3c2b(%rip), %rsi      # 0xd96c
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
jmp 0x9d99
incl %ebp
xorl %r14d, %r14d
leaq 0x35f9(%rip), %rbx      # 0xd35a
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1050
addl %eax, %r14d
decl %ebp
cmpl $0x2, %ebp
jg 0x9d61
leaq 0x3be8(%rip), %rsi      # 0xd96c
movl $0x1, %edx
movl $0x1, %edi
callq 0x1050
movq %rax, %rbx
addl %r14d, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: ft_padding
int				ft_padding(char *buf, int len, t_mod mod, int nbyte)
{
	char	*pad_char;

	if ((pad_char = " ") && (len > mod.prcsn || mod.prcsn == -1))
	{
		if (mod.width > len)
		{
			mod.fl.fzero && mod.prcsn == -1 ? pad_char = "0" : 0;
			if (!nbyte)
			{
				if (mod.fl.space && mod.fl.fzero)
					add_one_to_buf(&buf, *pad_char, &nbyte);
				while (mod.width - len - mod.neg > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
			else
			{
				while (mod.width - len > nbyte)
					add_one_to_buf(&buf, *pad_char, &nbyte);
			}
		}
	}
	else
		while (mod.width - mod.prcsn - mod.neg > nbyte)
			add_one_to_buf(&buf, *pad_char, &nbyte);
	return (nbyte);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x40(%rsp), %r15
movl 0x14(%r15), %r12d
movl 0x18(%r15), %eax
cmpl %esi, %eax
setl %cl
cmpl $-0x1, %eax
sete %dl
orb %cl, %dl
je 0xa13c
movl %esi, %ebp
movl %r12d, %r13d
subl %esi, %r13d
jle 0xa172
movl 0x10(%r15), %ecx
testl %ecx, %ecx
leaq 0x2cc6(%rip), %rsi      # 0xcdbc
leaq 0x325d(%rip), %rdx      # 0xd35a
cmoveq %rdx, %rsi
cmpl $-0x1, %eax
cmovneq %rdx, %rsi
testl %ebx, %ebx
je 0xa183
cmpl %ebx, %r13d
jle 0xa172
movsbl (%rsi), %ebp
leaq 0x4(%rsp), %r15
movl %ebp, 0x4(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7718
incq %r14
incl %ebx
cmpl %ebx, %r13d
jg 0xa119
movl %r13d, %ebx
jmp 0xa172
addl 0x20(%r15), %eax
subl %eax, %r12d
cmpl %ebx, %r12d
jle 0xa172
leaq 0x4(%rsp), %r15
movl $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7718
incq %r14
incl %ebx
cmpl %ebx, %r12d
jg 0xa14d
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ecx, %ecx
setne %al
cmpl $0x0, (%r15)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xa1ba
movq %rsi, %r13
movsbl (%rsi), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x7718
incq %r14
movl $0x1, %ebx
jmp 0xa1bd
movq %rsi, %r13
addl 0x20(%r15), %ebp
subl %ebp, %r12d
cmpl %ebx, %r12d
jle 0xa172
movsbl (%r13), %ebp
leaq 0x4(%rsp), %r15
movl %ebp, 0x4(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7718
incq %r14
incl %ebx
cmpl %ebx, %r12d
jg 0xa1d3
jmp 0xa16f
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/sprintf_helper.c
// Function: left_jut
void			left_jut(char *buf, char *num, t_mod mod, int nbyte)
{
	int		len;

	if ((len = (int)ft_strlen(num)) && mod.neg == 1)
		ft_strcpy(buf, "-");
	else if (mod.neg == 0)
	{
		if (mod.fl.fplus)
			ft_strcpy(buf, "+");
		else if (mod.fl.space)
			ft_strcpy(buf, "-");
	}
	buf++;
	while (mod.prcsn-- > len)
	{
		ft_strcpy(buf, "0");
		buf++;
	}
	add_to_buf(&buf, num, &nbyte, len);
	while (nbyte < mod.width)
	{
		add_one_to_buf(&buf, ' ', &nbyte);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x50(%rsp), %rbp
movq %rsi, %rdi
callq 0x7952
movq %rax, %r12
testl %r12d, %r12d
setne %cl
movl 0x20(%rbp), %eax
cmpl $0x1, %eax
sete %dl
leaq 0x3725(%rip), %rsi      # 0xd957
testb %dl, %cl
je 0xa240
movq %r14, %rdi
callq 0x76fc
jmp 0xa248
testl %eax, %eax
je 0xa2f0
incq %r14
movl 0x18(%rbp), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x18(%rbp)
cmpl %r12d, %eax
jle 0xa29e
movq %r15, 0x10(%rsp)
movl 0x18(%rbp), %r15d
cmpl %r12d, %r15d
movl %r12d, %eax
cmovll %r15d, %eax
movl %eax, 0x8(%rsp)
incl %r15d
leaq 0x2b42(%rip), %r13      # 0xcdbc
movq %r14, %rdi
movq %r13, %rsi
callq 0x76fc
incq %r14
decl %r15d
cmpl %r12d, %r15d
jg 0xa27a
movl 0x8(%rsp), %eax
decl %eax
movl %eax, 0x18(%rbp)
movq 0x10(%rsp), %r15
movslq %r12d, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x7718
addl %r12d, %ebx
cmpl 0x14(%rbp), %ebx
jge 0xa2e1
addq %r13, %r14
leaq 0xc(%rsp), %r15
movl $0x20, 0xc(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7718
incq %r14
incl %ebx
cmpl 0x14(%rbp), %ebx
jl 0xa2bf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0xc(%rbp)
je 0xa302
leaq 0x365c(%rip), %rsi      # 0xd959
jmp 0xa236
cmpl $0x0, (%rbp)
jne 0xa236
jmp 0xa248
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/c_to_buf.c
// Function: c_to_buf
int				c_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	char	c;
	int		n;

	c = va_arg(ap, int);
	if (modifiers.fl.minus == 1)
	{
		return (left_justify(buf, c, modifiers.width));
	}
	if (modifiers.width > 1)
	{
		return (right_justify(buf, c, modifiers.width, modifiers.fl.fzero));
	}
	n = 0;
	add_one_to_buf(&buf, c, &n);
	return (n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x40(%rsp), %rax
movq %rdi, 0x10(%rsp)
movl (%rsi), %edx
cmpq $0x28, %rdx
ja 0xa33e
movq %rdx, %rcx
addq 0x10(%rsi), %rcx
addl $0x8, %edx
movl %edx, (%rsi)
jmp 0xa34a
movq 0x8(%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsi)
movl (%rcx), %r15d
movl 0x14(%rax), %ebp
cmpl $0x1, 0x8(%rax)
jne 0xa3a5
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
movsbl %r15b, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xa05c
cmpl %ebp, (%rbx)
jge 0xa39c
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0xa05c
cmpl %ebp, 0x4(%rsp)
jl 0xa386
movl 0x4(%rsp), %eax
jmp 0xa433
cmpl $0x2, %ebp
jl 0xa3e2
cmpl $0x0, 0x10(%rax)
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
je 0xa3f8
incl %ebp
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movl $0x30, %esi
movq %r14, %rdx
callq 0xa05c
decl %ebp
cmpl $0x2, %ebp
jg 0xa3c9
jmp 0xa41b
leaq 0x8(%rsp), %rbx
movl $0x0, (%rbx)
movsbl %r15b, %esi
leaq 0x10(%rsp), %rdi
jmp 0xa429
incl %ebp
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0xa05c
decl %ebp
cmpl $0x2, %ebp
jg 0xa404
movsbl %r15b, %esi
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rbx
movq %rbx, %rdx
callq 0xa05c
movl (%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/s_to_buf.c
// Function: s_to_buf
int			s_to_buf(char *buf, t_mod modifiers, va_list ap)
{
	char	*s;
	char	*s2;
	int		len;

	s = va_arg(ap, char *);
	!s ? s = "(null)" : 0;
	if (modifiers.prcsn >= 0 && modifiers.prcsn < (int)ft_strlen(s))
		s2 = ft_strndup(s, modifiers.prcsn);
	else
		s2 = ft_strdup(s);
	if ((len = ft_strlen(s2)) && modifiers.fl.minus == 1)
	{
		if (modifiers.width <= len)
			ft_strcpy(buf, s2);
		else
			left_justify(buf, s2, len, modifiers);
		free(s2);
		return (modifiers.width <= len ? len : modifiers.width);
	}
	if (modifiers.width > len)
		right_justify(buf, s2, len, modifiers);
	else
		ft_strcpy(buf, s2);
	free(s2);
	return (modifiers.width > len ? modifiers.width : len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movl (%rsi), %ecx
cmpq $0x28, %rcx
ja 0xa80c
movq %rcx, %rax
addq 0x10(%rsi), %rax
addl $0x8, %ecx
movl %ecx, (%rsi)
jmp 0xa818
movq 0x8(%rsi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq (%rax), %rax
testq %rax, %rax
leaq 0x313d(%rip), %rbx      # 0xd962
cmovneq %rax, %rbx
movslq 0x18(%r12), %r14
testq %r14, %r14
js 0xa84d
movq %rbx, %rdi
callq 0x7952
cmpl %eax, %r14d
jge 0xa84d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b03
jmp 0xa855
movq %rbx, %rdi
callq 0x7ab8
movq %rax, %rbx
movq %rax, %rdi
callq 0x7952
movq %rax, %r14
movl 0x14(%r12), %ebp
testl %r14d, %r14d
je 0xa8cb
cmpl $0x1, 0x8(%r12)
jne 0xa8cb
cmpl %r14d, %ebp
jle 0xa93d
leaq 0x10(%rsp), %rdi
movq %r15, (%rdi)
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movq %rbx, %rsi
movq %r15, %rdx
movl %r14d, %ecx
callq 0xa08a
cmpl %ebp, (%r15)
jge 0xa948
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0xa05c
cmpl %ebp, 0xc(%rsp)
jl 0xa8b3
jmp 0xa948
cmpl %r14d, %ebp
jle 0xa93d
movl 0x10(%r12), %eax
movq %r15, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movl %ebp, %r13d
cmpl $0x1, %eax
jne 0xa90e
decl %r13d
movq %r15, %rdi
movl $0x30, %esi
movq %r12, %rdx
callq 0xa05c
cmpl %r14d, %r13d
jg 0xa8f4
jmp 0xa926
decl %r13d
movq %r15, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0xa05c
cmpl %r14d, %r13d
jg 0xa90e
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %rbx, %rsi
movl %r14d, %ecx
callq 0xa08a
jmp 0xa948
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76fc
movq %rbx, %rdi
callq 0x1030
cmpl %r14d, %ebp
cmovgl %ebp, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_sprintf/x_to_buf.c
// Function: pos_justify
static void		pos_justify(char *buf, t_mod mod, int len)
{
	int		nbyte;

	nbyte = 0;
	mod.neg = mod.fl.fplus;
	nbyte = ft_padding(buf, len, mod, nbyte);
	if (!mod.fl.fplus && mod.fl.space && !nbyte)
	{
		ft_strcpy(buf, " ");
		buf++;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x4c(%rsp), %eax
movl %eax, 0x60(%rsp)
movl %eax, 0x20(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
xorl %edx, %edx
callq 0xa0af
cmpl $0x0, 0x4c(%rsp)
jne 0xaffc
cmpl $0x0, 0x40(%rsp)
je 0xaffc
testl %eax, %eax
jne 0xaffc
leaq 0x236b(%rip), %rsi      # 0xd35a
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x76fc
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_itoa_base
char	*ft_itoa_base(int n, int base)
{
	int		tmp;
	int		len;
	char	*str;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	n < 0 ? n *= -1 : 0;
	tmp = n;
	len = 1;
	while (tmp /= base)
		len++;
	tmp = n;
	base == 10 ? len += 1 : 0;
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = g_base[(tmp % base)];
		tmp /= base;
	}
	if (n < 0 && base == 10)
		str[0] = '-';
	return (str);
}

// Assembly:
movl %edi, %eax
negl %eax
jno 0xb016
leaq 0x295d(%rip), %rdi      # 0xd96e
jmp 0x7ab8
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
cmovnsl %eax, %ebp
xorl %r14d, %r14d
movl %ebp, %eax
cltd
idivl %ebx
incq %r14
testl %eax, %eax
jne 0xb026
xorl %edi, %edi
cmpl $0xa, %ebx
sete %dil
addq %r14, %rdi
callq 0x79ec
testq %rax, %rax
je 0xb089
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xa, %ebx
sete %al
leaq (%rax,%r14), %rsi
negq %rsi
movq %rcx, %rdi
addq %rax, %rdi
xorl %r8d, %r8d
leaq 0x28d8(%rip), %r9       # 0xd940
movl %ebp, %eax
cltd
idivl %ebx
movslq %edx, %rdx
movb (%rdx,%r9), %dl
leaq (%rdi,%r8), %r10
movb %dl, -0x1(%r14,%r10)
decq %r8
movl %eax, %ebp
cmpq %r8, %rsi
jne 0xb068
jmp 0xb08b
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_uitoa_base
char	*ft_uitoa_base(unsigned int n, int base)
{
	unsigned int	tmp;
	int				len;
	char			*str;

	tmp = n;
	len = 1;
	while (tmp /= base)
		len++;
	tmp = n;
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = g_base[(tmp % base)];
		tmp /= base;
	}
	return (str);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x1, %r14d
cmpl %esi, %edi
jb 0xb0b2
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
incl %r14d
cmpl %ebx, %eax
jae 0xb0a7
movl %r14d, %edi
callq 0x79ec
testq %rax, %rax
je 0xb0e2
movq %rax, %rcx
movslq %r14d, %rsi
leaq 0x2874(%rip), %rdi      # 0xd940
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movb (%rdx,%rdi), %dl
movb %dl, -0x1(%rcx,%rsi)
movl %eax, %ebp
decq %rsi
jne 0xb0cc
jmp 0xb0e4
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/rpeepz[P]ft_ssl/libft/srcs/ft_itoa_base.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	int		tmp;
	int		len;
	char	*str;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	tmp = n;
	len = 0;
	if (n < 0)
	{
		tmp *= -1;
		len = 1;
	}
	len += ft_intlen(n);
	if (!(str = ft_strnew(len)))
		return (NULL);
	while (len--)
	{
		str[len] = tmp % 10 + '0';
		tmp = tmp / 10;
	}
	if (n < 0)
		str[0] = '-';
	return (str);
}

// Assembly:
movl %edi, %eax
negl %eax
jno 0xb0fe
leaq 0x2875(%rip), %rdi      # 0xd96e
jmp 0x7ab8
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movl %edi, %r14d
shrl $0x1f, %r14d
callq 0x7920
movl %eax, %ebp
addl %r14d, %ebp
movslq %ebp, %r14
movq %r14, %rdi
callq 0x79ec
testq %rax, %rax
je 0xb15f
testl %ebp, %ebp
je 0xb156
movl %ebx, %edx
negl %edx
cmovsl %ebx, %edx
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x23, %rsi
leal (%rsi,%rsi), %edi
leal (%rdi,%rdi,4), %edi
subl %edi, %edx
orb $0x30, %dl
movb %dl, -0x1(%rax,%r14)
movl %esi, %edx
decq %r14
jne 0xb135
testl %ebx, %ebx
jns 0xb161
movb $0x2d, (%rax)
jmp 0xb161
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/panux[P]linit/src/linitctl.c
// Function: connectToServer
FILE* connectToServer() {
    char *sp = getenv("LINITSOCK");
    if(sp == NULL) {
        fprintf(stderr, "[FATAL] LINITSOCK not set\n");
        exit(65);
    }
    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if(fd == -1) {
        fprintf(stderr, "[FATAL] Failed to create socket: %s\n", strerror(errno));
        exit(65);
    }
    struct sockaddr_un addr = { .sun_family = AF_UNIX };
    if((strlen(sp) + 1) > sizeof(addr.sun_path)) {
        fprintf(stderr, "[FATAL] Socket path is too long\n");
        exit(65);
    }
    strcpy(addr.sun_path, sp);
    if(connect(fd, (struct sockaddr *) &addr, sizeof(struct sockaddr_un)) == -1) {
        fprintf(stderr, "[FATAL] Failed to connect: %s\n", strerror(errno));
        exit(65);
    }
    FILE* stream = fdopen(fd, "r+");
    if(stream == NULL) {
        fprintf(stderr, "[FATAL] Failed to convert fd to stream\n");
        exit(65);
    }
    return stream;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0xb1a(%rip), %rdi       # 0x2004
callq 0x1030
testq %rax, %rax
je 0x1590
movq %rax, %r14
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1595
movl %eax, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movups %xmm0, 0x5e(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movw $0x1, (%rsp)
movq %r14, %rdi
callq 0x1080
addq $-0x6c, %rax
cmpq $-0x6e, %rax
jbe 0x159a
leaq 0x2(%rsp), %rdi
movq %r14, %rsi
callq 0x1060
movq %rsp, %rsi
movl %ebx, %edi
movl $0x6e, %edx
callq 0x10e0
cmpl $-0x1, %eax
je 0x159f
leaq 0xb12(%rip), %rsi       # 0x208e
movl %ebx, %edi
callq 0x10c0
testq %rax, %rax
je 0x15a4
addq $0x78, %rsp
popq %rbx
popq %r14
retq
callq 0x1200
callq 0x11cd
callq 0x11a8
callq 0x1175
callq 0x1150
// File: /workspace/github_c_makefile_star2_O1/panux[P]linit/src/linitctl.c
// Function: rcvResp
char *rcvResp(FILE* stream) {
    char* buf = NULL;
    size_t n = 0;
    if(getdelim(&buf, &n, '\0', stream) == -1) {
        fprintf(stderr, "[FATAL] Failed to read response\n");
        exit(65);
    }
    return buf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, %rcx
xorl %eax, %eax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorl %edx, %edx
callq 0x1120
cmpq $-0x1, %rax
je 0x15d9
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
callq 0x1225
// File: /workspace/github_c_makefile_star2_O1/panux[P]linit/src/linitctl.c
// Function: cmd_state
void cmd_state(int argc, char **argv, FILE *stream) {
    if(argc != 2) {
        fprintf(stderr, "[FATAL] Missing arguments\n");
        exit(1);
    }
    char pre[] = "state ";
    size_t n = strlen(pre) + strlen(argv[0]) + strlen(argv[1]) + 2;
    char buf[n];
    char *b = buf;
    strcpy(b, pre);
    b += strlen(pre);
    strcpy(b, argv[0]);
    b += strlen(argv[0]);
    *b = ' ';
    b++;
    strcpy(b, argv[1]);
    if(fwrite(buf, n, 1, stream) != 1) {
        fprintf(stderr, "[FATAL] Failed to write command\n");
        exit(65);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x1810
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %r12
movq %r12, %rdi
callq 0x1080
movq %rax, %r13
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x1080
leaq (%rax,%r13), %r14
addq $0x8, %r14
addq %r13, %rax
addq $0x17, %rax
andq $-0x10, %rax
movq %rsp, %rcx
movq %rcx, %r13
subq %rax, %r13
negq %rax
movq %r13, %rsp
movl $0x74617473, (%rcx,%rax) # imm = 0x74617473
movl $0x206574, 0x3(%r13)    # imm = 0x206574
leaq 0x6(%r13), %rdi
movq %r12, %rsi
callq 0x1060
movq %r12, %rdi
callq 0x1080
leaq (%rax,%r13), %rdi
addq $0x7, %rdi
movb $0x20, -0x1(%rdi)
movq %r15, %rsi
callq 0x1060
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x10f0
cmpq $0x1, %rax
jne 0x1815
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12eb
callq 0x1310