LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip.c
// Function: check_add_lbl
int			check_add_lbl(char *buf, t_data *data)
{
	t_label		*new_elem;
	char		**sp_lbl_name;
	char		*colon_chr;

	init_check_add_lbl(&new_elem, &sp_lbl_name, &colon_chr);
	if (is_in_str(LABEL_CHAR, buf) >= 1)
	{
		if ((sp_lbl_name = ft_strsplit(buf, LABEL_CHAR)) == NULL)
			error_line(data, "Malloc error");
		if (check_add_lbl_cut(buf, &colon_chr, sp_lbl_name) == 1)
			return (0);
		if (is_in_str(*colon_chr, " \t") == 0 && (*colon_chr) != DIRECT_CHAR)
		{
			if (str_is_in_str(LABEL_CHARS, sp_lbl_name[0]) == 1)
				error_line(data, "Incorrect label name");
			new_elem = lbl_new_elem(ft_strdup(sp_lbl_name[0]));
			addend_lbl_lst(&data->label, new_elem);
			free_strsplit(sp_lbl_name);
			return (1);
		}
		free_strsplit(sp_lbl_name);
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2676
movl $0x3a, %edi
movq %r14, %rsi
callq 0x3dd4
xorl %ebp, %ebp
testl %eax, %eax
jle 0x29a0
movq %r14, %rdi
movl $0x3a, %esi
callq 0x443c
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x2904
leaq 0x382f(%rip), %rsi      # 0x6126
movq %rbx, %rdi
callq 0x1f0a
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x29ab
testl %eax, %eax
jne 0x29a0
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
leaq 0x3948(%rip), %rsi      # 0x6273
callq 0x3dd4
xorl %ebp, %ebp
testl %eax, %eax
jne 0x2996
movq 0x10(%rsp), %rax
cmpb $0x25, (%rax)
je 0x2996
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x38d9(%rip), %rdi      # 0x6228
callq 0x3dfa
cmpl $0x1, %eax
jne 0x2968
leaq 0x3916(%rip), %rsi      # 0x6276
movq %rbx, %rdi
callq 0x1f0a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4170
movq %rax, %rdi
callq 0x2ea4
movq %rax, 0x18(%rsp)
addq $0x38, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ee0
movl $0x1, %ebp
movq 0x8(%rsp), %rdi
callq 0x3f50
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip.c
// Function: check_add_lbl_cut
int			check_add_lbl_cut(char *buf, char **colon_chr, char **sp_lbl_name)
{
	if (!(*colon_chr = ft_strchr(buf, LABEL_CHAR)) || buf == *colon_chr)
	{
		free_strsplit(sp_lbl_name);
		return (1);
	}
	*colon_chr = *colon_chr - 1;
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl $0x3a, %esi
callq 0x41bc
movq %rax, (%rbx)
testq %rax, %rax
setne %cl
cmpq %r15, %rax
setne %dl
testb %dl, %cl
jne 0x29e5
movq %r14, %rdi
callq 0x3f50
movl $0x1, %eax
jmp 0x29ed
decq %rax
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip.c
// Function: check_add_instruc
int			check_add_instruc(char *buf, t_data *data)
{
	char		*trim;
	char		**inst_line;
	int			ret;

	buf = check_comm(buf, data);
	check_first_lbl(data);
	init_check_add_instruc(&inst_line, &trim, &ret);
	trim = real_trim(buf);
	if (is_in_str(' ', trim) > 0)
	{
		ret = 1;
		if ((inst_line = ft_strsplit(trim, ' ')) == NULL)
			error("Malloc error");
		check_all_params(trim, inst_line, data, &ret);
		free_strsplit(inst_line);
	}
	return (ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
callq 0x1a45
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a0b
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %r15
leaq 0xc(%rsp), %rdx
movq %r15, %rsi
callq 0x2668
movq %r14, %rdi
callq 0x3ab3
movq %rax, (%r15)
movl $0x20, %edi
movq %rax, %rsi
callq 0x3dd4
testl %eax, %eax
jle 0x2adb
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x20, %esi
callq 0x443c
movq %rax, 0x10(%rsp)
testq %rax, %rax
jne 0x2abc
leaq 0x3674(%rip), %rdi      # 0x6126
callq 0x1f60
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rcx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2aec
movq 0x10(%rsp), %rdi
callq 0x3f50
movl 0xc(%rsp), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip_next.c
// Function: check_all_params
void		check_all_params(char *trim, char **inst_line, t_data *data,
		int *ret)
{
	if (is_in_str(SEPARATOR_CHAR, trim) == 0 && check_opcode_name(
				inst_line[0]) == 1)
		inst_one_param(inst_line, data);
	else if (is_in_str(SEPARATOR_CHAR, trim) == 1 && check_opcode_name(
				inst_line[0]) == 1)
		inst_two_params(inst_line, trim, data);
	else if (is_in_str(SEPARATOR_CHAR, trim) == 2 && check_opcode_name(
				inst_line[0]) == 1)
		inst_three_params(inst_line, trim, data);
	else if (is_in_str(SEPARATOR_CHAR, trim) > 3 && ft_strchr(trim,
				COMMENT_CHAR) == NULL)
		error_line(data, "Incorrect number of params");
	else
		*ret = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl $0x2c, %edi
movq %r15, %rsi
callq 0x3dd4
testl %eax, %eax
jne 0x2b35
movq (%r12), %rdi
callq 0x3608
cmpl $0x1, %eax
jne 0x2b35
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2bf8
movl $0x2c, %edi
movq %r15, %rsi
callq 0x3dd4
cmpl $0x1, %eax
jne 0x2b6e
movq (%r12), %rdi
callq 0x3608
cmpl $0x1, %eax
jne 0x2b6e
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2c94
movl $0x2c, %edi
movq %r15, %rsi
callq 0x3dd4
cmpl $0x2, %eax
jne 0x2ba7
movq (%r12), %rdi
callq 0x3608
cmpl $0x1, %eax
jne 0x2ba7
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2d83
movl $0x2c, %edi
movq %r15, %rsi
callq 0x3dd4
cmpl $0x4, %eax
jl 0x2bcb
movq %r15, %rdi
movl $0x23, %esi
callq 0x41bc
testq %rax, %rax
je 0x2bde
movl $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x36b8(%rip), %rsi      # 0x629d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f0a
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip_next.c
// Function: inst_one_param
void		inst_one_param(char **inst_line, t_data *data)
{
	t_instruc	*new_elem;
	t_label		*tmp_lbl;
	int			order;
	int			i;

	new_elem = NULL;
	order = 0;
	i = 0;
	while (inst_line[i])
		i++;
	if (i > 2)
		error_line(data, "Incorrect number of params");
	new_elem = inst_new_elem(ft_strdup(inst_line[0]));
	check_opcode(inst_line[0], new_elem);
	check_params(inst_line[1], new_elem, data, &order);
	new_elem->param_1 = no_comma(inst_line[1]);
	tmp_lbl = last_label(data);
	addend_inst_lst(&tmp_lbl->insts, new_elem);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
movq $-0x1, %rax
cmpq $0x0, 0x8(%r14,%rax,8)
leaq 0x1(%rax), %rax
jne 0x2c16
cmpq $0x3, %rax
jb 0x2c37
leaq 0x366e(%rip), %rsi      # 0x629d
movq %rbx, %rdi
callq 0x1f0a
movq (%r14), %rdi
callq 0x4170
movq %rax, %rdi
callq 0x2684
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x364c
movq 0x8(%r14), %rdi
leaq 0xc(%rsp), %rcx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x19ac
movq 0x8(%r14), %rdi
callq 0x3fb0
movq %rax, 0x18(%r15)
movq %rbx, %rdi
callq 0x29f3
leaq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x26d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip_next.c
// Function: inst_two_params
void		inst_two_params(char **inst_line, char *trim,
								t_data *data)
{
	t_instruc	*new_elem;
	t_label		*tmp_lbl;
	char		**inst_params;
	int			order;

	new_elem = NULL;
	inst_params = NULL;
	order = 0;
	new_elem = inst_new_elem(ft_strdup(inst_line[0]));
	check_opcode(inst_line[0], new_elem);
	check_params(inst_line[1], new_elem, data, &order);
	new_elem->param_1 = no_comma(inst_line[1]);
	if ((inst_params = ft_strsplit(trim, SEPARATOR_CHAR)) == NULL)
		error("Malloc error");
	if (inst_params[1] == NULL)
		error_line(data, "Incorrect input parameters");
	check_params(inst_params[1], new_elem, data, &order);
	new_elem->param_2 = ft_strdup(ft_pass_space_tab(inst_params[1]));
	tmp_lbl = last_label(data);
	addend_inst_lst(&tmp_lbl->insts, new_elem);
	free_strsplit(inst_params);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %r13
movl $0x0, (%r13)
movq (%rdi), %rdi
callq 0x4170
movq %rax, %rdi
callq 0x2684
movq %rax, %r14
movq (%r12), %rdi
movq %rax, %rsi
callq 0x364c
movq 0x8(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x19ac
movq 0x8(%r12), %rdi
callq 0x3fb0
movq %rax, 0x18(%r14)
movq %r15, %rdi
movl $0x2c, %esi
callq 0x443c
movq %rax, %r15
testq %rax, %rax
jne 0x2d18
leaq 0x3413(%rip), %rdi      # 0x6126
callq 0x1f60
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x2d34
leaq 0x34c8(%rip), %rsi      # 0x61f0
movq %rbx, %rdi
callq 0x1f0a
movq 0x8(%r15), %rdi
leaq 0xc(%rsp), %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19ac
movq 0x8(%r15), %rdi
callq 0x3fdf
movq %rax, %rdi
callq 0x4170
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x29f3
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x26d0
movq %r15, %rdi
callq 0x3f50
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_inst_manip_next.c
// Function: inst_three_params
void		inst_three_params(char **inst_line, char *trim, t_data *data)
{
	t_instruc	*new_elem;
	t_label		*tmp_lbl;
	char		**inst_params;
	int			order;

	new_elem = NULL;
	inst_params = NULL;
	order = 0;
	new_elem = inst_new_elem(ft_strdup(inst_line[0]));
	check_opcode(inst_line[0], new_elem);
	check_params(inst_line[1], new_elem, data, &order);
	new_elem->param_1 = no_comma(inst_line[1]);
	if ((inst_params = ft_strsplit(trim, SEPARATOR_CHAR)) == NULL)
		error("Malloc error");
	if (inst_params[1] == NULL || inst_params[2] == NULL)
		error_line(data, "Incorrect input parameters");
	check_params(inst_params[1], new_elem, data, &order);
	new_elem->param_2 = ft_strdup(ft_pass_space_tab(inst_params[1]));
	check_params(inst_params[2], new_elem, data, &order);
	new_elem->param_3 = ft_strdup(ft_pass_space_tab(inst_params[2]));
	tmp_lbl = last_label(data);
	addend_inst_lst(&tmp_lbl->insts, new_elem);
	free_strsplit(inst_params);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc(%rsp), %r13
movl $0x0, (%r13)
movq (%rdi), %rdi
callq 0x4170
movq %rax, %rdi
callq 0x2684
movq %rax, %r14
movq (%r12), %rdi
movq %rax, %rsi
callq 0x364c
movq 0x8(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x19ac
movq 0x8(%r12), %rdi
callq 0x3fb0
movq %rax, 0x18(%r14)
movq %r15, %rdi
movl $0x2c, %esi
callq 0x443c
movq %rax, %r15
testq %rax, %rax
jne 0x2e07
leaq 0x3324(%rip), %rdi      # 0x6126
callq 0x1f60
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2e17
cmpq $0x0, 0x10(%r15)
jne 0x2e2a
leaq 0x33d2(%rip), %rsi      # 0x61f0
movq %rbx, %rdi
callq 0x1f0a
movq 0x8(%r15), %rdi
leaq 0xc(%rsp), %r12
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x19ac
movq 0x8(%r15), %rdi
callq 0x3fdf
movq %rax, %rdi
callq 0x4170
movq %rax, 0x20(%r14)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x19ac
movq 0x10(%r15), %rdi
callq 0x3fdf
movq %rax, %rdi
callq 0x4170
movq %rax, 0x28(%r14)
movq %rbx, %rdi
callq 0x29f3
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x26d0
movq %r15, %rdi
callq 0x3f50
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_list_fct.c
// Function: lbl_new_elem
t_label		*lbl_new_elem(char *name)
{
	t_label		*new_element;

	if ((new_element = (t_label *)malloc(sizeof(t_label))) == NULL)
		error("Malloc error");
	if (new_element != NULL)
	{
		new_element->next = NULL;
		new_element->insts = NULL;
		new_element->name = name;
	}
	return (new_element);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
je 0x2ec9
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r14, 0x10(%rbx)
jmp 0x2ed5
leaq 0x3256(%rip), %rdi      # 0x6126
callq 0x1f60
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/label_list_fct.c
// Function: print_lbl_lst
void		print_lbl_lst(t_label *lst)
{
	t_label		*tmp;

	tmp = lst;
	while (tmp)
	{
		ft_putchar('[');
		ft_putstr(tmp->name);
		ft_putstr("] ");
		tmp = tmp->next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2f31
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33b1(%rip), %r14      # 0x62b8
movl $0x5b, %edi
callq 0x4540
movq 0x10(%rbx), %rdi
callq 0x455c
movq %r14, %rdi
callq 0x455c
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2f07
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/live_coding.c
// Function: live_coding_mode
void	live_coding_mode(t_data *data, char *filename)
{
	char	*tmp;

	ft_printf("\t\t\033[32;1;4mLive Coding Mode\033[0m\n");
	while (filename == NULL || ft_strcmp(filename, "") == 0)
	{
		ft_printf("\033[36;1mEnter filename :\033[0m\n");
		get_next_line(0, &filename);
	}
	tmp = ft_strjoin(filename, ".s");
	free(filename);
	set_filename(data, tmp);
	free(tmp);
	ft_printf("\033[36;1mWrite your file here (type \033[34;1msave%s",
							"\033[36;1m when you have finish) :\033[0m\n");
	data->fd = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
leaq 0x3365(%rip), %rdi      # 0x62bb
xorl %eax, %eax
callq 0x4984
leaq 0x3378(%rip), %r15      # 0x62dc
leaq 0x330a(%rip), %r12      # 0x6275
testq %r13, %r13
je 0x2f7f
movq %r13, %rdi
movq %r12, %rsi
callq 0x41e8
testl %eax, %eax
jne 0x2f9a
movq %r15, %rdi
xorl %eax, %eax
callq 0x4984
xorl %edi, %edi
movq %r14, %rsi
callq 0x45dc
movq 0x8(%rsp), %r13
jmp 0x2f6b
movq 0x8(%rsp), %rdi
leaq 0x3353(%rip), %rsi      # 0x62f9
callq 0x42e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d66
movq %r14, %rdi
callq 0x1030
leaq 0x332a(%rip), %rdi      # 0x62fc
leaq 0x3353(%rip), %rsi      # 0x632c
xorl %eax, %eax
callq 0x4984
movl $0x0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/mem.c
// Function: free_inst_lbl
void	free_inst_lbl(t_label *lbl)
{
	t_label		*tmp_lbl;
	t_label		*lbl_free;
	t_instruc	*inst_free;

	tmp_lbl = lbl;
	while (tmp_lbl)
	{
		while (tmp_lbl->insts)
		{
			free_inst_lbl_cut(tmp_lbl);
			inst_free = tmp_lbl->insts;
			tmp_lbl->insts = tmp_lbl->insts->next;
			free(inst_free);
		}
		if (tmp_lbl->name != NULL)
			free(tmp_lbl->name);
		lbl_free = tmp_lbl;
		tmp_lbl = tmp_lbl->next;
		free(lbl_free);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x304d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rbx)
je 0x3025
movq %rbx, %rdi
callq 0x304e
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x1030
jmp 0x3004
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3033
callq 0x1030
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x3004
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/asm/mem.c
// Function: free_inst_lbl_cut
void	free_inst_lbl_cut(t_label *tmp_lbl)
{
	if (tmp_lbl->insts->name != NULL)
		free(tmp_lbl->insts->name);
	if (tmp_lbl->insts->param_1 != NULL)
		free(tmp_lbl->insts->param_1);
	if (tmp_lbl->insts->param_2 != NULL)
		free(tmp_lbl->insts->param_2);
	if (tmp_lbl->insts->param_3 != NULL)
		free(tmp_lbl->insts->param_3);
	if (tmp_lbl->insts->trim != NULL)
		free(tmp_lbl->insts->trim);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3068
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x307a
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x308c
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x309e
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x30ad
popq %rbx
jmp 0x1030
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, %rbp
movq %rdi, %r15
movl %ecx, %edi
callq 0x35f4
cmpq $0x0, 0x8(%r14)
je 0x319e
movl %eax, 0x4(%rsp)
movq %r15, %rbx
movq 0x10(%r14), %r13
testq %r13, %r13
je 0x31ad
movq %r13, %rdi
callq 0x4154
movq %rax, %r15
addq %r13, %r15
movq 0x10(%r14), %rdi
callq 0x3fdf
cmpq %rax, %r15
je 0x31ad
cmpq $0x0, 0x8(%r14)
movl 0x4(%rsp), %eax
je 0x319e
movq %rbx, %rdi
cmpl $0x1, %r12d
jne 0x323b
leaq 0x3246(%rip), %rsi      # 0x63df
jmp 0x3242
movq %rbp, %rdi
movl %eax, %esi
callq 0x30ec
jmp 0x3247
cmpq $0x0, (%rbp)
movq %rbx, %r13
je 0x31d5
cmpl $0x1, %r12d
leaq 0x319f(%rip), %rax      # 0x6361
leaq 0x31ad(%rip), %rsi      # 0x6376
cmoveq %rax, %rsi
movq %r13, %rdi
callq 0x1f0a
movq 0x8(%r14), %rdi
callq 0x4154
movl 0x4(%rsp), %r15d
cmpl $0x1, %r12d
movq %rbp, %rbx
jne 0x31fe
cmpq %r15, %rax
jbe 0x31fe
leaq 0x3196(%rip), %rsi      # 0x638e
movl 0x4(%rsp), %ebp
jmp 0x3217
movq 0x8(%r14), %rdi
callq 0x4154
cmpq %r15, %rax
movl 0x4(%rsp), %ebp
jbe 0x3223
leaq 0x319e(%rip), %rsi      # 0x63b5
movq %r13, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x1fdc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x30ec
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x4198
jmp 0x3247
leaq 0x31b7(%rip), %rsi      # 0x63f9
callq 0x1f0a
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_O3/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 0x35de
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x3fdf
movq %rax, (%rbx)
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x35f4
// File: /workspace/github_c_makefile_star2_O3/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 0x35de
movq %rax, %r15
movq %r12, %rdi
callq 0x3fdf
movq %rax, %r13
movl %ebp, %edi
callq 0x35f4
movl %eax, %r12d
movq %r15, %rdi
callq 0x4154
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4204
testl %eax, %eax
jne 0x335b
movq %r15, %rdi
callq 0x4154
leaq (%rax,%r13), %rdi
callq 0x3fdf
cmpb $0x22, (%rax)
jne 0x335b
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x30b0
movl %eax, 0x4(%rsp)
movq %r13, %rdi
movl $0x22, %esi
callq 0x443c
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x3129
cmpl $0x1, 0x4(%rsp)
jne 0x334c
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x333c
callq 0x4154
subl %eax, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x353d
movq %r15, %rdi
callq 0x3f50
movl $0x1, %ebp
jmp 0x33a1
movq %r15, %rdi
callq 0x4154
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4204
xorl %ebp, %ebp
testl %eax, %eax
jne 0x33a1
movq %r15, %rdi
callq 0x4154
addq %rax, %r13
movq %r13, %rdi
callq 0x3fdf
cmpb $0x22, (%rax)
je 0x33a1
leaq 0x3080(%rip), %rsi      # 0x6416
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1f75
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_O3/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 0x4154
movq %rax, %rcx
incq %rcx
movl %ebp, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
ja 0x3437
movq (%rbx), %rdi
leaq 0x2d05(%rip), %rsi      # 0x60ec
callq 0x42e0
movq %rax, %r14
movq %r15, %rdi
callq 0x4154
testq %rax, %rax
je 0x341f
movq %r14, %rdi
movq %r15, %rsi
callq 0x42e0
movq %rax, %r15
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x4198
movq %r15, %rdi
callq 0x1030
jmp 0x342a
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4198
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_O3/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
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movl $0x22, %edi
movq %rcx, %rsi
callq 0x3dd4
testl %eax, %eax
je 0x34c2
cmpl $0x1, %eax
jne 0x352e
movq %r15, %rdi
movl $0x22, %esi
callq 0x443c
movq %rax, %r15
movq (%rax), %rsi
testq %rsi, %rsi
je 0x34fa
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x3507
movq %r12, %rdi
callq 0x4154
movq %rax, %r13
addq %r12, %r13
movq 0x8(%r15), %rdi
callq 0x3fdf
movq (%r15), %rsi
cmpq %rax, %r13
je 0x3507
testq %rsi, %rsi
je 0x34fa
movq %r15, %rdi
callq 0x3f50
jmp 0x3522
movl 0x4(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33b4
cmpl $-0x1, %eax
je 0x3529
movl 0x4(%r14), %ebp
movq %r15, %rdi
callq 0x4154
notl %eax
addl %eax, %ebp
movl (%r14), %ecx
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x353d
xorl %eax, %eax
jmp 0x352e
movl 0x4(%r14), %edx
leaq 0x2d70(%rip), %rsi      # 0x6275
jmp 0x350b
movl 0x4(%r14), %edx
movq %rbx, %rdi
callq 0x33b4
movl %eax, %ebx
movq %r15, %rdi
callq 0x3f50
cmpl $-0x1, %ebx
je 0x3529
movl $0x1, %eax
jmp 0x352e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x45dc
testl %eax, %eax
js 0x35d5
incl 0x40(%rbx)
movq (%rsp), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3442
cmpl $-0x1, %eax
leaq 0x2e02(%rip), %rsi      # 0x638e
leaq 0x2e22(%rip), %rcx      # 0x63b5
cmovneq %rcx, %rsi
cmpl $0x1, %ebp
cmovneq %rcx, %rsi
cmpl $-0x1, %eax
je 0x35c4
cmpl $0x2, %eax
leaq 0x2e84(%rip), %rsi      # 0x6431
leaq 0x2e91(%rip), %rcx      # 0x6445
cmovlq %rcx, %rsi
cmpl $0x1, %ebp
cmovneq %rcx, %rsi
cmpl $0x2, %eax
jl 0x35cc
movq %rbx, %rdi
callq 0x1f0a
movq (%rsp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6a12(%rip), %r12      # 0xa070
movq (%r12), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x36a5
movq %rdi, %r15
callq 0x41e8
testl %eax, %eax
je 0x3696
leaq 0x69f4(%rip), %r12      # 0xa070
movq 0x30(%r12), %rsi
testq %rsi, %rsi
je 0x36a5
movq %r15, %rdi
callq 0x41e8
addq $0x30, %r12
testl %eax, %eax
jne 0x367c
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_O3/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 0x2b73(%rip), %rsi      # 0x6273
callq 0x3e58
movq %rax, %rbx
leaq 0x2b66(%rip), %rsi      # 0x6275
movq %rax, %rdi
callq 0x41e8
testl %eax, %eax
je 0x3726
xorl %ebp, %ebp
cmpb $0x23, (%rbx)
sete %bpl
jmp 0x372b
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_O3/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 0x377a
cmpl $0x3a, %eax
jne 0x3743
callq 0x3fdf
movq %rax, %r14
movq %rax, %rdi
callq 0x4154
testq %rax, %rax
je 0x377a
movq %r14, %rdi
callq 0x4170
movq %rax, (%rbx)
movl $0x1, %eax
jmp 0x377c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x36f6
movl $0x1, %ebx
testl %eax, %eax
jne 0x37b2
movq %r14, %rdi
movq %r15, %rsi
callq 0x36b4
testl %eax, %eax
je 0x37c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x28a0
testl %eax, %eax
je 0x3807
movq %rsp, %r12
movq $0x0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x373c
movq (%r12), %r15
testl %eax, %eax
je 0x37f8
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a3b
testq %r15, %r15
je 0x37b2
movq %r15, %rdi
callq 0x1030
jmp 0x37b2
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a3b
testl %eax, %eax
jne 0x37b2
cmpl $0x0, 0x8(%r14)
jne 0x3830
leaq 0x2d1d(%rip), %rsi      # 0x6541
movq %r15, %rdi
callq 0x41e8
testl %eax, %eax
je 0x3844
leaq 0x2d0f(%rip), %rsi      # 0x6546
movq %r14, %rdi
callq 0x1f0a
jmp 0x37b2
xorl %ebx, %ebx
jmp 0x37b2
// File: /workspace/github_c_makefile_star2_O3/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 0x45dc
testl %eax, %eax
jle 0x3893
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3784
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0x1030
incl 0x40(%rbx)
testl %ebp, %ebp
jne 0x385b
cmpq $0x0, 0x18(%rbx)
jne 0x38af
leaq 0x2cb3(%rip), %rsi      # 0x6554
leaq 0x2b4b(%rip), %rdx      # 0x63f3
xorl %edi, %edi
callq 0x1f75
cmpq $0x0, 0x20(%rbx)
jne 0x38cb
leaq 0x2c97(%rip), %rsi      # 0x6554
leaq 0x2b49(%rip), %rdx      # 0x640d
xorl %edi, %edi
callq 0x1f75
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x50(%rdi), %r15
incq %r15
movl %r15d, 0x50(%rdi)
movq %r15, %rdi
callq 0x1080
movq %rax, %r14
testq %rax, %rax
jne 0x390b
leaq 0x2824(%rip), %rdi      # 0x6126
callq 0x1f60
movl 0x50(%rbx), %r15d
movq 0x48(%rbx), %rdi
cmpl $0x2, %r15d
jl 0x392e
decl %r15d
movl %r15d, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x391d
jmp 0x3930
xorl %eax, %eax
movb %bpl, (%r14,%rax)
callq 0x1030
movq %r14, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x39b0
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2914(%rip), %r14      # 0x6275
leaq 0x2bfd(%rip), %r15      # 0x6565
leaq 0x2bfb(%rip), %r12      # 0x656a
xorl %r13d, %r13d
testb $0xf, %r13b
jne 0x3980
movq %r14, %rdi
callq 0x4578
testb $0x1, %r13b
movq 0x48(%rbx), %rax
movzbl (%rax,%r13), %esi
movq %r12, %rdi
cmoveq %r15, %rdi
xorl %eax, %eax
callq 0x4984
incq %r13
movslq 0x50(%rbx), %rax
cmpq %rax, %r13
jl 0x3972
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
leaq 0x28be(%rip), %rdi      # 0x6275
jmp 0x4578
// File: /workspace/github_c_makefile_star2_O3/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 0x39ea
leaq 0x2741(%rip), %rdi      # 0x6126
callq 0x1f60
movq (%rbx), %rdi
testl %r15d, %r15d
jle 0x3a09
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq %rax, %r15
jne 0x39f4
movb %bpl, (%r14,%r15)
jmp 0x3a11
movb %bpl, (%r14)
testq %rdi, %rdi
je 0x3a16
callq 0x1030
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rcx
leaq (%rcx,%rdx), %r12
incq %r12
movzbl -0x1(%r12), %ecx
cmpl $0x9, %ecx
je 0x3a54
cmpl $0x20, %ecx
jne 0x3a5b
incl %ebx
incq %r12
jmp 0x3a44
movabsq $0x100000201, %r13      # imm = 0x100000201
cmpb $0x20, %cl
ja 0x3a73
movzbl %cl, %edx
btq %rdx, %r13
jb 0x3aa7
testb $0x1, %al
jne 0x3a8c
movq %r15, %rdi
movq %r14, %rsi
movl $0x20, %edx
callq 0x39bc
movb -0x1(%r12), %cl
movsbl %cl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x39bc
movb (%r12), %cl
incl %ebx
incq %r12
movb $0x1, %al
jmp 0x3a65
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b18
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3aff
xorl %eax, %eax
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x3a24
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
jne 0x3ae6
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x39bc
movq (%rbx), %rax
jmp 0x3b1a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b61
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x193e
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12a5
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3b6e
incq %r14
movq %r14, %rdi
callq 0x4250
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 0x38d4
movl $0xff, %r12d
andl %r12d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x38d4
andl %r12d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38d4
andl %r12d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x38d4
// File: /workspace/github_c_makefile_star2_O3/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 0x3bfa
movl %ecx, %ebp
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x193e
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12a5
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3c04
movq %r14, %rdi
callq 0x4250
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x38d4
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38d4
// File: /workspace/github_c_makefile_star2_O3/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 0x3c88
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x193e
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x12a5
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3c95
incq %r14
movq %r14, %rdi
callq 0x4250
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x38d4
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x38d4
// File: /workspace/github_c_makefile_star2_O3/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 0x3df9
movb (%rsi), %cl
testb %cl, %cl
je 0x3df9
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 0x3de6
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e57
movb (%rsi), %cl
testb %cl, %cl
je 0x3e57
movb (%rdi), %dl
movl $0x1, %eax
testb %dl, %dl
je 0x3e57
pushq %rbx
incq %rdi
xorl %r8d, %r8d
movq %rdi, %r9
movl %edx, %r11d
xorl %r10d, %r10d
xorl %ebx, %ebx
cmpb %cl, %r11b
sete %bl
addl %ebx, %r10d
movb (%r9), %r11b
incq %r9
testb %r11b, %r11b
jne 0x3e2d
testl %r10d, %r10d
je 0x3e56
movb 0x1(%rsi,%r8), %cl
incq %r8
testb %cl, %cl
jne 0x3e24
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ec2
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
movl $0x1, %r8d
testq %rbx, %rbx
je 0x3eae
movb (%rbx), %dil
testb %dil, %dil
je 0x3eae
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 0x3e8d
xorl %r8d, %r8d
testl %esi, %esi
sete %r8b
addl %r8d, %r15d
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x3e75
incl %r15d
jmp 0x3ec8
movl $0x1, %r15d
movq %r15, %rdi
callq 0x1080
movq %rax, %r12
testq %rax, %rax
jne 0x3ee4
leaq 0x2247(%rip), %rdi      # 0x6126
callq 0x1f60
movq %r12, %rdi
movq %r15, %rsi
callq 0x4144
movb (%r14), %dl
testb %dl, %dl
je 0x3f41
leaq 0x1(%rbx), %rax
xorl %ecx, %ecx
xorl %esi, %esi
testq %rbx, %rbx
je 0x3f2c
movb (%rbx), %r9b
testb %r9b, %r9b
je 0x3f2c
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 0x3f10
testl %edi, %edi
jne 0x3f35
movslq %esi, %rdi
incl %esi
movb %dl, (%r12,%rdi)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x3efe
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3faf
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
// File: /workspace/github_c_makefile_star2_O3/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 0x443c
movq %rax, %rbx
movq (%rax), %rdi
callq 0x4170
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f50
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4063
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
leaq 0x2561(%rip), %r14      # 0x6570
leaq 0x23dd(%rip), %rsi      # 0x63f3
movq %r14, %rdi
xorl %eax, %eax
callq 0x4984
movq 0x20(%rbx), %rdx
leaq 0x23e2(%rip), %rsi      # 0x640d
movq %r14, %rdi
xorl %eax, %eax
callq 0x4984
movl 0x50(%rbx), %esi
leaq 0x2545(%rip), %rdi      # 0x6584
xorl %eax, %eax
callq 0x4984
leaq 0x255d(%rip), %rdi      # 0x65aa
xorl %eax, %eax
callq 0x4984
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3948
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e21
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
movl $0x80, %edx
callq 0x1cdc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movsbl 0x53(%rbx), %esi
movq %rbx, %rdi
callq 0x1c68
movsbl 0x52(%rbx), %esi
movq %rbx, %rdi
callq 0x1c68
movsbl 0x51(%rbx), %esi
movq %rbx, %rdi
callq 0x1c68
movsbl 0x50(%rbx), %esi
movq %rbx, %rdi
callq 0x1c68
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x1cdc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c68
movq 0x48(%rbx), %rsi
movl 0x50(%rbx), %edx
movq %rbx, %rdi
callq 0x1cdc
movq %rbx, %rdi
callq 0x3ff8
cmpl $0x0, 0x4(%rbx)
je 0x412e
popq %rbx
retq
leaq 0x249a(%rip), %rdi      # 0x65cf
callq 0x455c
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x4578
// File: /workspace/github_c_makefile_star2_O3/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 0x416a
xorl %ecx, %ecx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rdi,%rcx)
movq %rax, %rcx
jne 0x415b
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x41b8
incq %rsi
movq %rax, %rdx
movb %cl, (%rdx)
incq %rdx
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x41aa
movb $0x0, (%rdx)
retq