LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/is_reg_d_ind.c
// Function: without_ocp_live
int		without_ocp_live(char *trim, t_data *data, t_instruc *inst)
{
	if (trim[0] == DIRECT_CHAR)
	{
		check_direct(trim, data);
		inst->ocp = -4;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x35a1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ee0
movq -0x20(%rbp), %rax
movl $0xfffffffc, 0x38(%rax) # imm = 0xFFFFFFFC
movl $0x1, -0x4(%rbp)
jmp 0x35a8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/label_chars_error.c
// Function: essential_char_in_label_chars
void	essential_char_in_label_chars(void)
{
	if (is_in_str(COMMENT_CHAR, LABEL_CHARS) > 0 || is_in_str(LABEL_CHAR,
		LABEL_CHARS) > 0 || is_in_str(DIRECT_CHAR, LABEL_CHARS) > 0 ||
		is_in_str(SEPARATOR_CHAR, LABEL_CHARS) > 0)
		error("Error, Essential CHAR in LABEL_CHARS");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x23, %edi
leaq 0x6c58(%rip), %rsi      # 0xa228
callq 0x5560
cmpl $0x0, %eax
jg 0x361c
movl $0x3a, %edi
leaq 0x6c42(%rip), %rsi      # 0xa228
callq 0x5560
cmpl $0x0, %eax
jg 0x361c
movl $0x25, %edi
leaq 0x6c2c(%rip), %rsi      # 0xa228
callq 0x5560
cmpl $0x0, %eax
jg 0x361c
movl $0x2c, %edi
leaq 0x6c16(%rip), %rsi      # 0xa228
callq 0x5560
cmpl $0x0, %eax
jle 0x3628
leaq 0x6c2b(%rip), %rdi      # 0xa24e
callq 0x2580
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x31c0
movq -0x10(%rbp), %rsi
movl $0x3a, %edi
callq 0x5560
cmpl $0x1, %eax
jl 0x3742
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x6230
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3690
movq -0x18(%rbp), %rdi
leaq 0x6a9b(%rip), %rsi      # 0xa126
callq 0x2510
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x3760
cmpl $0x1, %eax
jne 0x36b2
movl $0x0, -0x4(%rbp)
jmp 0x3749
movq -0x30(%rbp), %rax
leaq 0x6bb6(%rip), %rsi      # 0xa273
movsbl (%rax), %edi
callq 0x5560
cmpl $0x0, %eax
jne 0x3739
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x3739
movq -0x28(%rbp), %rax
movq (%rax), %rsi
leaq 0x6b44(%rip), %rdi      # 0xa228
callq 0x55e0
cmpl $0x1, %eax
jne 0x36fe
movq -0x18(%rbp), %rdi
leaq 0x6b7d(%rip), %rsi      # 0xa276
callq 0x2510
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, %rdi
callq 0x3da0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x3e00
movq -0x28(%rbp), %rdi
callq 0x5780
movl $0x1, -0x4(%rbp)
jmp 0x3749
movq -0x28(%rbp), %rdi
callq 0x5780
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x5c60
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x379c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x37ae
movq -0x20(%rbp), %rdi
callq 0x5780
movl $0x1, -0x4(%rbp)
jmp 0x37c7
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/label_inst_manip.c
// Function: last_label
t_label		*last_label(t_data *data)
{
	t_label		*tmp_lbl;

	tmp_lbl = data->label;
	if (tmp_lbl)
	{
		while (tmp_lbl->next)
			tmp_lbl = tmp_lbl->next;
	}
	return (tmp_lbl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3806
jmp 0x37ed
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3804
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x37ed
jmp 0x3806
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/label_inst_manip.c
// Function: check_first_lbl
void		check_first_lbl(t_data *data)
{
	t_label		*new_elem;

	new_elem = NULL;
	if (data->label == NULL)
	{
		new_elem = lbl_new_elem(ft_strdup("COMMENT_CHARfirst"));
		addend_lbl_lst(&data->label, new_elem);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3858
leaq 0x6a55(%rip), %rdi      # 0xa28b
callq 0x5bb0
movq %rax, %rdi
callq 0x3da0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
callq 0x3e00
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d50
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3810
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x3190
movq -0x8(%rbp), %rdi
callq 0x50b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movl $0x20, %edi
callq 0x5560
cmpl $0x0, %eax
jle 0x3904
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x6230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x38e6
leaq 0x6845(%rip), %rdi      # 0xa126
callq 0x2580
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x3910
movq -0x20(%rbp), %rdi
callq 0x5780
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x5560
cmpl $0x0, %eax
jne 0x395e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4900
cmpl $0x1, %eax
jne 0x395e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3a20
jmp 0x3a15
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x5560
cmpl $0x1, %eax
jne 0x3995
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4900
cmpl $0x1, %eax
jne 0x3995
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b00
jmp 0x3a13
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x5560
cmpl $0x2, %eax
jne 0x39cc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4900
cmpl $0x1, %eax
jne 0x39cc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3c30
jmp 0x3a11
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x5560
cmpl $0x3, %eax
jle 0x3a05
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x5c60
cmpq $0x0, %rax
jne 0x3a05
movq -0x18(%rbp), %rdi
leaq 0x689f(%rip), %rsi      # 0xa29d
callq 0x2510
jmp 0x3a0f
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3a11
jmp 0x3a13
jmp 0x3a15
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x3a60
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3a46
cmpl $0x2, -0x28(%rbp)
jle 0x3a76
movq -0x10(%rbp), %rdi
leaq 0x682c(%rip), %rsi      # 0xa29d
callq 0x2510
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, %rdi
callq 0x3200
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4980
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x1c30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5890
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x37d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x3290
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, %rdi
callq 0x3200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4980
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1c30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5890
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6230
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3ba8
leaq 0x6583(%rip), %rdi      # 0xa126
callq 0x2580
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3bc3
movq -0x18(%rbp), %rdi
leaq 0x6632(%rip), %rsi      # 0xa1f0
callq 0x2510
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1c30
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58e0
movq %rax, %rdi
callq 0x5bb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
callq 0x37d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x3290
movq -0x30(%rbp), %rdi
callq 0x5780
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5bb0
movq %rax, %rdi
callq 0x3200
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4980
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1c30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5890
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0x6230
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x3cd8
leaq 0x6453(%rip), %rdi      # 0xa126
callq 0x2580
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3cee
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3cfe
movq -0x18(%rbp), %rdi
leaq 0x64f7(%rip), %rsi      # 0xa1f0
callq 0x2510
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1c30
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58e0
movq %rax, %rdi
callq 0x5bb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x1c30
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x58e0
movq %rax, %rdi
callq 0x5bb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0x37d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x3290
movq -0x30(%rbp), %rdi
callq 0x5780
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3dcc
leaq 0x635f(%rip), %rdi      # 0xa126
callq 0x2580
cmpq $0x0, -0x10(%rbp)
je 0x3df6
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/label_list_fct.c
// Function: addend_lbl_lst
void		addend_lbl_lst(t_label **lst, t_label *new_elem)
{
	t_label		*tmp;

	tmp = *lst;
	if (tmp == NULL)
		*lst = new_elem;
	else
	{
		while (tmp->next)
			tmp = tmp->next;
		tmp->next = new_elem;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3e2b
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3e4f
jmp 0x3e2d
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3e44
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e2d
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3eab
movl $0x5b, %edi
callq 0x64a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x64d0
leaq 0x641f(%rip), %rdi      # 0xa2b8
callq 0x64d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3e74
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x63e4(%rip), %rdi      # 0xa2bb
movb $0x0, %al
callq 0x6ba0
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x3f03
movq -0x10(%rbp), %rdi
leaq 0x6380(%rip), %rsi      # 0xa275
callq 0x5ce0
cmpl $0x0, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3f0c
jmp 0x3f27
leaq 0x63c9(%rip), %rdi      # 0xa2dc
movb $0x0, %al
callq 0x6ba0
xorl %edi, %edi
leaq -0x10(%rbp), %rsi
callq 0x65e0
jmp 0x3ede
movq -0x10(%rbp), %rdi
leaq 0x63c7(%rip), %rsi      # 0xa2f9
callq 0x5f80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2270
movq -0x18(%rbp), %rdi
callq 0x1030
leaq 0x639b(%rip), %rdi      # 0xa2fc
leaq 0x63c4(%rip), %rsi      # 0xa32c
movb $0x0, %al
callq 0x6ba0
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4011
jmp 0x3f9d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3fdb
movq -0x10(%rbp), %rdi
callq 0x4020
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x3f9d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3ff3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x3f94
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x404c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x406c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x408c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x40ac
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x40cc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/nm_cmt.c
// Function: check_quote_nm_cmt
int				check_quote_nm_cmt(t_data *data, char *str, char *cmd)
{
	int cont;

	cont = 0;
	if ((cont = is_in_str('"', str)) == 2 || cont == 1)
		return (cont);
	else
		error_str(data, "to many '\"' in ", cmd);
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rsi
movl $0x22, %edi
callq 0x5560
movl %eax, -0x24(%rbp)
cmpl $0x2, %eax
je 0x4117
cmpl $0x1, -0x24(%rbp)
jne 0x411f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x413a
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6223(%rip), %rsi      # 0xa351
callq 0x25b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x48d0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42f2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4230
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x58e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x42f2
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4252
cmpl $0x1, -0x1c(%rbp)
jne 0x4252
movq -0x8(%rbp), %rdi
leaq 0x6116(%rip), %rsi      # 0xa361
callq 0x2510
jmp 0x426e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x426c
movq -0x8(%rbp), %rdi
leaq 0x610f(%rip), %rsi      # 0xa376
callq 0x2510
jmp 0x426e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5b70
movl -0x20(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x42a2
cmpl $0x1, -0x1c(%rbp)
jne 0x42a2
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %ecx
leaq 0x60f7(%rip), %rsi      # 0xa38e
xorl %eax, %eax
movl %eax, %edx
callq 0x2630
jmp 0x42d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5b70
movl -0x20(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x42ce
movq -0x8(%rbp), %rdi
movl -0x20(%rbp), %ecx
leaq 0x60f0(%rip), %rsi      # 0xa3b5
xorl %eax, %eax
movl %eax, %edx
callq 0x2630
jmp 0x42d0
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x4150
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5c10
jmp 0x4337
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x430b
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x4150
jmp 0x4335
cmpl $0x1, -0x1c(%rbp)
jne 0x4323
movq -0x8(%rbp), %rdi
leaq 0x60c3(%rip), %rsi      # 0xa3df
callq 0x2510
jmp 0x4333
movq -0x8(%rbp), %rdi
leaq 0x60cb(%rip), %rsi      # 0xa3f9
callq 0x2510
jmp 0x4335
jmp 0x4337
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %edi
callq 0x48a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x58e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %edi
callq 0x48d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x4350
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5b70
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x5d60
cmpl $0x0, %eax
jne 0x44f2
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5b70
movq -0x50(%rbp), %rdi
addq %rax, %rdi
callq 0x58e0
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x44f2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x40e0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl $0x22, %esi
callq 0x6230
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x41b0
movl %eax, -0x20(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x44cc
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x44cc
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x28(%rbp), %eax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5b70
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movl %eax, %edx
movl -0x1c(%rbp), %ecx
callq 0x47b0
jmp 0x44e7
cmpl $0x1, -0x24(%rbp)
jne 0x44e5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x47b0
jmp 0x44e7
movq -0x30(%rbp), %rdi
callq 0x5780
jmp 0x455b
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5b70
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x5d60
cmpl $0x0, %eax
jne 0x4559
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5b70
movq -0x80(%rbp), %rdi
addq %rax, %rdi
callq 0x58e0
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x4559
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x5ec2(%rip), %rsi      # 0xa416
callq 0x25b0
jmp 0x455b
movl -0x20(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
addq $0x1, %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x45a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4613
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x5b3d(%rip), %rsi      # 0xa0ec
callq 0x5f80
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5b70
cmpq $0x0, %rax
je 0x45f3
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f80
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x5c10
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x4603
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x5c10
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x22, %edi
callq 0x5560
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x465b
jmp 0x4728
cmpl $0x1, -0x34(%rbp)
jne 0x4728
movq -0x28(%rbp), %rdi
movl $0x22, %esi
callq 0x6230
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x46e8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x46cc
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5b70
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x46e8
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x4570
movl %eax, -0x38(%rbp)
jmp 0x470e
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x470c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x5b71(%rip), %rsi      # 0xa275
callq 0x4570
movl %eax, -0x38(%rbp)
jmp 0x470e
movq -0x30(%rbp), %rdi
callq 0x5780
cmpl $-0x1, -0x38(%rbp)
jne 0x4726
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47a2
jmp 0x4728
cmpl $0x0, -0x34(%rbp)
jne 0x479c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x4570
movl %eax, -0x38(%rbp)
cmpl $-0x1, -0x38(%rbp)
jne 0x4754
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47a2
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movslq 0x4(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5b70
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq $0x1, %rcx
subq %rcx, %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
callq 0x47b0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x65e0
cmpl $0x0, %eax
jl 0x4894
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4620
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x483d
cmpl $0x1, -0x18(%rbp)
jne 0x483d
movq -0x8(%rbp), %rdi
leaq 0x5b58(%rip), %rsi      # 0xa38e
callq 0x2510
jmp 0x4855
cmpl $-0x1, -0x24(%rbp)
jne 0x4853
movq -0x8(%rbp), %rdi
leaq 0x5b67(%rip), %rsi      # 0xa3b5
callq 0x2510
jmp 0x4855
cmpl $0x2, -0x24(%rbp)
jl 0x4873
cmpl $0x1, -0x18(%rbp)
jne 0x4873
movq -0x8(%rbp), %rdi
leaq 0x5bc5(%rip), %rsi      # 0xa431
callq 0x2510
jmp 0x488b
cmpl $0x2, -0x24(%rbp)
jl 0x4889
movq -0x8(%rbp), %rdi
leaq 0x5bc1(%rip), %rsi      # 0xa445
callq 0x2510
jmp 0x488b
movq -0x20(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/opcode_check.c
// Function: check_opcode_name
int		check_opcode_name(char *str)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9742(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4962
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x9726(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x5ce0
cmpl $0x0, %eax
jne 0x4957
movl $0x1, -0x4(%rbp)
jmp 0x4969
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4913
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x96be(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x4a03
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x96a2(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x5ce0
cmpl $0x0, %eax
jne 0x49f8
movslq -0x1c(%rbp), %rcx
leaq 0x9683(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsbl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4a0a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4997
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/parser.c
// Function: read_name_comment
int		read_name_comment(t_data *data, char *str)
{
	int		ret;

	ret = 0;
	if ((ret = parse_nm_cmt(data, &data->name, str, 1)) == 0)
		ret = parse_nm_cmt(data, &data->comment, str, 2);
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
callq 0x43b0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x4a76
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdx
movl $0x2, %ecx
callq 0x43b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x57dc(%rip), %rsi      # 0xa273
callq 0x5670
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x57c3(%rip), %rsi      # 0xa275
callq 0x5ce0
cmpl $0x0, %eax
jne 0x4ac5
movl $0x1, -0xc(%rbp)
jmp 0x4ada
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x4ad8
movl $0x1, -0xc(%rbp)
jmp 0x4ada
movq -0x8(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x4b32
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x4b3b
jmp 0x4b46
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b07
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x4b9c
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x58e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b70
cmpq $0x0, %rax
jbe 0x4b9a
movq -0x10(%rbp), %rdi
callq 0x5bb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4ba3
jmp 0x4b9c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a80
cmpl $0x0, %eax
je 0x4bd3
jmp 0x4c89
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a20
cmpl $0x0, %eax
je 0x4bea
jmp 0x4c87
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3630
cmpl $0x0, %eax
je 0x4c35
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4af0
cmpl $0x0, %eax
je 0x4c23
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3860
cmpq $0x0, -0x20(%rbp)
je 0x4c33
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x4c85
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3860
cmpl $0x0, %eax
je 0x4c49
jmp 0x4c83
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4c71
movq -0x18(%rbp), %rdi
leaq 0x58e3(%rip), %rsi      # 0xa541
callq 0x5ce0
cmpl $0x0, %eax
jne 0x4c71
movl $0x0, -0x4(%rbp)
jmp 0x4c90
movq -0x10(%rbp), %rdi
leaq 0x58ca(%rip), %rsi      # 0xa546
callq 0x2510
jmp 0x4c83
jmp 0x4c85
jmp 0x4c87
jmp 0x4c89
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x4ced
movq $0x0, -0x10(%rbp)
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x15(%rbp)
jne 0x4cd4
jmp 0x4ced
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x10(%rbp), %rsi
callq 0x65e0
cmpl $0x0, %eax
setg %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x4cf6
jmp 0x4d1e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4bb0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
jmp 0x4cb3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4d40
xorl %eax, %eax
movl %eax, %edi
leaq 0x5820(%rip), %rsi      # 0xa554
leaq 0x56b8(%rip), %rdx      # 0xa3f3
callq 0x25b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4d62
xorl %eax, %eax
movl %eax, %edi
leaq 0x57fe(%rip), %rsi      # 0xa554
leaq 0x56b0(%rip), %rdx      # 0xa40d
callq 0x25b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movslq 0x50(%rax), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x4db6
leaq 0x5375(%rip), %rdi      # 0xa126
callq 0x2580
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x50(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4df3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4dbd
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x4ec9
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4e5f
leaq 0x541b(%rip), %rdi      # 0xa275
callq 0x6510
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4e8d
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x56df(%rip), %rdi      # 0xa565
movb $0x0, %al
callq 0x6ba0
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x4ebb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x56b6(%rip), %rdi      # 0xa56a
movb $0x0, %al
callq 0x6ba0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e33
leaq 0x53a5(%rip), %rdi      # 0xa275
callq 0x6510
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)