LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt.c
// Function: nm_cmt
int				nm_cmt(t_data *data, char **s, char **arr, int index)
{
	unsigned int	len;

	len = name_comment_len(index);
	if (arr[1] != 0 && (arr[2] == 0 ||
			(arr[2] + ft_strlen(arr[2])) == ft_pass_space_tab(arr[2])))
	{
		if (*s != NULL && index == 1)
			error_line(data, ERR_ALRD_SET_NAME);
		else if (*s != NULL)
			error_line(data, ERR_ALRD_SET_COMMENT);
		if (ft_strlen(arr[1]) > len && index == 1)
			error_limit(data, ERR_LENGTH_NAME, NULL, len);
		else if (ft_strlen(arr[1]) > len)
			error_limit(data, ERR_LENGTH_COM, NULL, len);
		init_nm_cmt(s, len);
		ft_strcpy(*s, arr[1]);
	}
	else if (arr[1] == 0)
		init_nm_cmt(s, len);
	else if (index == 1)
		error_line(data, ERR_LFT_QUOTE_NAME);
	else
		error_line(data, ERR_LFT_QUOTE_COMMENT);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl %ecx, %edi
callq 0x35ad
movl %eax, %ebp
cmpq $0x0, 0x8(%r14)
je 0x3136
movq 0x10(%r14), %r13
testq %r13, %r13
je 0x314c
movq %r13, %rdi
callq 0x4104
movl %ebp, 0x4(%rsp)
movq %rbx, %rbp
movq %r15, %rbx
movq %rax, %r15
addq %r13, %r15
movq 0x10(%r14), %rdi
callq 0x3f8f
cmpq %rax, %r15
movq %rbx, %r15
movq %rbp, %rbx
movl 0x4(%rsp), %ebp
je 0x314c
cmpq $0x0, 0x8(%r14)
je 0x3193
cmpl $0x1, %r12d
jne 0x319f
leaq 0x3295(%rip), %rsi      # 0x63df
jmp 0x31a6
cmpq $0x0, (%rbx)
je 0x3170
cmpl $0x1, %r12d
leaq 0x3204(%rip), %rax      # 0x6361
leaq 0x3212(%rip), %rsi      # 0x6376
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x1ee2
movq %r15, %r13
movq 0x8(%r14), %rdi
callq 0x4104
movl %ebp, %r15d
cmpl $0x1, %r12d
jne 0x31b0
cmpq %r15, %rax
jbe 0x31b0
leaq 0x31fd(%rip), %rsi      # 0x638e
jmp 0x31c5
movq %rbx, %rdi
movl %ebp, %esi
callq 0x309c
jmp 0x31e7
leaq 0x3253(%rip), %rsi      # 0x63f9
movq %r15, %rdi
callq 0x1ee2
jmp 0x31e7
movq 0x8(%r14), %rdi
callq 0x4104
cmpq %r15, %rax
jbe 0x31d1
leaq 0x31f0(%rip), %rsi      # 0x63b5
movq %r13, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x1fb4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x309c
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x4148
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt.c
// Function: parse_nm_cmt_init
unsigned int	parse_nm_cmt_init(int *ret, int index, char **cmd, char **str)
{
	*ret = 0;
	*cmd = name_comment(index);
	*str = ft_pass_space_tab(*str);
	return (name_comment_len(index));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl $0x0, (%rdi)
movl %esi, %edi
callq 0x3597
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x3f8f
movq %rax, (%rbx)
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x35ad
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt.c
// Function: parse_nm_cmt
int				parse_nm_cmt(t_data *data, char **s, char *str, int index)
{
	int				ret;
	int				cont;
	unsigned int	len;
	char			**arr;
	char			*cmd;

	len = parse_nm_cmt_init(&ret, index, &cmd, &str);
	if (ft_strncmp(str, cmd, ft_strlen(cmd)) == 0 &&
			*ft_pass_space_tab(str + ft_strlen(cmd)) == '"')
	{
		cont = check_quote_nm_cmt(data, str, cmd);
		arr = ft_strsplit(str, '"');
		ret = nm_cmt(data, s, arr, index);
		if (cont == 1 && arr[1] != 0)
			add_nm_cmt(data, s, len - ft_strlen(arr[1]), index);
		else if (cont == 1)
			add_nm_cmt(data, s, len, index);
		free_strsplit(arr);
	}
	else if (ft_strncmp(str, cmd, ft_strlen(cmd)) == 0 &&
			*ft_pass_space_tab(str + ft_strlen(cmd)) != '"')
		error_str(data, "character between '\"' and ", cmd);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl %ecx, %edi
callq 0x3597
movq %rax, %r15
movq %r12, %rdi
callq 0x3f8f
movq %rax, %r13
movl %ebp, %edi
callq 0x35ad
movl %eax, %r12d
movq %r15, %rdi
callq 0x4104
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x41c0
testl %eax, %eax
jne 0x32fb
movq %r15, %rdi
callq 0x4104
leaq (%rax,%r13), %rdi
callq 0x3f8f
cmpb $0x22, (%rax)
jne 0x32fb
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x3060
movl %eax, 0x4(%rsp)
movq %r13, %rdi
movl $0x22, %esi
callq 0x43e8
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x30d6
cmpl $0x1, 0x4(%rsp)
jne 0x32ec
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x32dc
callq 0x4104
subl %eax, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x34f8
movq %r15, %rdi
callq 0x3efd
movl $0x1, %ebp
jmp 0x3341
movq %r15, %rdi
callq 0x4104
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x41c0
xorl %ebp, %ebp
testl %eax, %eax
jne 0x3341
movq %r15, %rdi
callq 0x4104
addq %rax, %r13
movq %r13, %rdi
callq 0x3f8f
cmpb $0x22, (%rax)
je 0x3341
leaq 0x30e0(%rip), %rsi      # 0x6416
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f4d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt_2.c
// Function: add_newline_nm_cmt
int		add_newline_nm_cmt(char **s, char *add, unsigned int len)
{
	char	*join;
	char	*jointmp;

	if (ft_strlen(add) + 1 > len)
		return (-1);
	jointmp = ft_strjoin(*s, "\n");
	if (ft_strlen(add) != 0)
	{
		join = ft_strjoin(jointmp, add);
		ft_strcpy(*s, join);
		free(join);
	}
	else
	{
		ft_strcpy(*s, jointmp);
	}
	free(jointmp);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4104
movq %rax, %rcx
incq %rcx
movl %ebp, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
ja 0x33d7
movq (%rbx), %rdi
leaq 0x2d65(%rip), %rsi      # 0x60ec
callq 0x4298
movq %rax, %r14
movq %r15, %rdi
callq 0x4104
testq %rax, %rax
je 0x33bf
movq %r14, %rdi
movq %r15, %rsi
callq 0x4298
movq %rax, %r15
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x4148
movq %r15, %rdi
callq 0x1030
jmp 0x33ca
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4148
movq %r14, %rdi
callq 0x1030
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt_2.c
// Function: check_nm_cmt
int		check_nm_cmt(t_data *data, char **s, int ind_len[], char *str)
{
	char	**arr;
	int		tmp;
	int		ret;

	tmp = is_in_str('"', str);
	if ((ret = 0) == 0 && tmp == 1)
	{
		arr = ft_strsplit(str, '"');
		if (arr[0] != 0 && (arr[1] == 0 ||
					(arr[1] + ft_strlen(arr[1])) == ft_pass_space_tab(arr[1])))
			ret = add_newline_nm_cmt(s, arr[0], ind_len[1]);
		else if (arr[0] == 0)
			ret = add_newline_nm_cmt(s, "", ind_len[1]);
		free_strsplit(arr);
		if (ret == -1)
			return (-1);
	}
	if (tmp == 0)
	{
		ret = add_newline_nm_cmt(s, str, ind_len[1]);
		if (ret == -1)
			return (-1);
		add_nm_cmt(data, s, ind_len[1] - (ft_strlen(str) + 1), ind_len[0]);
	}
	return (tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl $0x22, %edi
movq %rcx, %rsi
callq 0x3d7c
movl %eax, %ebx
testl %eax, %eax
je 0x34a9
cmpl $0x1, %ebx
jne 0x34e7
movq %r15, 0x10(%rsp)
movq %r13, %rdi
movl $0x22, %esi
callq 0x43e8
movq %rax, %rbp
cmpq $0x0, (%rax)
je 0x3466
movq 0x8(%rbp), %r15
testq %r15, %r15
je 0x347e
movq %r15, %rdi
callq 0x4104
movq %r14, 0x8(%rsp)
movq %rax, %r14
addq %r15, %r14
movq 0x8(%rbp), %rdi
callq 0x3f8f
cmpq %rax, %r14
movq 0x8(%rsp), %r14
je 0x347e
xorl %r15d, %r15d
cmpq $0x0, (%rbp)
jne 0x3492
movl 0x4(%r12), %edx
leaq 0x2df9(%rip), %rsi      # 0x6275
jmp 0x3487
movq (%rbp), %rsi
movl 0x4(%r12), %edx
movq %r14, %rdi
callq 0x3354
movl %eax, %r15d
movq %rbp, %rdi
callq 0x3efd
cmpl $-0x1, %r15d
je 0x34e2
testl %ebx, %ebx
movq 0x10(%rsp), %r15
jne 0x34e7
movl 0x4(%r12), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3354
cmpl $-0x1, %eax
je 0x34e2
movl 0x4(%r12), %ebp
movq %r13, %rdi
callq 0x4104
notl %eax
addl %eax, %ebp
movl (%r12), %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x34f8
jmp 0x34e7
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/nm_cmt_2.c
// Function: add_nm_cmt
void	add_nm_cmt(t_data *data, char **s, int len, int index)
{
	char	*str;
	int		ret;
	int		tmp[2];

	str = NULL;
	ret = 0;
	tmp[0] = index;
	tmp[1] = len;
	if (get_next_line(data->fd, &str) >= 0)
	{
		data->line++;
		ret = check_nm_cmt(data, s, tmp, str);
		if (ret == -1 && index == 1)
			error_line(data, ERR_TOO_LRG_NAME);
		else if (ret == -1)
			error_line(data, ERR_TOO_LRG_COM);
		if (ret >= 2 && index == 1)
			error_line(data, ERR_TOO_MNY_NAME);
		else if (ret >= 2)
			error_line(data, ERR_TOO_MNY_COMMENT);
		free(str);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x0, (%rsi)
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movl 0x8(%rdi), %edi
callq 0x45ac
testl %eax, %eax
js 0x358e
incl 0x40(%rbx)
movq (%rsp), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33e2
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x3562
cmpl $0x1, %ebp
leaq 0x2e3f(%rip), %rax      # 0x638e
leaq 0x2e5f(%rip), %rsi      # 0x63b5
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x1ee2
cmpl $0x2, %r14d
jl 0x3585
cmpl $0x1, %ebp
leaq 0x2ebf(%rip), %rax      # 0x6431
leaq 0x2ecc(%rip), %rsi      # 0x6445
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x1ee2
movq (%rsp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/opcode_check.c
// Function: check_opcode
int		check_opcode(char *str, t_instruc *inst)
{
	int		i;

	i = 0;
	while (g_op[i].name != 0)
	{
		if (ft_strcmp(str, g_op[i].name) == 0)
		{
			inst->opcode = g_op[i].op_code;
			return (1);
		}
		i++;
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x6a5a(%rip), %r12      # 0xa070
movq (%r12), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x365d
movq %rdi, %r15
callq 0x4198
testl %eax, %eax
je 0x364e
leaq 0x6a3c(%rip), %r12      # 0xa070
movq 0x30(%r12), %rsi
testq %rsi, %rsi
je 0x365d
movq %r15, %rdi
callq 0x4198
addq $0x30, %r12
testl %eax, %eax
jne 0x3634
movsbl 0x18(%r12), %eax
movl %eax, 0x10(%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/parser.c
// Function: is_comment
int		is_comment(char *str)
{
	int		ret;

	str = rm_char(str, " \t");
	ret = 0;
	if (ft_strcmp(str, "") == 0)
		ret = 1;
	else if (str[0] == COMMENT_CHAR)
		ret = 1;
	free(str);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x2bbb(%rip), %rsi      # 0x6273
callq 0x3e05
movq %rax, %rbx
leaq 0x2bae(%rip), %rsi      # 0x6275
movq %rax, %rdi
callq 0x4198
testl %eax, %eax
je 0x36de
xorl %ebp, %ebp
cmpb $0x23, (%rbx)
sete %bpl
jmp 0x36e3
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/parser.c
// Function: chk_after_lbl
int		chk_after_lbl(char *buf, char **next)
{
	int		i;

	i = 0;
	while (buf[i] != '\0' && buf[i] != LABEL_CHAR)
	{
		i++;
	}
	if (buf[i] == LABEL_CHAR)
	{
		buf = ft_pass_space_tab(buf + i + 1);
		if (ft_strlen(buf) > 0)
		{
			*next = ft_strdup(buf);
			return (1);
		}
	}
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
incq %rdi
movzbl -0x1(%rdi), %eax
testl %eax, %eax
je 0x3732
cmpl $0x3a, %eax
jne 0x36fb
callq 0x3f8f
movq %rax, %r14
movq %rax, %rdi
callq 0x4104
testq %rax, %rax
je 0x3732
movq %r14, %rdi
callq 0x4120
movq %rax, (%rbx)
movl $0x1, %eax
jmp 0x3734
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/parser.c
// Function: routes
int		routes(t_data *data, char *buf)
{
	char		*next;

	if (is_comment(buf))
		;
	else if (read_name_comment(data, buf))
		;
	else if (check_add_lbl(buf, data))
	{
		next = NULL;
		if (chk_after_lbl(buf, &next))
			check_add_instruc(next, data);
		if (next != NULL)
			free(next);
	}
	else if (check_add_instruc(buf, data))
		;
	else if (data->fd == 0 && ft_strcmp(buf, "save") == 0)
		return (0);
	else
		error_line(data, "Lexical error");
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x36ae
movl $0x1, %ebx
testl %eax, %eax
jne 0x376b
movq %r14, %rdi
movq %r15, %rsi
callq 0x366c
testl %eax, %eax
je 0x3777
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x2870
testl %eax, %eax
je 0x37bc
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %r15, %rdi
callq 0x36f4
testl %eax, %eax
je 0x37ab
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2a08
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x376b
callq 0x1030
jmp 0x376b
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a08
testl %eax, %eax
jne 0x376b
cmpl $0x0, 0x8(%r14)
jne 0x37e5
leaq 0x2d68(%rip), %rsi      # 0x6541
movq %r15, %rdi
callq 0x4198
testl %eax, %eax
je 0x37f9
leaq 0x2d5a(%rip), %rsi      # 0x6546
movq %r14, %rdi
callq 0x1ee2
jmp 0x376b
xorl %ebx, %ebx
jmp 0x376b
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/parser.c
// Function: parser
void	parser(t_data *data)
{
	char		*buf;
	int			next;

	next = 1;
	while (next && (buf = NULL) == NULL && get_next_line(data->fd, &buf) > 0)
	{
		next = routes(data, buf);
		free(buf);
		data->line++;
	}
	if (data->name == NULL)
		error_str(NULL, "Error : missing ", NAME_CMD_STRING);
	if (data->comment == NULL)
		error_str(NULL, "Error : missing ", COMMENT_CMD_STRING);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, 0x8(%rsp)
movl 0x8(%rbx), %edi
movq %r14, %rsi
callq 0x45ac
testl %eax, %eax
jle 0x3848
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x373c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0x1030
incl 0x40(%rbx)
testl %ebp, %ebp
jne 0x3810
cmpq $0x0, 0x18(%rbx)
jne 0x3864
leaq 0x2cfe(%rip), %rsi      # 0x6554
leaq 0x2b96(%rip), %rdx      # 0x63f3
xorl %edi, %edi
callq 0x1f4d
cmpq $0x0, 0x20(%rbx)
jne 0x3880
leaq 0x2ce2(%rip), %rsi      # 0x6554
leaq 0x2b94(%rip), %rdx      # 0x640d
xorl %edi, %edi
callq 0x1f4d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/prog.c
// Function: add_to_prog
void	add_to_prog(t_data *data, unsigned char c)
{
	unsigned char	*tmp;
	int				i;

	data->prog_size++;
	if ((tmp = (unsigned char *)malloc(sizeof(unsigned char) *
				data->prog_size)) == NULL)
		error("Malloc error");
	i = 0;
	while (i < data->prog_size - 1)
	{
		tmp[i] = data->prog[i];
		i++;
	}
	tmp[i] = c;
	free(data->prog);
	data->prog = tmp;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x50(%rdi), %rdi
incq %rdi
movl %edi, 0x50(%rbx)
callq 0x1080
movq %rax, %r14
testq %rax, %rax
jne 0x38b8
leaq 0x2873(%rip), %rdi      # 0x6126
callq 0x1f38
movl 0x50(%rbx), %eax
cmpl $0x2, %eax
jl 0x38da
decl %eax
movq 0x48(%rbx), %rdx
xorl %ecx, %ecx
movb (%rdx,%rcx), %sil
movb %sil, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x38c8
jmp 0x38dc
xorl %ecx, %ecx
movb %bpl, (%r14,%rcx)
movq 0x48(%rbx), %rdi
callq 0x1030
movq %r14, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/asm/prog.c
// Function: print_prog
void	print_prog(t_data *data)
{
	int		i;

	i = 0;
	while (i < data->prog_size)
	{
		if (i % 16 == 0)
			ft_putendl("");
		if (i % 2 == 0)
			ft_printf("%02x", data->prog[i]);
		if (i % 2 == 1)
			ft_printf("%02x ", data->prog[i]);
		i++;
	}
	ft_putendl("");
}

// Assembly:
cmpl $0x0, 0x50(%rdi)
jle 0x395a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x296a(%rip), %r14      # 0x6275
leaq 0x2c53(%rip), %r15      # 0x6565
leaq 0x2c51(%rip), %r12      # 0x656a
xorl %r13d, %r13d
testb $0xf, %r13b
jne 0x392a
movq %r14, %rdi
callq 0x4548
testb $0x1, %r13b
movq %r12, %rdi
cmoveq %r15, %rdi
movq 0x48(%rbx), %rax
movzbl (%rax,%r13), %esi
xorl %eax, %eax
callq 0x48d0
incq %r13
movslq 0x50(%rbx), %rax
cmpq %rax, %r13
jl 0x391c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
leaq 0x2914(%rip), %rdi      # 0x6275
jmp 0x4548
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movslq (%rsi), %r15
leaq 0x1(%r15), %rdi
movl %edi, (%rsi)
callq 0x1080
movq %rax, %r14
testq %rax, %rax
jne 0x3996
leaq 0x2795(%rip), %rdi      # 0x6126
callq 0x1f38
testl %r15d, %r15d
jle 0x39b1
movq (%rbx), %rcx
xorl %eax, %eax
movb (%rcx,%rax), %dl
movb %dl, (%r14,%rax)
incq %rax
cmpq %rax, %r15
jne 0x39a0
jmp 0x39b3
xorl %eax, %eax
movb %bpl, (%r14,%rax)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x39c4
callq 0x1030
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
sete %al
movslq %ecx, %r12
addq %rdx, %r12
movzbl (%r12), %ecx
cmpl $0x9, %ecx
je 0x39fd
cmpl $0x20, %ecx
jne 0x3a04
incl %ebx
incq %r12
jmp 0x39ee
movabsq $0x100000201, %r13      # imm = 0x100000201
movzbl (%r12), %ecx
cmpq $0x20, %rcx
ja 0x3a1f
btq %rcx, %r13
jb 0x3a4c
testb $0x1, %al
jne 0x3a33
movq %r15, %rdi
movq %r14, %rsi
movl $0x20, %edx
callq 0x3968
movsbl (%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3968
incl %ebx
incq %r12
movb $0x1, %al
jmp 0x3a0e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x0, 0x4(%rsp)
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x3abd
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3aa4
xorl %eax, %eax
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x39d2
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
jne 0x3a8b
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3968
movq (%rbx), %rax
jmp 0x3abf
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x3a, 0x1(%rsi)
jne 0x3b09
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x192f
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x129a
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3b16
incq %r14
movq %r14, %rdi
callq 0x4208
movl %eax, %ebp
movl %ebp, %r14d
shrl $0x8, %r14d
movl %ebp, %r15d
shrl $0x10, %r15d
movl %ebp, %esi
shrl $0x18, %esi
movq %rbx, %rdi
callq 0x388c
movl $0xff, %r12d
andl %r12d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x388c
andl %r12d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x388c
andl %r12d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x388c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x3a, (%rsi)
jne 0x3ba2
movl %ecx, %ebp
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x192f
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x129a
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3bac
movq %r14, %rdi
callq 0x4208
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x388c
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x388c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x3a, 0x1(%rsi)
jne 0x3c30
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x192f
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x129a
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3c3d
incq %r14
movq %r14, %rdi
callq 0x4208
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x388c
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x388c
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
testq %rsi, %rsi
je 0x3da1
movb (%rsi), %cl
testb %cl, %cl
je 0x3da1
incq %rsi
xorl %eax, %eax
xorl %edx, %edx
cmpb %dil, %cl
sete %dl
addl %edx, %eax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x3d8e
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x3e04
movb (%rsi), %dl
testb %dl, %dl
je 0x3e04
pushq %rbx
leaq 0x1(%rdi), %rcx
xorl %r8d, %r8d
movl $0x1, %eax
testq %rdi, %rdi
je 0x3e03
movb (%rdi), %r11b
testb %r11b, %r11b
je 0x3e03
xorl %r9d, %r9d
movq %rcx, %r10
xorl %ebx, %ebx
cmpb %dl, %r11b
sete %bl
addl %ebx, %r9d
movb (%r10), %r11b
incq %r10
testb %r11b, %r11b
jne 0x3dda
testl %r9d, %r9d
je 0x3e03
movb 0x1(%rsi,%r8), %dl
incq %r8
testb %dl, %dl
jne 0x3dc7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %dl
testb %dl, %dl
je 0x3e6f
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
movl $0x1, %r8d
testq %rbx, %rbx
je 0x3e5b
movb (%rbx), %dil
testb %dil, %dil
je 0x3e5b
xorl %esi, %esi
movq %rax, %r8
xorl %r9d, %r9d
cmpb %dl, %dil
sete %r9b
addl %r9d, %esi
movb (%r8), %dil
incq %r8
testb %dil, %dil
jne 0x3e3a
xorl %r8d, %r8d
testl %esi, %esi
sete %r8b
addl %r8d, %r15d
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x3e22
incl %r15d
jmp 0x3e75
movl $0x1, %r15d
movq %r15, %rdi
callq 0x1080
movq %rax, %r12
testq %rax, %rax
jne 0x3e91
leaq 0x229a(%rip), %rdi      # 0x6126
callq 0x1f38
movq %r12, %rdi
movq %r15, %rsi
callq 0x40f4
movb (%r14), %dl
testb %dl, %dl
je 0x3eee
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
xorl %esi, %esi
testq %rbx, %rbx
je 0x3ed9
movb (%rbx), %r9b
testb %r9b, %r9b
je 0x3ed9
xorl %edi, %edi
movq %rax, %r8
xorl %r10d, %r10d
cmpb %dl, %r9b
sete %r10b
addl %r10d, %edi
movb (%r8), %r9b
incq %r8
testb %r9b, %r9b
jne 0x3ebd
testl %edi, %edi
jne 0x3ee2
movslq %esi, %rdi
incl %esi
movb %dl, (%r12,%rdi)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x3eab
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edi, %eax
movl %esi, %ecx
orl %edx, %ecx
cmpl $0x3, %ecx
ja 0x3f5c
movl %edx, %ecx
shll $0x6, %ecx
movl %eax, %edi
andl $0x3f, %edi
testl %esi, %esi
cmovnel %edx, %ecx
cmovnel %eax, %edi
movl %ecx, %eax
shll $0x4, %eax
movl %edi, %edx
andl $0xcf, %edx
cmpl $0x1, %esi
cmovnel %ecx, %eax
cmovnel %edi, %edx
leal (,%rax,4), %ecx
movl %edx, %edi
andl $0xf3, %edi
cmpl $0x2, %esi
cmovnel %eax, %ecx
cmovnel %edx, %edi
movl %edi, %eax
andl $0xfc, %eax
cmpl $0x3, %esi
cmovnel %edi, %eax
orl %ecx, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl $0x2c, %esi
callq 0x43e8
movq %rax, %rbx
movq (%rax), %rdi
callq 0x4120
movq %rax, %r14
movq %rbx, %rdi
callq 0x3efd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, (%rdi)
je 0x4013
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
leaq 0x25b1(%rip), %r14      # 0x6570
leaq 0x242d(%rip), %rsi      # 0x63f3
movq %r14, %rdi
xorl %eax, %eax
callq 0x48d0
movq 0x20(%rbx), %rdx
leaq 0x2432(%rip), %rsi      # 0x640d
movq %r14, %rdi
xorl %eax, %eax
callq 0x48d0
movl 0x50(%rbx), %esi
leaq 0x2595(%rip), %rdi      # 0x6584
xorl %eax, %eax
callq 0x48d0
leaq 0x25ad(%rip), %rdi      # 0x65aa
xorl %eax, %eax
callq 0x48d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x38f2
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x1dfa
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
movl $0x80, %edx
callq 0x1cbe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movsbl 0x53(%rbx), %esi
movq %rbx, %rdi
callq 0x1c58
movsbl 0x52(%rbx), %esi
movq %rbx, %rdi
callq 0x1c58
movsbl 0x51(%rbx), %esi
movq %rbx, %rdi
callq 0x1c58
movsbl 0x50(%rbx), %esi
movq %rbx, %rdi
callq 0x1c58
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x1cbe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c58
movq 0x48(%rbx), %rsi
movl 0x50(%rbx), %edx
movq %rbx, %rdi
callq 0x1cbe
movq %rbx, %rdi
callq 0x3fa8
cmpl $0x0, 0x4(%rbx)
je 0x40de
popq %rbx
retq
leaq 0x24ea(%rip), %rdi      # 0x65cf
callq 0x452c
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x4548
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, (%rdi)
je 0x411a
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x410b
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
movq %rdi, %rax
movb (%rsi), %cl
movq %rdi, %rdx
testb %cl, %cl
je 0x4168
incq %rsi
movq %rax, %rdx
movb %cl, (%rdx)
incq %rdx
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x415a
movb $0x0, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x418a
movzbl %sil, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x418d
incq %rdi
cmpl %ecx, %eax
jne 0x4175
decq %rdi
movq %rdi, %rax
retq
xorl %eax, %eax
retq
xorl %eax, %eax
testb %sil, %sil
cmoveq %rdi, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x4205
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x4205
movzbl (%rdi,%rcx), %r8d
movzbl (%rsi,%rcx), %r9d
cmpb %r9b, %r8b
jne 0x41ff
cmpb $0x0, 0x1(%rsi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x41e0
subl %r9d, %r8d
movl %r8d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rbx), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x4221
incq %rbx
jmp 0x420f
cmpl $0x20, %ecx
je 0x421c
cmpl $0x2b, %ecx
je 0x4230
cmpl $0x2d, %ecx
jne 0x4243
incq %rbx
xorl %ecx, %ecx
cmpb $0x2b, %al
sete %cl
leal -0x1(,%rcx,2), %ebp
jmp 0x4248
movl $0x1, %ebp
movsbl (%rbx), %edi
callq 0x428c
testl %eax, %eax
je 0x427b
incq %rbx
xorl %r14d, %r14d
leal (%r14,%r14,4), %eax
movsbl -0x1(%rbx), %ecx
leal (%rcx,%rax,2), %r14d
addl $-0x30, %r14d
movsbl (%rbx), %edi
callq 0x428c
incq %rbx
testl %eax, %eax
jne 0x425a
jmp 0x427e
xorl %r14d, %r14d
imull %ebp, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
jne 0x42b1
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x4300
testq %rbx, %rbx
je 0x4305
movq %r14, %rdi
callq 0x4104
movq %rax, %r15
movq %rbx, %rdi
callq 0x4104
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1080
testq %rax, %rax
je 0x42a5
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4148
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4b84
jmp 0x42a8
movq %rbx, %rdi
jmp 0x4308
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4120
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x43d5
movq %rdi, %rbx
leaq -0x1(%rdi), %rax
movq %rdi, %r13
negq %r13
movabsq $0x100000600, %rcx      # imm = 0x100000600
movq %rdi, %r14
movzbl (%r14), %edx
cmpq $0x20, %rdx
ja 0x435b
btq %rdx, %rcx
jae 0x435b
incq %r14
incq %rax
decq %r13
jmp 0x4340
movq $-0x1, %rcx
cmpb $0x0, 0x1(%rbx,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x4362
movabsq $0x100000601, %rdx      # imm = 0x100000601
movzbl (%rbx,%rcx), %esi
cmpq $0x20, %rsi
ja 0x4391
btq %rsi, %rdx
jae 0x4391
testq %rcx, %rcx
je 0x4394
decq %rcx
jmp 0x4377
addq %rcx, %rbx
movq %rbx, %rcx
addq %r13, %rcx
cmovsq %r14, %rbx
movq %rbx, %r12
subq %rax, %r12
movq %r12, %rdi
callq 0x1080
testq %rax, %rax
je 0x43d5
movq %rax, %r15
cmpq $0x1, %r12
adcq $0x0, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1070
addq %r15, %rbx
movb $0x0, 0x1(%r13,%rbx)
jmp 0x43d8
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x44d1
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %cl
testb %cl, %cl
je 0x4449
xorl %r13d, %r13d
movq %r14, %rax
movl %ecx, %edx
decq %rax
movq %rax, %rcx
movq %rcx, %rax
movb 0x1(%rcx), %sil
cmpb %bl, %sil
je 0x4430
leaq 0x1(%rax), %rcx
testb %sil, %sil
jne 0x441b
movb 0x1(%rax), %cl
incq %rax
cmpb %bl, %cl
je 0x4430
xorl %esi, %esi
cmpb %bl, %dl
setne %sil
addl %esi, %r13d
testb %cl, %cl
jne 0x4413
movslq %r13d, %rax
leaq 0x8(,%rax,8), %rdi
callq 0x1080
testq %rax, %rax
je 0x44d1
movq %rax, %rcx
testl %r13d, %r13d
je 0x44d5
movsbl %bl, %eax
movl %eax, 0xc(%rsp)
xorl %r15d, %r15d
movl %r13d, %ebp
movq %rcx, 0x10(%rsp)
decq %r14
movq %r14, %r12
movq %r12, %r14
incq %r12
movb 0x1(%r14), %al
cmpb %bl, %al
je 0x447e
testb %al, %al
je 0x44d9
movq %r12, %rdi
movl 0xc(%rsp), %esi
callq 0x44f9
movslq %eax, %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x4c00
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
je 0x44d1
decl %ebp
incq %r15
movb 0x1(%r14), %al
incq %r14
cmpb %bl, %al
je 0x44cb
testb %al, %al
jne 0x44bc
testl %ebp, %ebp
jne 0x4478
jmp 0x44dc
xorl %ecx, %ecx
jmp 0x44e7
xorl %eax, %eax
jmp 0x44df
movl %r15d, %r13d
movl %r13d, %eax
movq $0x0, (%rcx,%rax,8)
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4938
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %r10, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, 0x10(%rsp)
callq 0x4120
movq %rax, %rbx
xorl %eax, %eax
movabsq $0x100000000, %rdx      # imm = 0x100000000
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %esi
testl %esi, %esi
je 0x4984
cmpl $0x25, %esi
je 0x4984
incq %rcx
addq %rdx, %rax
jmp 0x496f
movl %ecx, 0x4(%rsp)
sarq $0x20, %rax
movb $0x1, %cl
cmpb $0x0, (%rbx,%rax)
je 0x4a49
movq %rbx, %rdi
addq %rax, %rdi
leaq 0x10(%rsp), %r14
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rdi, 0x8(%rsp)
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x4a84
testq %rax, %rax
je 0x4a3e
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4298
movq %rax, %rbp
movq %r13, %rdi
callq 0x1030
movq 0x8(%rsp), %rsi
movq %rbp, %rdi
callq 0x4298
movq %rax, %r13
movq %rbx, %rdi
callq 0x1030
movq %rbp, %rdi
callq 0x1030
movslq 0x4(%rsp), %rax
movq %rax, %rcx
addq %r13, %rcx
movzbl (%rcx), %edx
testl %edx, %edx
je 0x4a1c
cmpl $0x25, %edx
je 0x4a1c
incl %eax
incq %rcx
jmp 0x4a09
movl %eax, 0x4(%rsp)
cltq
movq %r13, %rdi
addq %rax, %rdi
cmpb $0x0, (%r13,%rax)
movq %r13, %rbx
jne 0x49ad
movq %r13, %rbx
movb $0x1, %cl
jmp 0x4a49
movslq 0x4(%rsp), %rax
movb $0x0, (%rbx,%rax)
xorl %ecx, %ecx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x4a5e
movq %rbx, %rdi
callq 0x4104
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d0c
movq %rbx, %rdi
callq 0x1030
movl %r14d, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
cmpb $0x25, 0x1(%rdi)
jne 0x4abc
movq (%rbx), %rax
movb $0x0, (%rax)
incl (%r14)
addq $0x2, (%rbx)
leaq 0x1b3e(%rip), %rdi      # 0x65ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4120
movq %rsi, %r12
callq 0x56d8
testq %rax, %rax
je 0x4af5
movq %rax, %r15
cmpb $0x0, 0x20(%rax)
je 0x4afa
movq %r12, %rdi
movq %r15, %rsi
callq 0x4d9c
movq %rax, %rdi
movq %r15, %rsi
callq 0x5050
movq %rax, %rdi
movq %r15, %rsi
callq 0x5620
jmp 0x4b0b
xorl %r12d, %r12d
jmp 0x4b3e
movq (%rbx), %rax
movslq 0x24(%r15), %rcx
movsbl -0x1(%rax,%rcx), %edi
callq 0x4d88
movq %rax, %rdi
movq %r15, %rsi
callq 0x52e0
movq %rax, %r12
testq %rax, %rax
je 0x4b36
movq (%rbx), %rax
movb $0x0, (%rax)
movq %r12, %rdi
callq 0x4104
addl %eax, (%r14)
movslq 0x24(%r15), %rax
addq %rax, (%rbx)
movq %r15, %rdi
callq 0x57a1
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
xorl %edi, %edi
testq %rdx, %rdx
je 0x4b70
movb (%rsi,%rdi), %al
testb %al, %al
je 0x4b70
movb %al, (%rbx,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x4b5b
movq %rdx, %rdi
subq %rdi, %rdx
jbe 0x4b7f
addq %rbx, %rdi
xorl %esi, %esi
callq 0x1050
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x1080
testq %rax, %rax
je 0x4bcf
testq %rbx, %rbx
je 0x4bcd
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x1050
popq %rbx
retq
leaq 0x1a16(%rip), %rdi      # 0x65ec
callq 0x4548
xorl %edi, %edi
callq 0x10a0
nop
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x4c3e
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x1(%rdx), %rdi
callq 0x1080
testq %rax, %rax
je 0x4c41
testq %rbx, %rbx
je 0x4c45
movl %ebp, %ecx
addq %rcx, %r14
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
movl %ecx, %edx
cmpq %rbx, %rdx
jb 0x4c2b
jmp 0x4c47
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x4c4b
xorl %edx, %edx
movb $0x0, (%rax,%rdx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edi, %ebp
negl %ebp
jno 0x4c6a
leaq 0x19ae(%rip), %rdi      # 0x660f
popq %rbx
popq %r14
popq %rbp
jmp 0x4120
movl %edi, %ebx
cmovsl %edi, %ebp
movl %edi, %r14d
shrl $0x1f, %r14d
incl %r14d
cmpl $0xa, %ebp
jb 0x4c99
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
movl %ebp, %ecx
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x23, %rdx
incl %r14d
cmpl $0x63, %ecx
movl %edx, %ecx
ja 0x4c85
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x1080
testq %rax, %rax
je 0x4ce8
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
incq %rcx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ebp, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
leal (%rsi,%rsi), %edi
leal (%rdi,%rdi,4), %edi
subl %edi, %ebp
orb $0x30, %bpl
movb %bpl, -0x2(%rax,%rcx)
decq %rcx
movl %esi, %ebp
cmpq $0x1, %rcx
jg 0x4cb9
testl %ebx, %ebx
jns 0x4cea
movb $0x2d, (%rax)
jmp 0x4cea
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x1(%rdi), %rbx
movzbl -0x1(%rbx), %eax
cmpl $0xff, %eax
je 0x4d22
testl %eax, %eax
jne 0x4d35
jmp 0x4d3a
movb $0x0, -0x1(%rbx)
callq 0x452c
xorl %edi, %edi
callq 0x4510
movq %rbx, %rdi
incq %rbx
jmp 0x4d11
popq %rbx
jmp 0x452c
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
leaq 0x1(%rdi), %r14
movzbl -0x1(%r14), %eax
cmpl $0xff, %eax
je 0x4d5c
testl %eax, %eax
jne 0x4d74
jmp 0x4d79
movb $0x0, -0x1(%r14)
movl %ebx, %esi
callq 0x455c
xorl %edi, %edi
movl %ebx, %esi
callq 0x4cf0
movq %r14, %rdi
incq %r14
jmp 0x4d4a
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x455c
nop