LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/real_trim.c
// Function: add_to_buf
void	add_to_buf(char **buf, int *buf_len, char c)
{
	char	*tmp;
	int		i;
	int		len;

	*buf_len = *buf_len + 1;
	len = *buf_len;
	if ((tmp = (char *)malloc(sizeof(char) * len)) == NULL)
		error("Malloc error");
	i = 0;
	while (i < len - 1)
	{
		tmp[i] = (*buf)[i];
		i++;
	}
	tmp[i] = c;
	if (*buf != NULL)
		free(*buf);
	(*buf) = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4f30
leaq 0x51fb(%rip), %rdi      # 0xa126
callq 0x2580
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4f68
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f37
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4f8c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/real_trim.c
// Function: next_word
int		next_word(char **buf, int *buf_len, char *str, int i)
{
	int		space;

	if (i == 0)
		space = 0;
	else
		space = 1;
	while (str[i] == ' ' || str[i] == '\t')
		i++;
	while (str[i] != '\0' && str[i] != ' ' && str[i] != '\t')
	{
		if (space == 1)
			add_to_buf(buf, buf_len, ' ');
		space = 0;
		add_to_buf(buf, buf_len, str[i]);
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4fc6
movl $0x0, -0x20(%rbp)
jmp 0x4fcd
movl $0x1, -0x20(%rbp)
jmp 0x4fcf
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
je 0x4ffa
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5003
jmp 0x500e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4fcf
jmp 0x5010
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x5051
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x22(%rbp)
je 0x5051
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x505a
jmp 0x50a0
cmpl $0x1, -0x20(%rbp)
jne 0x5072
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x20, %edx
callq 0x4ee0
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0x4ee0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5010
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/real_trim.c
// Function: real_trim
char	*real_trim(char *str)
{
	int		i;
	int		buf_len;
	char	*buf;

	i = 0;
	buf_len = 0;
	buf = NULL;
	if (str == NULL)
		return (NULL);
	while (str[i] != '\0')
		i = next_word(&buf, &buf_len, str, i);
	add_to_buf(&buf, &buf_len, '\0');
	return (buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x50e3
movq $0x0, -0x8(%rbp)
jmp 0x5126
jmp 0x50e5
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x510f
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4fa0
movl %eax, -0x14(%rbp)
jmp 0x50e5
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x4ee0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/set_normal.c
// Function: set_direct
void	set_direct(t_data *data, char *param, char *lbl_name,
		int inst_pos)
{
	int		val;

	if (param[1] == LABEL_CHAR)
	{
		val = label_exist(data, param + 2, lbl_name);
		val = val * addr_diff(data, param + 2, inst_pos);
		add_to_prog(data, ((unsigned char *)(&val))[3]);
		add_to_prog(data, ((unsigned char *)(&val))[2]);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
	else
	{
		val = ft_atoi(param + 1);
		add_to_prog(data, ((unsigned char *)(&val))[3]);
		add_to_prog(data, ((unsigned char *)(&val))[2]);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x51c7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movq -0x18(%rbp), %rdx
callq 0x1b90
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movl -0x1c(%rbp), %edx
callq 0x12c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1d(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x1e(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
jmp 0x520b
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x5e20
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1d(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x1e(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/set_normal.c
// Function: set_indirect
void	set_indirect(t_data *data, char *param, char *lbl_name,
		int inst_pos)
{
	int		val;

	if (param[0] == LABEL_CHAR)
	{
		val = label_exist(data, param + 1, lbl_name);
		val = val * addr_diff(data, param + 1, inst_pos);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
	else
	{
		val = ft_atoi(param);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x529c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0x1b90
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl -0x1c(%rbp), %edx
callq 0x12c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
jmp 0x52c2
movq -0x10(%rbp), %rdi
callq 0x5e20
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/set_special.c
// Function: set_address
void	set_address(t_data *data, char *param, char *lbl_name,
		int inst_pos)
{
	int		val;

	if (param[1] == LABEL_CHAR)
	{
		val = label_exist(data, param + 2, lbl_name);
		val = val * addr_diff(data, param + 2, inst_pos);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
	else
	{
		val = ft_atoi(param + 1);
		add_to_prog(data, ((unsigned char *)(&val))[1]);
		add_to_prog(data, ((unsigned char *)(&val))[0]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x538d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movq -0x18(%rbp), %rdx
callq 0x1b90
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
movl -0x1c(%rbp), %edx
callq 0x12c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
jmp 0x53b7
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x5e20
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x1f(%rbp), %esi
callq 0x4d70
movq -0x8(%rbp), %rdi
movzbl -0x20(%rbp), %esi
callq 0x4d70
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/tools.c
// Function: is_in_str
int		is_in_str(char c, char *str)
{
	int		i;
	int		ret;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x558c
movl $0x0, -0x4(%rbp)
jmp 0x55cd
jmp 0x558e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x55c7
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x55bc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x558e
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/tools.c
// Function: str_is_in_str
int		str_is_in_str(char *search, char *str)
{
	int		i;

	i = 0;
	if (search == NULL)
		return (0);
	if (str == NULL)
		return (0);
	while (str[i] != '\0')
	{
		if (is_in_str(str[i], search) == 0)
			return (1);
		i++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5607
movl $0x0, -0x4(%rbp)
jmp 0x5661
cmpq $0x0, -0x18(%rbp)
jne 0x5617
movl $0x0, -0x4(%rbp)
jmp 0x5661
jmp 0x5619
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x565a
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rsi
movsbl %al, %edi
callq 0x5560
cmpl $0x0, %eax
jne 0x564f
movl $0x1, -0x4(%rbp)
jmp 0x5661
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5619
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/tools.c
// Function: rm_char
char	*rm_char(char *str, char *rem)
{
	char	*ret;
	int		len;
	int		i;
	int		j;

	len = 0;
	i = 0;
	while (str[i] != '\0')
	{
		if (is_in_str(str[i], rem) == 0)
			len++;
		i++;
	}
	if ((ret = (char *)malloc(sizeof(char) * ++len)) == NULL)
		error("Malloc error");
	ft_bzero(ret, len);
	i = 0;
	j = 0;
	while (str[j] != '\0')
	{
		if (is_in_str(str[j], rem) == 0)
			ret[i++] = str[j];
		j++;
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x56cf
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rsi
movsbl %al, %edi
callq 0x5560
cmpl $0x0, %eax
jne 0x56c4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x568e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x56fa
leaq 0x4a31(%rip), %rdi      # 0xa126
callq 0x2580
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x5b20
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x576d
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rsi
movsbl %al, %edi
callq 0x5560
cmpl $0x0, %eax
jne 0x5762
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5715
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/tools.c
// Function: free_strsplit
void	free_strsplit(char **arr)
{
	int		i;

	i = 0;
	while (arr[i] == 0)
	{
		free(arr[i]);
		i++;
	}
	free(arr);
}

// 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
cmpq $0x0, (%rax,%rcx,8)
jne 0x57be
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5793
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/tools.c
// Function: set_ocp
int		set_ocp(int ocp, int index, int val)
{
	if ((val == 0 || val == 1 || val == 2 || val == 3) &&
			(index == 0 || index == 1 || index == 2 || index == 3))
	{
		if (index == 0)
			val = val << 6;
		if (index == 1)
			val = val << 4;
		if (index == 2)
			val = val << 2;
		if (index == 0)
			ocp = ocp & 0x3f;
		if (index == 1)
			ocp = ocp & 0xcf;
		if (index == 2)
			ocp = ocp & 0xf3;
		if (index == 3)
			ocp = ocp & 0xfc;
		ocp = ocp | val;
	}
	return (ocp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x57f9
cmpl $0x1, -0xc(%rbp)
je 0x57f9
cmpl $0x2, -0xc(%rbp)
je 0x57f9
cmpl $0x3, -0xc(%rbp)
jne 0x5889
cmpl $0x0, -0x8(%rbp)
je 0x5811
cmpl $0x1, -0x8(%rbp)
je 0x5811
cmpl $0x2, -0x8(%rbp)
je 0x5811
cmpl $0x3, -0x8(%rbp)
jne 0x5889
cmpl $0x0, -0x8(%rbp)
jne 0x5820
movl -0xc(%rbp), %eax
shll $0x6, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x582f
movl -0xc(%rbp), %eax
shll $0x4, %eax
movl %eax, -0xc(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x583e
movl -0xc(%rbp), %eax
shll $0x2, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x584d
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x4(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x585e
movl -0x4(%rbp), %eax
andl $0xcf, %eax
movl %eax, -0x4(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x586f
movl -0x4(%rbp), %eax
andl $0xf3, %eax
movl %eax, -0x4(%rbp)
cmpl $0x3, -0x8(%rbp)
jne 0x5880
movl -0x4(%rbp), %eax
andl $0xfc, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
orl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/utils.c
// Function: no_comma
char	*no_comma(char *str)
{
	char	**comma_split;
	char	*ret;

	comma_split = ft_strsplit(str, ',');
	ret = ft_strdup(comma_split[0]);
	free_strsplit(comma_split);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5780
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/utils.c
// Function: ft_pass_space_tab
char	*ft_pass_space_tab(char *str)
{
	int	index;

	index = 0;
	while (str[index] != '\0' && (str[index] == ' ' || str[index] == '\t'))
		index++;
	return (str + index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
je 0x5936
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xe(%rbp)
je 0x5930
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0xe(%rbp)
movb -0xe(%rbp), %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x593f
jmp 0x594a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x58ef
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/write_file.c
// Function: write_verbose
void	write_verbose(t_data *data)
{
	if (data->verbose == 0)
		return ;
	ft_printf("\033[31;1m%s :\033[0m\n%s\n", NAME_CMD_STRING, data->name);
	ft_printf("\033[31;1m%s :\033[0m\n%s\n", COMMENT_CMD_STRING, data->comment);
	ft_printf("\033[31;1mSize of cor in bytes : \033[0m%d\n", data->prog_size);
	ft_printf("\033[31;1mProgram in hexadecimal : \033[0m");
	print_prog(data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x5977
jmp 0x59dd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x4bea(%rip), %rdi      # 0xa570
leaq 0x4a66(%rip), %rsi      # 0xa3f3
movb $0x0, %al
callq 0x6ba0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x4bcd(%rip), %rdi      # 0xa570
leaq 0x4a63(%rip), %rsi      # 0xa40d
movb $0x0, %al
callq 0x6ba0
movq -0x8(%rbp), %rax
movl 0x50(%rax), %esi
leaq 0x4bc5(%rip), %rdi      # 0xa584
movb $0x0, %al
callq 0x6ba0
leaq 0x4bdd(%rip), %rdi      # 0xa5aa
movb $0x0, %al
callq 0x6ba0
movq -0x8(%rbp), %rdi
callq 0x4e20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/write_file.c
// Function: write_header
void	write_header(t_data *data)
{
	set_magic_to_cor(data);
	add_str_to_cor(data, data->name, PROG_NAME_LENGTH);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_to_cor(data, ((unsigned char *)(&data->prog_size))[3]);
	add_to_cor(data, ((unsigned char *)(&data->prog_size))[2]);
	add_to_cor(data, ((unsigned char *)(&data->prog_size))[1]);
	add_to_cor(data, ((unsigned char *)(&data->prog_size))[0]);
	add_str_to_cor(data, data->comment, COMMENT_LENGTH);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_to_cor(data, 0);
	add_str_to_cor(data, (char *)data->prog, data->prog_size);
	write_verbose(data);
	if (data->binary)
		return ;
	ft_putstr("Writing output program to ");
	ft_putendl(data->filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl $0x80, %edx
callq 0x2190
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl 0x53(%rax), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl 0x52(%rax), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl 0x51(%rax), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl 0x50(%rax), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movl $0x800, %edx            # imm = 0x800
callq 0x2190
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edx
callq 0x2190
movq -0x8(%rbp), %rdi
callq 0x5960
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x5afa
jmp 0x5b13
leaq 0x4ace(%rip), %rdi      # 0xa5cf
callq 0x64d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6510
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_bzero.c
// Function: ft_bzero
void	ft_bzero(void *s, size_t n)
{
	if (n == 0)
		return ;
	while (n--)
		*(char *)s++ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5b35
jmp 0x5b60
jmp 0x5b37
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5b60
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
jmp 0x5b37
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strlen.c
// Function: ft_strlen
size_t	ft_strlen(const char *s)
{
	size_t l;

	l = 0;
	while (*s++)
		l++;
	return (l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, (%rax)
je 0x5ba2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5b80
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strdup.c
// Function: ft_strdup
char	*ft_strdup(const char *s1)
{
	char	*dst;

	dst = (char *)malloc(sizeof(char) * (ft_strlen(s1) + 1));
	if (dst == NULL)
		return (NULL);
	return (ft_strcpy(dst, s1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b70
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5bea
movq $0x0, -0x8(%rbp)
jmp 0x5bfb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	char	*dst_cp;

	dst_cp = dst;
	while (*src)
		*dst++ = *src++;
	*dst = '\0';
	return (dst_cp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5c51
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x5c24
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	if (s == NULL)
		return (NULL);
	while (*s)
		if (*s++ == (unsigned char)c)
			return ((char *)s - 1);
	return ((unsigned char)c == '\0' ? (char*)s : NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5c7c
movq $0x0, -0x8(%rbp)
jmp 0x5cd8
jmp 0x5c7e
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5cb3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5cb1
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5cd8
jmp 0x5c7e
movl -0x14(%rbp), %eax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5cc8
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5cd0
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x5cd0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	unsigned char	*t1;
	unsigned char	*t2;

	t1 = (unsigned char *)s1;
	t2 = (unsigned char *)s2;
	while (*t1 == *t2)
		if (*t1++ == '\0' || *t2++ == '\0')
			return (0);
	return (*t1 - *t2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5d47
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x5d3c
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5d45
movl $0x0, -0x4(%rbp)
jmp 0x5d5a
jmp 0x5cfc
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	if (s1 == NULL || s2 == NULL || n == 0)
		return (0);
	while (n--)
		if (*(unsigned char *)s1++ != *(unsigned char *)s2++ || *s2 == 0)
			return (*(unsigned char *)--s1 - *(unsigned char *)--s2);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5d85
cmpq $0x0, -0x18(%rbp)
je 0x5d85
cmpq $0x0, -0x20(%rbp)
jne 0x5d91
movl $0x0, -0x4(%rbp)
jmp 0x5e12
jmp 0x5d93
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5e0b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5ddc
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5e09
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl -0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl -0x1(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5e12
jmp 0x5d93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_atoi.c
// Function: ft_atoi
int			ft_atoi(const char *str)
{
	int	value;
	int	is_neg;

	value = 0;
	is_neg = 1;
	while (ft_isignored(*str))
		str++;
	if (*str == '-' || *str == '+')
		is_neg = (*str++ == '+') ? 1 : -1;
	while (ft_isdigit(*str))
		value = value * 10 + (*str++ - '0');
	return (value * is_neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x5ee0
cmpl $0x0, %eax
je 0x5e59
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5e3a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x5e71
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x5e96
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl $0x2b, %edx
cmovel %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x5e98
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x5f50
cmpl $0x0, %eax
je 0x5ec9
imull $0xa, -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e98
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*join;

	if (s1 == NULL && s2 == NULL)
		return (NULL);
	else if (s1 == NULL)
		return (ft_strdup(s2));
	else if (s2 == NULL)
		return (ft_strdup(s1));
	join = (char *)malloc(sizeof(char) * (ft_strlen(s1) + ft_strlen(s2) + 1));
	if (join == NULL)
		return (NULL);
	ft_strcpy(join, s1);
	ft_strcat(join, s2);
	return (join);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5fab
cmpq $0x0, -0x18(%rbp)
jne 0x5fab
movq $0x0, -0x8(%rbp)
jmp 0x603c
cmpq $0x0, -0x10(%rbp)
jne 0x5fc1
movq -0x18(%rbp), %rdi
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x603c
cmpq $0x0, -0x18(%rbp)
jne 0x5fd7
movq -0x10(%rbp), %rdi
callq 0x5bb0
movq %rax, -0x8(%rbp)
jmp 0x603c
jmp 0x5fd9
jmp 0x5fdb
movq -0x10(%rbp), %rdi
callq 0x5b70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x601a
movq $0x0, -0x8(%rbp)
jmp 0x603c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c10
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strtrim.c
// Function: ft_strtrim
char		*ft_strtrim(char const *s)
{
	char	*start;
	char	*end;
	char	*trim;
	size_t	parser;

	if (s == NULL)
		return (NULL);
	start = get_first(s);
	end = get_last(s);
	if (end - start < 0)
		end = start;
	trim = (char *)malloc(sizeof(char) * (end - start + 1));
	if (trim == NULL)
		return (NULL);
	parser = -1;
	while (++parser <= (size_t)(end - start))
		trim[parser] = start[parser];
	trim[end - start + 1] = '\0';
	return (trim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6070
movq $0x0, -0x8(%rbp)
jmp 0x6128
movq -0x10(%rbp), %rdi
callq 0x6140
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x61a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jge 0x60a3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
subq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x60d0
movq $0x0, -0x8(%rbp)
jmp 0x6128
movq $-0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
ja 0x610c
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x60d8
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strtrim.c
// Function: get_last
static char	*get_last(char const *s)
{
	const char	*start;

	start = s;
	while (*s)
		s++;
	while ((*s == ' ' || *s == '\t' || *s == '\n' || *s == '\0') && s != start)
		s--;
	return ((char *)s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x61c7
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x61b0
jmp 0x61c9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x61fe
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x61fe
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x61fe
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x620c
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6215
jmp 0x6223
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x61c9
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char	*str;
	char	**tab;
	int		i;
	int		word;

	if (s == NULL)
		return (NULL);
	str = (char *)s;
	word = ft_count_wrd(str, c);
	if ((tab = (char **)malloc(sizeof(char *) * (word + 1))) == NULL)
		return (NULL);
	i = 0;
	while (word--)
	{
		while (*str == c)
			str++;
		if (*str == '\0')
			break ;
		if ((tab[i++] = ft_strsub(str, 0, ft_szwd(str, c))) == NULL)
			return (NULL);
		while (*str != c && *str != '\0')
			str++;
	}
	tab[i] = 0;
	return (tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6256
movq $0x0, -0x8(%rbp)
jmp 0x6385
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x6390
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6297
movq $0x0, -0x8(%rbp)
jmp 0x6385
movl $0x0, -0x2c(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x30(%rbp)
cmpl $0x0, %eax
je 0x636d
jmp 0x62b4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x62d1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x62b4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x62e2
jmp 0x636d
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x6440
movq -0x38(%rbp), %rdi
movslq %eax, %rdx
xorl %esi, %esi
callq 0x7150
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %edx
movl %edx, %esi
addl $0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %edx, %rdx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x632b
movq $0x0, -0x8(%rbp)
jmp 0x6385
jmp 0x632d
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movsbl -0x11(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x39(%rbp)
je 0x6351
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x635a
jmp 0x6368
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x632d
jmp 0x629e
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_strsplit.c
// Function: ft_count_wrd
static int		ft_count_wrd(char *str, char c)
{
	int count;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x643a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x63d9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x63d9
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x63db
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
je 0x63ff
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6408
jmp 0x6416
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x63db
jmp 0x6418
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6435
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6418
jmp 0x63a5
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/get_next_line.c
// Function: get_next_line
int			get_next_line(int const fd, char **line)
{
	static t_file	*file = NULL;
	t_file			*fil;
	int				s;
	char			*new;

	if (init(&file, &fil, fd) < 0)
		return (-1);
	file = (file == NULL ? fil : file);
	if ((s = reduce(&fil, 1)) != 1)
		return (s);
	s = size_line(fil->text, fil->size_text);
	if ((new = (char *)malloc(sizeof(char) * (s + 1))) == NULL)
		return (-1);
	ft_bzero(new, s + 1);
	ft_strncpy(new, fil->text, s);
	*line = new;
	s = fil->size_text - s - 1;
	if ((new = (char*)malloc(sizeof(char) * (s > 0 ? s : BUFF_SIZE))) == NULL)
		return (-1);
	if (s > 0)
		ft_strncpy(new, &fil->text[fil->size_text - s], s);
	ft_strdel(&(fil->text));
	fil->size_text = s;
	fil->text = new;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edx
leaq 0x7d9f(%rip), %rdi      # 0xe398
leaq -0x18(%rbp), %rsi
callq 0x6780
cmpl $0x0, %eax
jge 0x6613
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
cmpq $0x0, 0x7d7d(%rip)      # 0xe398
jne 0x6627
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x6632
movq 0x7d6a(%rip), %rax      # 0xe398
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x7d5b(%rip)      # 0xe398
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x68f0
movl %eax, -0x1c(%rbp)
cmpl $0x1, %eax
je 0x665e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x676d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x6aa0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x669d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x5b20
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x6fe0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x66ed
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x66f7
movl $0x800, %eax            # imm = 0x800
movl %eax, -0x34(%rbp)
jmp 0x66f7
movl -0x34(%rbp), %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6719
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
cmpl $0x0, -0x1c(%rbp)
jle 0x6743
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
subl -0x1c(%rbp), %eax
cltq
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x6fe0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x7120
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/get_next_line.c
// Function: init
static int	init(t_file **file_sav, t_file **file, int fd)
{
	t_file			*fil;

	*file = *file_sav;
	if (fd < 0 || *file == NULL || (*file != NULL && found_fd(file, fd) == 0))
	{
		if (fd < 0 || (fil = ft_memalloc(sizeof(t_file))) == NULL)
			return (-1);
		if ((fil->text = ft_memalloc(sizeof(char) * BUFF_SIZE)) == NULL)
			return (-1);
		fil->size_text = 0;
		fil->fd = fd;
		fil->next = NULL;
		if (*file != NULL)
			(*file)->next = fil;
		*file = (*file == NULL ? fil : (*file)->next);
	}
	else if (found_fd(file, fd) == 1 && (*file)->text == NULL)
	{
		if (((*file)->text = ft_memalloc(sizeof(char) * BUFF_SIZE)) == NULL)
			return (-1);
		(*file)->size_text = 0;
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x1c(%rbp)
jl 0x67d4
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x67d4
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6887
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6b20
cmpl $0x0, %eax
jne 0x6887
cmpl $0x0, -0x1c(%rbp)
jl 0x67ee
movl $0x20, %edi
callq 0x70b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x67fa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68e1
movl $0x800, %edi            # imm = 0x800
callq 0x70b0
movq -0x28(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x681e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68e1
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6857
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x686b
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x687a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x68da
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6b20
cmpl $0x1, %eax
jne 0x68d8
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x68d8
movl $0x800, %edi            # imm = 0x800
callq 0x70b0
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x68ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x68e1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x10(%rax)
jmp 0x68da
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/get_next_line.c
// Function: size_line
static int	size_line(char *text, int limit)
{
	char *pos;

	if (text != NULL)
	{
		pos = text;
		while (*pos != '\n' && pos - text < limit)
			pos++;
		return (pos - text);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6b0a
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x6ae3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6aec
jmp 0x6afa
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6aba
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x6b11
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/get_next_line.c
// Function: found_fd
static int	found_fd(t_file **file, int fd)
{
	if (*file != NULL)
	{
		while ((*file)->next != NULL && (*file)->fd != fd)
			*file = (*file)->next;
		if ((*file)->fd == fd)
			return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6b92
jmp 0x6b37
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx)
movb %al, -0x15(%rbp)
je 0x6b5c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x6b65
jmp 0x6b79
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6b37
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x6b90
movl $0x1, -0x4(%rbp)
jmp 0x6b99
jmp 0x6b92
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: ft_printf
int			ft_printf(const char *format, ...)
{
	va_list args;
	int		count;
	int		error;

	va_start(args, format);
	error = replace_conversion((char **)&format, args);
	if (error)
		count = -1;
	else
		count = ft_strlen(format);
	ft_putstr_spec((char *)format);
	free((void*)format);
	va_end(args);
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x6bd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x20(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x6c70
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x6c42
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c4e
movq -0x8(%rbp), %rdi
callq 0x5b70
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x73a0
movq -0x8(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: replace_conversion
static int	replace_conversion(char **str, va_list args)
{
	char	*s2;
	char	*old1;
	char	*old2;
	char	*insert;
	int		i;

	*str = ft_strdup(*str);
	i = get_next_precent_position(*str);
	while ((*str)[i] != '\0')
	{
		old1 = *str;
		s2 = &((*str)[i]);
		insert = get_processed_str(s2, args, &i, &s2);
		if (manage_error(insert, str, i))
			return (1);
		old2 = ft_strjoin(*str, insert);
		free(insert);
		*str = ft_strjoin(old2, s2);
		free(old1);
		free(old2);
		i += get_next_precent_position(&((*str)[i]));
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6d90
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x6d75
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x6e40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x6df0
cmpl $0x0, %eax
je 0x6d11
movl $0x1, -0x4(%rbp)
jmp 0x6d7c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x5f80
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5f80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
callq 0x6d90
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x6ca5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: get_next_precent_position
static int	get_next_precent_position(char *str)
{
	int		i;

	i = 0;
	while (str[i] != '\0' && str[i] != '%')
		i++;
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
je 0x6dca
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x25, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x6dd3
jmp 0x6dde
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d9f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)