LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: manage_error
static int	manage_error(char *insert, char **str, int position)
{
	if (insert == NULL)
	{
		(*str)[position] = '\0';
		free(insert);
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6e2b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x6e32
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_string.c
// Function: get_processed_str
char		*get_processed_str(char *str, va_list args, int *length, char **end)
{
	char			*processed_str;
	long long		argument;
	t_conversion	*conv;

	if (check_escaped(str, length, end))
		return (ft_strdup("%"));
	conv = save_conversion_format(str);
	if (!conv)
		return (NULL);
	if (conv->conversion != 0)
	{
		argument = get_arg(args, conv);
		processed_str = get_converted_string(argument, conv);
		processed_str = process_precision(processed_str, conv);
	}
	else
		processed_str = ft_tostr(*(*end + conv->length - 1));
	processed_str = process_flags(processed_str, conv);
	if (processed_str != NULL && ((**end = '\0') || 1))
	{
		*length += ft_strlen(processed_str);
		*end += conv->length;
	}
	free_conversion_format(conv);
	return (processed_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6f80
cmpl $0x0, %eax
je 0x6e83
leaq 0x3775(%rip), %rdi      # 0xa5ea
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x6f73
movq -0x10(%rbp), %rdi
callq 0x89e0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6ea4
movq $0x0, -0x8(%rbp)
jmp 0x6f73
movq -0x40(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x0, %eax
je 0x6ee6
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x74c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7ea0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x88a0
movq %rax, -0x30(%rbp)
jmp 0x6f03
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rcx
movslq 0x24(%rcx), %rcx
movsbl -0x1(%rax,%rcx), %edi
callq 0x7490
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8320
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6f62
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x6f33
movb $0x1, %al
testb $0x1, %al
jne 0x6f33
jmp 0x6f62
movq -0x30(%rbp), %rdi
callq 0x5b70
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rdi
callq 0x8b30
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_string.c
// Function: check_escaped
static int	check_escaped(char *str, int *length, char **end)
{
	if (str[1] == '%')
	{
		**end = '\0';
		*length += 1;
		*end += 2;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x25, %eax
jne 0x6fc9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6fd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strncpy.c
// Function: ft_strncpy
char	*ft_strncpy(char *dst, const char *src, size_t n)
{
	size_t	i;

	i = -1;
	while (++i < n && src[i] != 0)
		dst[i] = src[i];
	while (i < n)
		dst[i++] = 0;
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $-0x1, -0x20(%rbp)
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0x7024
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x702d
jmp 0x7045
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x6ff8
jmp 0x7047
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x706a
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0x7047
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_memalloc.c
// Function: ft_memalloc
void	*ft_memalloc(size_t size)
{
	char	*ptr;
	size_t	c;

	ptr = (char*)malloc(size);
	if (ptr == NULL)
	{
		ft_putendl("Error : malloc failed. Exiting ...");
		exit(0);
	}
	c = 0;
	while (c < size)
		ptr[c++] = 0;
	return ((void*)ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x70e3
leaq 0x3515(%rip), %rdi      # 0xa5ec
callq 0x6510
xorl %edi, %edi
callq 0x1080
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x710e
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x0, (%rax,%rcx)
jmp 0x70eb
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strsub.c
// Function: ft_strsub
char	*ft_strsub(char const *s, unsigned int start, size_t len)
{
	char	*str;

	if (s == NULL)
		return (NULL);
	str = (char *)malloc(sizeof(char) * len + 1);
	if (str == NULL)
		return (NULL);
	start++;
	while (--start)
		s++;
	while (start < len)
		str[start++] = *s++;
	str[start] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7177
movq $0x0, -0x8(%rbp)
jmp 0x7207
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x719d
movq $0x0, -0x8(%rbp)
jmp 0x7207
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x71c2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x71a6
jmp 0x71c4
movl -0x14(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x71f4
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x71c4
movq -0x28(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_itoa.c
// Function: ft_itoa
char		*ft_itoa(int n)
{
	char	*str;
	int		is_neg;
	int		len;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	len = get_size(n);
	str = (char *)malloc(sizeof(char) * len);
	if (str == NULL)
		return (NULL);
	is_neg = (n < 0) ? 1 : 0;
	n = (n < 0) ? -n : n;
	str[--len] = 0;
	while (len-- > 0)
	{
		str[len] = (n % 10) + '0';
		n /= 10;
	}
	if (is_neg)
		*str = '-';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $-0x80000000, %rax      # imm = 0x80000000
jne 0x724c
leaq 0x33d1(%rip), %rdi      # 0xa60f
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x730d
movl -0xc(%rbp), %edi
callq 0x7320
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x727c
movq $0x0, -0x8(%rbp)
jmp 0x730d
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x729f
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x72a5
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x72f8
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
jmp 0x72bf
cmpl $0x0, -0x1c(%rbp)
je 0x7305
movq -0x18(%rbp), %rax
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_itoa.c
// Function: get_size
static int	get_size(int n)
{
	int c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x7345
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7347
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jle 0x7365
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7347
movl -0x8(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_putstr_spec.c
// Function: ft_putstr_spec
void	ft_putstr_spec(char *s)
{
	char	*p;

	p = s;
	while (*p != '\0')
	{
		if (*p == '\xFF')
		{
			*p = '\0';
			ft_putstr(s);
			ft_putchar('\0');
			s = p + 1;
		}
		p++;
	}
	ft_putstr(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x73fd
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x73ef
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x64d0
xorl %edi, %edi
callq 0x64a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x73b4
movq -0x8(%rbp), %rdi
callq 0x64d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_putstr_spec.c
// Function: ft_putstr_spec_fd
void	ft_putstr_spec_fd(char *s, int fd)
{
	char	*p;

	p = s;
	while (*p != '\0')
	{
		if (*p == '\xFF')
		{
			*p = '\0';
			ft_putstr_fd(s, fd);
			ft_putchar_fd('\0', fd);
			s = p + 1;
		}
		p++;
	}
	ft_putstr_fd(s, fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x7476
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
jne 0x7468
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6540
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x7370
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7427
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/cast.c
// Function: get_arg
long long			get_arg(va_list args, t_conversion *conv)
{
	if (ft_strchr("DOU", conv->conversion) != NULL)
		return ((long long)va_arg(args, long int));
	if (ft_strchr("di", conv->conversion) != NULL)
		return (d_types(args, conv));
	else if (ft_strchr("ouxX", conv->conversion) != NULL)
		return (o_types(args, conv));
	else if (ft_strchr("cCsSp", conv->conversion) != NULL)
		return (c_types(args, conv));
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x313c(%rip), %rdi      # 0xa61b
callq 0x5c60
cmpq $0x0, %rax
je 0x753c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x28, %eax
ja 0x7515
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x30(%rbp)
jmp 0x752c
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x75cf
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x2bbc(%rip), %rdi      # 0xa107
callq 0x5c60
cmpq $0x0, %rax
je 0x7569
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x75e0
movq %rax, -0x8(%rbp)
jmp 0x75cf
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x30ee(%rip), %rdi      # 0xa666
callq 0x5c60
cmpq $0x0, %rax
je 0x7596
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x78f0
movq %rax, -0x8(%rbp)
jmp 0x75cf
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x307a(%rip), %rdi      # 0xa61f
callq 0x5c60
cmpq $0x0, %rax
je 0x75c3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7bf0
movq %rax, -0x8(%rbp)
jmp 0x75cf
jmp 0x75c5
jmp 0x75c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/converter.c
// Function: get_converted_string
char		*get_converted_string(long long arg, t_conversion *conv)
{
	if (ft_strchr("dDioOuUxXp", conv->conversion) != NULL)
		return (convert_decimals(arg, conv));
	else if (ft_strchr("s", conv->conversion) != NULL)
		return (convert_strings(arg, conv));
	else if (ft_strchr("cC", conv->conversion) != NULL)
		return (convert_chars(arg, conv));
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x2766(%rip), %rdi      # 0xa625
callq 0x5c60
cmpq $0x0, %rax
je 0x7edd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7f50
movq %rax, -0x8(%rbp)
jmp 0x7f43
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x21eb(%rip), %rdi      # 0xa0d7
callq 0x5c60
cmpq $0x0, %rax
je 0x7f0a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8050
movq %rax, -0x8(%rbp)
jmp 0x7f43
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x2778(%rip), %rdi      # 0xa691
callq 0x5c60
cmpq $0x0, %rax
je 0x7f37
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x80e0
movq %rax, -0x8(%rbp)
jmp 0x7f43
jmp 0x7f39
jmp 0x7f3b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/converter.c
// Function: convert_decimals
static char	*convert_decimals(long long arg, t_conversion *conv)
{
	char	op;

	op = conv->conversion;
	if (op == 'd' || op == 'i' || op == 'D')
		return (itoa(arg));
	else if (op == 'u' || op == 'U')
		return (itoa_base(arg, "0123456789"));
	else if (op == 'o' || op == 'O')
		return (itoa_base(arg, "01234567"));
	else if (op == 'x' || op == 'p')
		return (itoa_base(arg, "0123456789abcdef"));
	else if (op == 'X')
		return (itoa_base(arg, "0123456789ABCDEF"));
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x20(%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x64, %eax
je 0x7f85
movsbl -0x19(%rbp), %eax
cmpl $0x69, %eax
je 0x7f85
movsbl -0x19(%rbp), %eax
cmpl $0x44, %eax
jne 0x7f97
movq -0x10(%rbp), %rdi
callq 0x8e20
movq %rax, -0x8(%rbp)
jmp 0x803e
movsbl -0x19(%rbp), %eax
cmpl $0x75, %eax
je 0x7fa9
movsbl -0x19(%rbp), %eax
cmpl $0x55, %eax
jne 0x7fbf
movq -0x10(%rbp), %rdi
leaq 0x228f(%rip), %rsi      # 0xa243
callq 0x8f60
movq %rax, -0x8(%rbp)
jmp 0x803e
movsbl -0x19(%rbp), %eax
cmpl $0x6f, %eax
je 0x7fd1
movsbl -0x19(%rbp), %eax
cmpl $0x4f, %eax
jne 0x7fe7
movq -0x10(%rbp), %rdi
leaq 0x2654(%rip), %rsi      # 0xa630
callq 0x8f60
movq %rax, -0x8(%rbp)
jmp 0x803e
movsbl -0x19(%rbp), %eax
cmpl $0x78, %eax
je 0x7ff9
movsbl -0x19(%rbp), %eax
cmpl $0x70, %eax
jne 0x800f
movq -0x10(%rbp), %rdi
leaq 0x2635(%rip), %rsi      # 0xa639
callq 0x8f60
movq %rax, -0x8(%rbp)
jmp 0x803e
movsbl -0x19(%rbp), %eax
cmpl $0x58, %eax
jne 0x802e
movq -0x10(%rbp), %rdi
leaq 0x2627(%rip), %rsi      # 0xa64a
callq 0x8f60
movq %rax, -0x8(%rbp)
jmp 0x803e
jmp 0x8030
jmp 0x8032
jmp 0x8034
jmp 0x8036
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/converter.c
// Function: convert_strings
static char	*convert_strings(long long arg, t_conversion *conv)
{
	char	op;

	op = conv->conversion;
	if (op == 's')
	{
		if ((char *)arg == NULL)
			return (ft_strdup("(null)"));
		if (ft_strchr(conv->modifier, 'l'))
			return (convert_utf_string((wint_t *)arg));
		return (ft_strdup((char *)arg));
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x20(%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x73, %eax
jne 0x80c5
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
jne 0x808f
leaq 0x25d7(%rip), %rdi      # 0xa65b
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x80cd
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x6c, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x80b6
movq -0x10(%rbp), %rdi
callq 0x81a0
movq %rax, -0x8(%rbp)
jmp 0x80cd
movq -0x10(%rbp), %rdi
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x80cd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/converter.c
// Function: convert_chars
static char	*convert_chars(long long arg, t_conversion *conv)
{
	char	*out;
	size_t	length;

	if (arg >= 0x80000000)
		return (NULL);
	if (arg == 0)
		return (ft_strdup("\xFF"));
	length = 1;
	if (ft_strchr(conv->modifier, 'l'))
	{
		length = sizeof(long long);
		arg = convert_utf(arg);
	}
	out = ft_strnew(length + 1);
	ft_memcpy(out, &arg, length);
	ft_strrev(out);
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x80000000, %eax       # imm = 0x80000000
cmpq %rax, -0x10(%rbp)
jl 0x8108
movq $0x0, -0x8(%rbp)
jmp 0x818b
cmpq $0x0, -0x10(%rbp)
jne 0x8121
leaq 0x254c(%rip), %rdi      # 0xa662
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x818b
movq $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x6c, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x8158
movq $0x8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x8270
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x90e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rsi
callq 0x9060
movq -0x20(%rbp), %rdi
callq 0x9150
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/utf.c
// Function: convert_utf_string
char		*convert_utf_string(wint_t *endpoints_list)
{
	char		*out;
	char		*old;
	char		*new;
	long long	utf;

	if (*endpoints_list == '\0')
		return (ft_strdup(""));
	out = NULL;
	while (*endpoints_list != (wint_t)0)
	{
		old = out;
		utf = convert_utf(*endpoints_list);
		new = ft_strnew(sizeof(long long) + 1);
		ft_memcpy(new, &utf, sizeof(long long));
		out = ft_strjoin(old, ft_strrev(new));
		free(old);
		free(new);
		endpoints_list++;
	}
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x81ca
leaq 0x20b9(%rip), %rdi      # 0xa275
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x825e
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8256
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x8270
movq %rax, -0x30(%rbp)
movl $0x9, %edi
callq 0x90e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x9060
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9150
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x81d2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/utf.c
// Function: convert_utf
long long	convert_utf(wint_t arg)
{
	unsigned char		power;
	int					rang;
	unsigned long long	out;

	if (arg <= 0x7F)
		return (arg);
	power = 0x3F;
	rang = 0;
	out = 0;
	while (arg > (wint_t)power)
	{
		out += (long long)((arg & 0x3F) | 0x80) << (rang++ * 8);
		power /= 2;
		arg >>= 6;
	}
	out += (long long)((unsigned char)(~power << 1) | arg) << (rang * 8);
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
ja 0x8289
movl -0xc(%rbp), %eax
movq %rax, -0x8(%rbp)
jmp 0x8315
movb $0x3f, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movzbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jbe 0x82e9
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movl %eax, %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl -0xd(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0xc(%rbp)
jmp 0x829c
movzbl -0xd(%rbp), %eax
xorl $-0x1, %eax
shll %eax
movzbl %al, %eax
orl -0xc(%rbp), %eax
movl %eax, %eax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/flags.c
// Function: process_flags
char		*process_flags(char *str, t_conversion *conv)
{
	char	*out;

	if (str == NULL)
		str = ft_strdup("");
	out = str;
	if (ft_strchr(conv->flags, '+') != NULL
			|| ft_strchr(conv->flags, ' ') != NULL)
		out = sign_wrapper(out, conv);
	if (ft_strchr(conv->flags, '#') != NULL)
		out = hash_wrapper(out, conv);
	if (ft_strchr(conv->flags, '-') != NULL)
		out = minus_wrapper(out, conv);
	else if (ft_strchr(conv->flags, '0') != NULL
			&& (!(ft_strchr("diouxX", conv->conversion) && *(conv->precision))
			|| conv->conversion == 0))
		out = zero_wrapper(out, ft_atoi(conv->width));
	out = space_wrapper(out, ft_atoi(conv->width));
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8347
leaq 0x1f37(%rip), %rdi      # 0xa275
callq 0x5bb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2b, %esi
callq 0x5c60
cmpq $0x0, %rax
jne 0x837d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x838e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8490
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x23, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x83b6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8550
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x83e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8620
movq %rax, -0x18(%rbp)
jmp 0x8455
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x30, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x8453
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x225e(%rip), %rdi      # 0xa664
callq 0x5c60
cmpq $0x0, %rax
je 0x842e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x842e
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x8453
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5e20
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0x86a0
movq %rax, -0x18(%rbp)
jmp 0x8455
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5e20
movq -0x28(%rbp), %rdi
movslq %eax, %rsi
callq 0x8840
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/flags.c
// Function: sign_wrapper
static char	*sign_wrapper(char *str, t_conversion *conv)
{
	char	*out;

	if (ft_strchr("ouxXcsp", conv->conversion) != NULL)
		return (str);
	out = str;
	if (*str != '-')
	{
		if (ft_strchr(conv->flags, '+') != NULL)
			out = ft_strjoin("+", str);
		else if (ft_strchr(conv->flags, ' ') != NULL)
			out = ft_strjoin(" ", str);
		free(str);
	}
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x21bc(%rip), %rdi      # 0xa66b
callq 0x5c60
cmpq $0x0, %rax
je 0x84c4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8543
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x853b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2b, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x8505
movq -0x10(%rbp), %rsi
leaq 0x2179(%rip), %rdi      # 0xa673
callq 0x5f80
movq %rax, -0x20(%rbp)
jmp 0x8532
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x8530
movq -0x10(%rbp), %rsi
leaq 0x1ae4(%rip), %rdi      # 0xa00b
callq 0x5f80
movq %rax, -0x20(%rbp)
jmp 0x8532
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/flags.c
// Function: hash_wrapper
static char	*hash_wrapper(char *str, t_conversion *conv)
{
	char	*out;

	out = str;
	if (conv->conversion == 'o' && *out != '0')
	{
		out = ft_strjoin("0", str);
		free(str);
	}
	else if ((conv->conversion == 'x')
			|| conv->conversion == 'p')
	{
		out = ft_strjoin("0x", str);
		free(str);
	}
	else if (conv->conversion == 'X' && ft_atoi(str))
	{
		out = ft_strjoin("0X", str);
		free(str);
	}
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x6f, %eax
jne 0x85a0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x85a0
movq -0x8(%rbp), %rsi
leaq 0x20e9(%rip), %rdi      # 0xa675
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
jmp 0x8615
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x78, %eax
je 0x85ba
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x70, %eax
jne 0x85d9
movq -0x8(%rbp), %rsi
leaq 0x20b2(%rip), %rdi      # 0xa677
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
jmp 0x8613
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x58, %eax
jne 0x8611
movq -0x8(%rbp), %rdi
callq 0x5e20
cmpl $0x0, %eax
je 0x8611
movq -0x8(%rbp), %rsi
leaq 0x207b(%rip), %rdi      # 0xa67a
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
jmp 0x8613
jmp 0x8615
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/flags.c
// Function: minus_wrapper
static char	*minus_wrapper(char *str, t_conversion *conv)
{
	size_t	length;
	char	*out;
	char	*old;

	out = str;
	length = ft_atoi(conv->width);
	if (length > 0)
		while (ft_strlen(out) < length)
		{
			old = out;
			out = ft_strjoin(old, " ");
			free(old);
		}
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5e20
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x868c
jmp 0x8654
movq -0x20(%rbp), %rdi
callq 0x5b70
cmpq -0x18(%rbp), %rax
jae 0x868a
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1995(%rip), %rsi      # 0xa00b
callq 0x5f80
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x8654
jmp 0x868c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/wrapper.c
// Function: zero_wrapper
char		*zero_wrapper(char *str, size_t length)
{
	char	*out;
	char	*old;
	char	*left_part;

	left_part = get_left_part(str);
	out = ft_strdup(str + ft_strlen(left_part));
	free(str);
	while (ft_strlen(out) + ft_strlen(left_part) < length)
	{
		old = out;
		out = ft_strjoin("0", old);
		free(old);
	}
	old = out;
	out = ft_strjoin(left_part, old);
	free(old);
	free(left_part);
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8770
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5b70
movq -0x30(%rbp), %rdi
addq %rax, %rdi
callq 0x5bb0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x5b70
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5b70
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x8734
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x1f55(%rip), %rdi      # 0xa675
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x86e7
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/wrapper.c
// Function: get_left_part
static char	*get_left_part(char *str)
{
	char	*left_part;
	int		i;

	left_part = ft_strdup(str);
	i = 0;
	while (str[i] == '0' || str[i] == 'x' || str[i] == 'X'
			|| str[i] == '+' || str[i] == '-' || str[i] == ' ')
		i++;
	left_part[i] = '\0';
	return (left_part);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5bb0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0x15(%rbp)
je 0x8813
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x78, %ecx
movb %al, -0x15(%rbp)
je 0x8813
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x58, %ecx
movb %al, -0x15(%rbp)
je 0x8813
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0x15(%rbp)
je 0x8813
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x15(%rbp)
je 0x8813
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x881c
jmp 0x882a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8790
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/wrapper.c
// Function: space_wrapper
char		*space_wrapper(char *str, size_t length)
{
	char	*out;
	char	*old;

	out = str;
	while (ft_strlen(out) < length)
	{
		old = out;
		out = ft_strjoin(" ", old);
		free(old);
	}
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
cmpq -0x10(%rbp), %rax
jae 0x888e
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x1791(%rip), %rdi      # 0xa00b
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x8858
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/precision.c
// Function: process_precision
char		*process_precision(char *str, t_conversion *conv)
{
	char	*out;
	char	*old;
	size_t	precision;

	out = str;
	if (*(conv->precision++) == '.')
	{
		precision = ft_atoi(conv->precision);
		if (ft_strchr("diouxXp", conv->conversion)
			&& ft_atoi(str) == 0 && precision == 0)
			*str = '\0';
		else if (ft_strchr("diouxXp", conv->conversion) != NULL)
			out = zero_wrapper(out, precision + (ft_strchr(str, '-') != NULL));
		else if (conv->conversion == 's')
		{
			old = out;
			out = ft_strsub(out, 0, precision);
			free(old);
		}
	}
	conv->precision--;
	return (out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rcx)
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x89b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5e20
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x1d84(%rip), %rdi      # 0xa67d
callq 0x5c60
cmpq $0x0, %rax
je 0x8925
movq -0x8(%rbp), %rdi
callq 0x5e20
cmpl $0x0, %eax
jne 0x8925
cmpq $0x0, -0x28(%rbp)
jne 0x8925
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x89b6
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %esi
leaq 0x1d49(%rip), %rdi      # 0xa67d
callq 0x5c60
cmpq $0x0, %rax
je 0x8981
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x5c60
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rsi
callq 0x86a0
movq %rax, -0x18(%rbp)
jmp 0x89b4
movq -0x10(%rbp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x73, %eax
jne 0x89b2
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %esi, %esi
callq 0x7150
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x89b4
jmp 0x89b6
jmp 0x89b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/read_conversion.c
// Function: save_conversion_format
t_conversion	*save_conversion_format(char *str)
{
	t_conversion	*conv;
	int				i;

	i = 1;
	if (!(conv = (t_conversion*)malloc(sizeof(t_conversion))))
		return (NULL);
	conv->conversion = 0;
	conv->flags = get_flags(&str[i]);
	i += ft_strlen(conv->flags);
	conv->width = get_width(&str[i]);
	i += ft_strlen(conv->width);
	conv->precision = get_precision(&str[i]);
	i += ft_strlen(conv->precision);
	conv->modifier = get_modifier(&str[i]);
	i += ft_strlen(conv->modifier);
	conv->conversion = get_conversion(&str[i]);
	conv->length = ++i;
	return (resolve_alias(conv));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x28, %edi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x8a14
movq $0x0, -0x8(%rbp)
jmp 0x8b24
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x8b80
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x8c30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x8ca0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x8d30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
callq 0x8dd0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x20(%rax)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rdi
callq 0x91e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/read_conversion.c
// Function: free_conversion_format
void			free_conversion_format(t_conversion *conv)
{
	free(conv->flags);
	free(conv->width);
	free(conv->precision);
	free(conv->modifier);
	free(conv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_conversion_parts.c
// Function: get_flags
char			*get_flags(char *str)
{
	int		i;

	i = 0;
	while (str[i] == '#' || str[i] == '0' || str[i] == '-' || str[i] == '+'
			|| str[i] == ' ')
		i++;
	return (ft_strsub(str, 0, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x23, %ecx
movb %al, -0xd(%rbp)
je 0x8c00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x30, %ecx
movb %al, -0xd(%rbp)
je 0x8c00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0xd(%rbp)
je 0x8c00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0xd(%rbp)
je 0x8c00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x8c09
jmp 0x8c17
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8b93
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x7150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_conversion_parts.c
// Function: get_width
char			*get_width(char *str)
{
	int		i;

	i = 0;
	while (str[i] >= '0' && str[i] <= '9')
		i++;
	return (ft_strsub(str, 0, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0xd(%rbp)
jl 0x8c6e
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x8c77
jmp 0x8c82
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8c43
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x7150
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_conversion_parts.c
// Function: get_precision
char			*get_precision(char *str)
{
	int		i;

	i = 0;
	if (*str == '.')
		i++;
	while (i > 0 && str[i] >= '0' && str[i] <= '9')
		i++;
	return (ft_strsub(str, 0, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x8cc8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8cca
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xd(%rbp)
jle 0x8d00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0xd(%rbp)
jl 0x8d00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x8d09
jmp 0x8d14
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8cca
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x7150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_conversion_parts.c
// Function: get_modifier
char			*get_modifier(char *str)
{
	int		i;

	i = 0;
	if ((*str == 'h' && *(str + 1) == 'h')
			|| (*str == 'l' && *(str + 1) == 'l'))
		i = 2;
	else if (*str == 'h' || *str == 'l' || *str == 'j' || *str == 'z')
		i = 1;
	return (ft_strsub(str, 0, i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
jne 0x8d5c
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x68, %eax
je 0x8d75
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0x8d7e
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6c, %eax
jne 0x8d7e
movl $0x2, -0xc(%rbp)
jmp 0x8db7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x68, %eax
je 0x8dae
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x8dae
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6a, %eax
je 0x8dae
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jne 0x8db5
movl $0x1, -0xc(%rbp)
jmp 0x8db7
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x7150
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/get_conversion_parts.c
// Function: get_conversion
char			get_conversion(char *str)
{
	char	*conversion_chars;

	conversion_chars = "sSpdDioOuUxXcC";
	if (ft_strchr(conversion_chars, *str) != NULL)
		return (*str);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x18a2(%rip), %rax      # 0xa685
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
callq 0x5c60
cmpq $0x0, %rax
je 0x8e08
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x8e0c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/itoa.c
// Function: itoa
char		*itoa(long long n)
{
	char	*str;
	int		is_neg;
	int		len;

	len = get_size(n);
	str = (char *)malloc(sizeof(char) * len);
	if (str == NULL)
		return (NULL);
	is_neg = (n < 0) ? 1 : 0;
	str[--len] = 0;
	while (len-- > 0)
	{
		str[len] = (n % 10) * (n < 0 ? -1 : 1) + '0';
		n /= 10;
	}
	if (is_neg)
		*str = '-';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f10
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8e5d
movq $0x0, -0x8(%rbp)
jmp 0x8efd
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovll %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x8ee8
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rdx, %rax
movq -0x10(%rbp), %rsi
movl $0x1, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq $0x0, %rsi
cmovll %edx, %ecx
movslq %ecx, %rcx
imulq %rcx, %rax
addq $0x30, %rax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
jmp 0x8e86
cmpl $0x0, -0x1c(%rbp)
je 0x8ef5
movq -0x18(%rbp), %rax
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/itoa.c
// Function: get_size
static int	get_size(long long n)
{
	int		c;

	c = 1;
	if (n < 0)
		c++;
	while ((n /= 10) != 0)
		c++;
	return (c + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x8f2f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f31
movq -0x8(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x8f54
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8f31
movl -0xc(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/itoa_base.c
// Function: itoa_base
char		*itoa_base(unsigned long long n, char *charset)
{
	char	*str;
	int		base;
	int		len;

	base = ft_strlen(charset);
	len = get_size(n, base);
	str = (char *)malloc(sizeof(char) * len);
	if (str == NULL)
		return (NULL);
	str[--len] = 0;
	while (len-- > 0)
	{
		str[len] = charset[n % base];
		n /= base;
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9020
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8fad
movq $0x0, -0x8(%rbp)
jmp 0x9013
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
jle 0x900b
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
xorl %edx, %edx
divq %rcx
movq -0x30(%rbp), %rax
movb (%rax,%rdx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x24(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
jmp 0x8fc1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/itoa_base.c
// Function: get_size
static int	get_size(unsigned long long n, int base)
{
	int		c;

	c = 1;
	while ((n /= base) > 0)
		c++;
	return (c + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jbe 0x9054
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9032
movl -0x10(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopl (%rax)