LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%r13)
movq (%rdi), %rdi
callq 0x3ef8
movq %rax, %rdi
callq 0x2560
movq %rax, %r14
movq (%r12), %rdi
movq %rax, %rsi
callq 0x349e
movq 0x8(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x1918
movq 0x8(%r12), %rdi
callq 0x3d40
movq %rax, 0x18(%r14)
pushq $0x2c
popq %rsi
movq %r15, %rdi
callq 0x418c
movq %rax, %r15
testq %rax, %rax
jne 0x2c95
leaq 0x3496(%rip), %rdi      # 0x6126
callq 0x1e85
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2ca5
cmpq $0x0, 0x10(%r15)
jne 0x2cb8
leaq 0x3544(%rip), %rsi      # 0x61f0
movq %rbx, %rdi
callq 0x1e39
movq 0x8(%r15), %rdi
leaq 0xc(%rsp), %r12
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x1918
movq 0x8(%r15), %rdi
callq 0x3d6d
movq %rax, %rdi
callq 0x3ef8
movq %rax, 0x20(%r14)
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x1918
movq 0x10(%r15), %rdi
callq 0x3d6d
movq %rax, %rdi
callq 0x3ef8
movq %rax, 0x28(%r14)
movq %rbx, %rdi
callq 0x28a5
leaq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x25ac
movq %r15, %rdi
callq 0x3cdf
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x1060
movq %rax, %rbx
testq %rax, %rax
je 0x2d57
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r14, 0x10(%rbx)
jmp 0x2d63
leaq 0x33c8(%rip), %rdi      # 0x6126
callq 0x1e85
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x5b
popq %rbp
leaq 0x3525(%rip), %r14      # 0x62b8
testq %rbx, %rbx
je 0x2db5
movl %ebp, %edi
callq 0x4284
movq 0x10(%rbx), %rdi
callq 0x429c
movq %r14, %rdi
callq 0x429c
movq (%rbx), %rbx
jmp 0x2d93
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x34dd(%rip), %rdi      # 0x62bb
xorl %eax, %eax
callq 0x45d4
leaq 0x34f0(%rip), %r15      # 0x62dc
leaq 0x3482(%rip), %r12      # 0x6275
testq %r13, %r13
je 0x2e07
movq %r13, %rdi
movq %r12, %rsi
callq 0x3f68
testl %eax, %eax
jne 0x2e22
movq %r15, %rdi
xorl %eax, %eax
callq 0x45d4
xorl %edi, %edi
movq %r14, %rsi
callq 0x4310
movq 0x8(%rsp), %r13
jmp 0x2df3
movq 0x8(%rsp), %rdi
leaq 0x34cb(%rip), %rsi      # 0x62f9
callq 0x4054
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ccb
movq %r14, %rdi
callq 0x1030
leaq 0x34a2(%rip), %rdi      # 0x62fc
leaq 0x34cb(%rip), %rsi      # 0x632c
xorl %eax, %eax
callq 0x45d4
andl $0x0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x2ec2
cmpq $0x0, 0x8(%rbx)
je 0x2ea9
movq %rbx, %rdi
callq 0x2eca
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x1030
jmp 0x2e88
movq 0x10(%rbx), %rdi
callq 0x1030
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x2e83
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq 0x30(%rax), %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x3456
cmpq $0x0, 0x8(%r14)
je 0x2ffa
movl %eax, 0x4(%rsp)
movq %r15, %rbx
movq 0x10(%r14), %r13
testq %r13, %r13
je 0x3009
movq %r13, %rdi
callq 0x3ee8
movq %rax, %r15
addq %r13, %r15
movq 0x10(%r14), %rdi
callq 0x3d6d
cmpq %rax, %r15
je 0x3009
cmpq $0x0, 0x8(%r14)
movl 0x4(%rsp), %eax
je 0x2ffa
movq %rbx, %rdi
cmpl $0x1, %r12d
jne 0x3097
leaq 0x33ea(%rip), %rsi      # 0x63df
jmp 0x309e
movq %rbp, %rdi
movl %eax, %esi
callq 0x2f48
jmp 0x30a3
cmpq $0x0, (%rbp)
movq %rbx, %r13
je 0x3031
cmpl $0x1, %r12d
leaq 0x3343(%rip), %rax      # 0x6361
leaq 0x3351(%rip), %rsi      # 0x6376
cmoveq %rax, %rsi
movq %r13, %rdi
callq 0x1e39
movq 0x8(%r14), %rdi
callq 0x3ee8
movl 0x4(%rsp), %r15d
cmpl $0x1, %r12d
movq %rbp, %rbx
jne 0x305a
cmpq %r15, %rax
jbe 0x305a
leaq 0x333a(%rip), %rsi      # 0x638e
movl 0x4(%rsp), %ebp
jmp 0x3073
movq 0x8(%r14), %rdi
callq 0x3ee8
cmpq %r15, %rax
movl 0x4(%rsp), %ebp
jbe 0x307f
leaq 0x3342(%rip), %rsi      # 0x63b5
movq %r13, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x1ef4
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2f48
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x3f20
jmp 0x30a3
leaq 0x335b(%rip), %rsi      # 0x63f9
callq 0x1e39
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rdi)
movl %esi, %edi
callq 0x3440
movq %rax, (%r14)
movq (%rbx), %rdi
callq 0x3d6d
movq %rax, (%rbx)
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3456
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x28, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %r12
movq %rdx, (%r12)
leaq 0x4(%rsp), %rdi
leaq 0x18(%rsp), %rbx
movl %ecx, %esi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x30b5
movl %eax, %r15d
movq (%r12), %r13
movq (%rbx), %r12
movq %r12, %rdi
callq 0x3ee8
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3f84
testl %eax, %eax
jne 0x31cc
movq %r12, %rdi
callq 0x3ee8
leaq (%rax,%r13), %rdi
callq 0x3d6d
cmpb $0x22, (%rax)
jne 0x31cc
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2f10
movl %eax, 0x14(%rsp)
pushq $0x22
popq %rsi
movq %r13, %rdi
callq 0x418c
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
callq 0x2f85
movl $0x1, 0x4(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0x31c2
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x31b0
callq 0x3ee8
subl %eax, %r15d
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x33a2
movq %r12, %rdi
callq 0x3cdf
jmp 0x3212
movq %r12, %rdi
callq 0x3ee8
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3f84
testl %eax, %eax
jne 0x3212
movq %r12, %rdi
callq 0x3ee8
addq %rax, %r13
movq %r13, %rdi
callq 0x3d6d
cmpb $0x22, (%rax)
je 0x3212
leaq 0x3211(%rip), %rsi      # 0x6416
movq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x1e96
movl 0x4(%rsp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3ee8
incq %rax
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0x324d
pushq $-0x1
jmp 0x32a4
movq (%rbx), %rdi
leaq 0x2e95(%rip), %rsi      # 0x60ec
callq 0x4054
movq %rax, %r14
movq %r15, %rdi
callq 0x3ee8
testq %rax, %rax
je 0x328f
movq %r14, %rdi
movq %r15, %rsi
callq 0x4054
movq %rax, %r15
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x3f20
movq %r15, %rdi
callq 0x1030
jmp 0x329a
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x3f20
movq %r14, %rdi
callq 0x1030
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x22
popq %rdi
movq %rcx, %rsi
callq 0x3be8
testl %eax, %eax
je 0x3331
cmpl $0x1, %eax
jne 0x3393
pushq $0x22
popq %rsi
movq %r15, %rdi
callq 0x418c
movq %rax, %r15
movq (%rax), %rsi
testq %rsi, %rsi
je 0x3324
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x3369
movq %r12, %rdi
callq 0x3ee8
movq %rax, %r13
addq %r12, %r13
movq 0x8(%r15), %rdi
callq 0x3d6d
movq (%r15), %rsi
cmpq %rax, %r13
je 0x3369
xorl %ebp, %ebp
testq %rsi, %rsi
jne 0x3377
movl 0x4(%r14), %edx
leaq 0x2f46(%rip), %rsi      # 0x6275
jmp 0x336d
movl 0x4(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3228
cmpl $-0x1, %eax
je 0x3390
movl 0x4(%r14), %ebp
movq %r15, %rdi
callq 0x3ee8
notl %eax
addl %eax, %ebp
movl (%r14), %ecx
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x33a2
xorl %eax, %eax
jmp 0x3393
movl 0x4(%r14), %edx
movq %rbx, %rdi
callq 0x3228
movl %eax, %ebp
movq %r15, %rdi
callq 0x3cdf
xorl %eax, %eax
cmpl $-0x1, %ebp
setne %al
leal -0x1(,%rax,2), %eax
jmp 0x3393
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsp, %rsi
andq $0x0, (%rsi)
movq %rdi, %rbx
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movl 0x8(%rdi), %edi
callq 0x4310
testl %eax, %eax
js 0x3437
incl 0x40(%rbx)
movq (%rsp), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
cmpl $-0x1, %eax
leaq 0x2fa0(%rip), %rsi      # 0x638e
leaq 0x2fc0(%rip), %rcx      # 0x63b5
cmovneq %rcx, %rsi
cmpl $0x1, %ebp
cmovneq %rcx, %rsi
cmpl $-0x1, %eax
je 0x3426
cmpl $0x2, %eax
leaq 0x3022(%rip), %rsi      # 0x6431
leaq 0x302f(%rip), %rcx      # 0x6445
cmovlq %rcx, %rsi
cmpl $0x1, %ebp
cmovneq %rcx, %rsi
cmpl $0x2, %eax
jl 0x342e
movq %rbx, %rdi
callq 0x1e39
movq (%rsp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d4b(%rip), %rsi      # 0x6273
callq 0x3c4f
movq %rax, %rbx
leaq 0x2d3e(%rip), %rsi      # 0x6275
movq %rax, %rdi
callq 0x3f68
testl %eax, %eax
je 0x354e
xorl %ebp, %ebp
cmpb $0x23, (%rbx)
sete %bpl
jmp 0x3551
pushq $0x1
popq %rbp
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x359e
cmpl $0x3a, %eax
jne 0x3569
callq 0x3d6d
movq %rax, %r14
movq %rax, %rdi
callq 0x3ee8
testq %rax, %rax
je 0x359e
movq %r14, %rdi
callq 0x3ef8
movq %rax, (%rbx)
pushq $0x1
popq %rax
jmp 0x35a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x351e
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0x364f
movq %r14, %rdi
movq %r15, %rsi
callq 0x34e0
testl %eax, %eax
jne 0x364f
movq %r15, %rdi
movq %r14, %rsi
callq 0x275c
testl %eax, %eax
je 0x3617
movq %rsp, %r12
andq $0x0, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3562
movq (%r12), %r15
testl %eax, %eax
je 0x360d
movq %r15, %rdi
movq %r14, %rsi
callq 0x28ed
movq %r15, %rdi
callq 0x1030
jmp 0x364f
movq %r15, %rdi
movq %r14, %rsi
callq 0x28ed
testl %eax, %eax
jne 0x364f
cmpl $0x0, 0x8(%r14)
jne 0x3640
leaq 0x2f0d(%rip), %rsi      # 0x6541
movq %r15, %rdi
callq 0x3f68
testl %eax, %eax
je 0x365d
leaq 0x2eff(%rip), %rsi      # 0x6546
movq %r14, %rdi
callq 0x1e39
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x364f
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r14
testl %ebp, %ebp
je 0x36ab
andq $0x0, 0x8(%rsp)
movl 0x8(%rbx), %edi
movq %r14, %rsi
callq 0x4310
testl %eax, %eax
jle 0x36ab
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x35a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0x1030
incl 0x40(%rbx)
jmp 0x3674
cmpq $0x0, 0x18(%rbx)
jne 0x36c7
leaq 0x2e9b(%rip), %rsi      # 0x6554
leaq 0x2d33(%rip), %rdx      # 0x63f3
xorl %edi, %edi
callq 0x1e96
cmpq $0x0, 0x20(%rbx)
jne 0x36e3
leaq 0x2e7f(%rip), %rsi      # 0x6554
leaq 0x2d31(%rip), %rdx      # 0x640d
xorl %edi, %edi
callq 0x1e96
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %r15, %rdi
incq %rdi
movl %edi, 0x50(%rbx)
callq 0x1060
movq %rax, %r14
testq %rax, %rax
jne 0x3725
leaq 0x2a0d(%rip), %rdi      # 0x6126
callq 0x1e85
movl 0x50(%rbx), %r15d
decl %r15d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x3743
movq 0x48(%rbx), %rcx
movb (%rcx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x372e
movb %bpl, (%r14,%r15)
movq 0x48(%rbx), %rdi
callq 0x1030
movq %r14, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2b03(%rip), %r14      # 0x6275
leaq 0x2dec(%rip), %r15      # 0x6565
leaq 0x2dea(%rip), %r12      # 0x656a
xorl %r13d, %r13d
movslq 0x50(%rbx), %rax
cmpq %rax, %r13
jge 0x37ba
testb $0xf, %r13b
jne 0x379a
movq %r14, %rdi
callq 0x42b4
testb $0x1, %r13b
movq 0x48(%rbx), %rax
movzbl (%rax,%r13), %esi
movq %r12, %rdi
cmoveq %r15, %rdi
xorl %eax, %eax
callq 0x45d4
incq %r13
jmp 0x3783
leaq 0x2ab4(%rip), %rdi      # 0x6275
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42b4
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %r15, %rdi
incq %rdi
movl %edi, (%rsi)
callq 0x1060
movq %rax, %r14
testq %rax, %rax
jne 0x3800
leaq 0x292b(%rip), %rdi      # 0x6126
callq 0x1e85
xorl %eax, %eax
testl %r15d, %r15d
movl $0x0, %ecx
cmovgl %r15d, %ecx
cmpq %rax, %rcx
je 0x3822
movq (%rbx), %rdx
movb (%rdx,%rax), %dl
movb %dl, (%r14,%rax)
incq %rax
jmp 0x380e
movb %bpl, (%r14,%rcx)
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/real_trim.c
// Function: next_word
int		next_word(char **buf, int *buf_len, char *str, int i)
{
	int		space;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
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 0x386e
cmpl $0x20, %ecx
jne 0x3875
incl %ebx
incq %r12
jmp 0x385e
pushq $0x20
popq %rbp
movabsq $0x100000201, %r13      # imm = 0x100000201
cmpb $0x20, %cl
ja 0x3890
movzbl %cl, %edx
btq %rdx, %r13
jb 0x38c1
testb $0x1, %al
jne 0x38a6
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x37d0
movb -0x1(%r12), %cl
movsbl %cl, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x37d0
movb (%r12), %cl
incl %ebx
incq %r12
movb $0x1, %al
jmp 0x3882
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x4(%rsp)
andq $0x0, 0x8(%rsp)
xorl %eax, %eax
testq %rdi, %rdi
je 0x392c
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
je 0x3915
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x383c
jmp 0x38fa
leaq 0x8(%rsp), %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x37d0
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x3975
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18ad
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x123d
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3982
incq %r14
movq %r14, %rdi
callq 0x3fd0
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 0x36ec
movl $0xff, %r12d
andl %r12d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x36ec
andl %r12d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x36ec
andl %r12d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36ec
// File: /workspace/github_c_makefile_star2_O2/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 0x3a0e
movl %ecx, %ebp
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18ad
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x123d
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3a18
movq %r14, %rdi
callq 0x3fd0
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x36ec
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36ec
// File: /workspace/github_c_makefile_star2_O2/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 0x3a9c
movl %ecx, %ebp
addq $0x2, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18ad
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x123d
movl %eax, %ebp
imull %r15d, %ebp
jmp 0x3aa9
incq %r14
movq %r14, %rdi
callq 0x3fd0
movl %eax, %ebp
movl %ebp, %esi
shrl $0x8, %esi
movl $0xff, %r14d
andl %r14d, %esi
movq %rbx, %rdi
callq 0x36ec
andl %r14d, %ebp
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36ec
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/src/asm/tools.c
// Function: rm_char
char	*rm_char(char *str, char *rem)
{
	char	*ret;
	int		len;
	int		i;
	int		j;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq %rdi, %r15
movb (%r15), %al
testb %al, %al
je 0x3c81
movsbl %al, %edi
movq %rbx, %rsi
callq 0x3be8
cmpl $0x1, %eax
adcl $0x0, %r12d
incq %r15
jmp 0x3c63
incl %r12d
movq %r12, %rdi
callq 0x1060
movq %rax, %r15
testq %rax, %rax
jne 0x3ca0
leaq 0x248b(%rip), %rdi      # 0x6126
callq 0x1e85
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ed0
xorl %ebp, %ebp
movb (%r14), %r12b
testb %r12b, %r12b
je 0x3cd3
movsbl %r12b, %edi
movq %rbx, %rsi
callq 0x3be8
testl %eax, %eax
jne 0x3cce
movslq %ebp, %rax
incl %ebp
movb %r12b, (%r15,%rax)
incq %r14
jmp 0x3cad
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d3e
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
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2c
popq %rsi
callq 0x418c
movq %rax, %rbx
movq (%rax), %rdi
callq 0x3ef8
movq %rax, %r14
movq %rbx, %rdi
callq 0x3cdf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3def
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
leaq 0x27d5(%rip), %r14      # 0x6570
leaq 0x2651(%rip), %rsi      # 0x63f3
movq %r14, %rdi
xorl %eax, %eax
callq 0x45d4
movq 0x20(%rbx), %rdx
leaq 0x2656(%rip), %rsi      # 0x640d
movq %r14, %rdi
xorl %eax, %eax
callq 0x45d4
movl 0x50(%rbx), %esi
leaq 0x27b9(%rip), %rdi      # 0x6584
xorl %eax, %eax
callq 0x45d4
leaq 0x27d1(%rip), %rdi      # 0x65aa
xorl %eax, %eax
callq 0x45d4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x375f
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1d60
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
movl $0x80, %edx
callq 0x1c33
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movsbl 0x53(%rbx), %esi
movq %rbx, %rdi
callq 0x1bc0
movsbl 0x52(%rbx), %esi
movq %rbx, %rdi
callq 0x1bc0
movsbl 0x51(%rbx), %esi
movq %rbx, %rdi
callq 0x1bc0
movsbl 0x50(%rbx), %esi
movq %rbx, %rdi
callq 0x1bc0
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
movl $0x800, %edx            # imm = 0x800
callq 0x1c33
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1bc0
movq 0x48(%rbx), %rsi
movl 0x50(%rbx), %edx
movq %rbx, %rdi
callq 0x1c33
movq %rbx, %rdi
callq 0x3d84
cmpl $0x0, 0x4(%rbx)
je 0x3eba
popq %rbx
retq
leaq 0x270e(%rip), %rdi      # 0x65cf
callq 0x429c
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x42b4
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_bzero.c
// Function: ft_bzero
void	ft_bzero(void *s, size_t n)
{
	if (n == 0)
		return ;
	while (n--)
		*(char *)s++ = 0;
}

// Assembly:
testq %rsi, %rsi
je 0x3ee5
xorl %eax, %eax
cmpq %rax, %rsi
je 0x3ee5
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x3ed7
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
movb (%rsi,%rcx), %dl
testb %dl, %dl
je 0x3f34
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x3f25
movb $0x0, (%rax,%rcx)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strchr.c
// Function: ft_strchr
char	*ft_strchr(const char *s, int c)
{
	if (s == NULL)
		return (NULL);
	while (*s)
		if (*s++ == (unsigned char)c)
			return ((char *)s - 1);
	return ((unsigned char)c == '\0' ? (char*)s : NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x3f5a
movzbl %sil, %ecx
movsbl (%rdi), %eax
testl %eax, %eax
je 0x3f5d
incq %rdi
cmpl %eax, %ecx
jne 0x3f45
decq %rdi
movq %rdi, %rax
retq
xorl %eax, %eax
retq
xorl %eax, %eax
testl %ecx, %ecx
cmoveq %rdi, %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(const char *s1, const char *s2)
{
	unsigned char	*t1;
	unsigned char	*t2;

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

// Assembly:
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %edx
cmpb %dl, %al
jne 0x3f80
incq %rcx
testl %eax, %eax
jne 0x3f6a
xorl %eax, %eax
retq
subl %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strncmp.c
// Function: ft_strncmp
int		ft_strncmp(const char *s1, const char *s2, size_t n)
{
	if (s1 == NULL || s2 == NULL || n == 0)
		return (0);
	while (n--)
		if (*(unsigned char *)s1++ != *(unsigned char *)s2++ || *s2 == 0)
			return (*(unsigned char *)--s1 - *(unsigned char *)--s2);
	return (0);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x3fce
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x3fce
movb (%rdi,%rcx), %r8b
movb (%rsi,%rcx), %r9b
cmpb %r9b, %r8b
jne 0x3fc4
cmpb $0x0, 0x1(%rsi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x3fa4
movl %r8d, %r9d
movzbl %r8b, %eax
movzbl %r9b, %ecx
subl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_atoi.c
// Function: ft_atoi
int			ft_atoi(const char *str)
{
	int	value;
	int	is_neg;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movabsq $0x100003e00, %rcx      # imm = 0x100003E00
movzbl (%rbx), %eax
cmpq $0x2d, %rax
ja 0x4019
btq %rax, %rcx
jae 0x3ff5
incq %rbx
jmp 0x3fe1
movabsq $0x280000000000, %rcx   # imm = 0x280000000000
btq %rax, %rcx
jae 0x4019
incq %rbx
xorl %ecx, %ecx
cmpb $0x2b, %al
sete %cl
leal -0x1(,%rcx,2), %r14d
jmp 0x401d
pushq $0x1
popq %r14
xorl %ebp, %ebp
movsbl (%rbx), %edi
callq 0x4048
testl %eax, %eax
je 0x403c
imull $0xa, %ebp, %eax
movsbl (%rbx), %ecx
incq %rbx
leal (%rax,%rcx), %ebp
addl $-0x30, %ebp
jmp 0x401f
imull %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*join;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
jne 0x406d
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x40bc
testq %rbx, %rbx
je 0x40c1
movq %r14, %rdi
callq 0x3ee8
movq %rax, %r15
movq %rbx, %rdi
callq 0x3ee8
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1060
testq %rax, %rax
je 0x4061
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x3f20
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4844
jmp 0x4064
movq %rbx, %rdi
jmp 0x40c4
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3ef8
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strtrim.c
// Function: ft_strtrim
char		*ft_strtrim(char const *s)
{
	char	*start;
	char	*end;
	char	*trim;
	size_t	parser;

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

// Assembly:
testq %rdi, %rdi
je 0x413d
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rdi, %r14
negq %r14
movabsq $0x100000600, %rax      # imm = 0x100000600
movq %rdi, %r15
movzbl (%r15), %ecx
cmpq $0x20, %rcx
ja 0x4108
btq %rcx, %rax
jae 0x4108
incq %r15
decq %r14
jmp 0x40f0
xorl %eax, %eax
cmpb $0x0, (%rbx,%rax)
leaq 0x1(%rax), %rax
jne 0x410a
xorl %edx, %edx
movabsq $0x100000601, %rcx      # imm = 0x100000601
cmpb $0x20, %dl
ja 0x4140
movzbl %dl, %edx
btq %rdx, %rcx
jae 0x4140
cmpq $0x1, %rax
je 0x4146
movb -0x2(%rbx,%rax), %dl
decq %rax
jmp 0x4120
xorl %eax, %eax
retq
addq %rax, %rbx
decq %rbx
movq %rbx, %rax
addq %r14, %rax
cmovsq %r15, %rbx
leaq (%rbx,%r14), %rdi
incq %rdi
callq 0x1060
testq %rax, %rax
je 0x4184
leaq (%rbx,%r14), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
ja 0x4179
movb (%r15,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x4167
addq %rax, %rbx
movb $0x0, 0x1(%r14,%rbx)
jmp 0x4186
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/ft_strsplit.c
// Function: ft_strsplit
char			**ft_strsplit(char const *s, char c)
{
	char	*str;
	char	**tab;
	int		i;
	int		word;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x4262
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %cl
movq %rdi, %rax
testb %cl, %cl
je 0x41e5
decq %rax
movq %rax, %rdx
movq %rdx, %rax
movb 0x1(%rdx), %sil
cmpb %bl, %sil
je 0x41cc
leaq 0x1(%rax), %rdx
testb %sil, %sil
jne 0x41b7
movb 0x1(%rax), %dl
incq %rax
cmpb %bl, %dl
je 0x41cc
xorl %esi, %esi
cmpb %bl, %cl
setne %sil
addl %esi, %r12d
movl %edx, %ecx
jmp 0x41ad
movl %r12d, %eax
leaq 0x8(,%rax,8), %rdi
callq 0x1060
testq %rax, %rax
je 0x4262
movq %rax, %r15
xorl %r13d, %r13d
movl %r12d, %ebp
subl $0x1, %ebp
jb 0x426a
leaq -0x1(%r14), %rdi
incq %r14
movq %r14, %rdx
movq %rdi, %r14
movq %rdx, %rax
incq %rdi
movb 0x1(%r14), %cl
incq %rdx
cmpb %bl, %cl
je 0x4212
testb %cl, %cl
je 0x4267
xorl %edx, %edx
testb %cl, %cl
je 0x423e
cmpb %bl, %cl
je 0x423e
movb (%rax), %cl
incq %rdx
incq %rax
jmp 0x422c
xorl %esi, %esi
callq 0x48b8
movq %rax, (%r15,%r13,8)
testq %rax, %rax
je 0x4262
incq %r13
movb 0x1(%r14), %al
incq %r14
cmpb %bl, %al
je 0x4203
testb %al, %al
jne 0x4251
jmp 0x4203
xorl %r15d, %r15d
jmp 0x4272
movl %r13d, %r12d
movl %r12d, %eax
andq $0x0, (%r15,%rax,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/get_next_line.c
// Function: found_fd
static int	found_fd(t_file **file, int fd)
{
	if (*file != NULL)
	{
		while ((*file)->next != NULL && (*file)->fd != fd)
			*file = (*file)->next;
		if ((*file)->fd == fd)
			return (1);
	}
	return (0);
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x45d0
movl (%rax), %ecx
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x45c8
cmpl %esi, %ecx
je 0x45c8
movq %rax, (%rdi)
jmp 0x45b4
cmpl %esi, %ecx
jne 0x45d0
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: ft_printf
int			ft_printf(const char *format, ...)
{
	va_list args;
	int		count;
	int		error;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x30(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x463c
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
leaq 0x10(%rsp), %rbx
movq %r10, 0x10(%rbx)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rbx)
callq 0x3ef8
movq %rax, %r14
movq %rax, %rdi
callq 0x4730
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
movl %eax, 0x4(%rsp)
movslq %eax, %rdi
cmpb $0x0, (%r14,%rdi)
je 0x46f2
addq %r14, %rdi
movq %rdi, 0x8(%rsp)
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x4748
testq %rax, %rax
je 0x46ff
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x4054
movq %rax, %rbp
movq %r13, %rdi
callq 0x1030
movq 0x8(%rsp), %rsi
movq %rbp, %rdi
callq 0x4054
movq %rax, %r13
movq %r14, %rdi
callq 0x1030
movq %rbp, %rdi
callq 0x1030
movslq 0x4(%rsp), %r14
movq %r13, %rdi
addq %r14, %rdi
callq 0x4730
addl %r14d, %eax
movq %r13, %r14
jmp 0x4678
movq %r14, %rdi
callq 0x3ee8
movq %rax, %rbx
jmp 0x470c
movslq 0x4(%rsp), %rax
movb $0x0, (%r14,%rax)
pushq $-0x1
popq %rbx
movq %r14, %rdi
callq 0x49b0
movq %r14, %rdi
callq 0x1030
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/printf/ft_printf.c
// Function: get_next_precent_position
static int	get_next_precent_position(char *str)
{
	int		i;

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

// Assembly:
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
testl %ecx, %ecx
je 0x4744
cmpl $0x25, %ecx
je 0x4744
incq %rax
jmp 0x4732
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Orycterope[P]corewar/libft/printf/get_string.c
// Function: get_processed_str
char		*get_processed_str(char *str, va_list args, int *length, char **end)
{
	char			*processed_str;
	long long		argument;
	t_conversion	*conv;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
cmpb $0x25, 0x1(%rdi)
jne 0x4780
movq (%rbx), %rax
movb $0x0, (%rax)
incl (%r14)
addq $0x2, (%rbx)
leaq 0x1e7a(%rip), %rdi      # 0x65ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ef8
movq %rsi, %r12
callq 0x52d0
testq %rax, %rax
je 0x47b9
movq %rax, %r15
cmpb $0x0, 0x20(%rax)
je 0x47be
movq %r12, %rdi
movq %r15, %rsi
callq 0x4a3c
movq %rax, %rdi
movq %r15, %rsi
callq 0x4cc8
movq %rax, %rdi
movq %r15, %rsi
callq 0x5218
jmp 0x47cf
xorl %r12d, %r12d
jmp 0x4802
movq (%rbx), %rax
movslq 0x24(%r15), %rcx
movsbl -0x1(%rax,%rcx), %edi
callq 0x4a2c
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f3c
movq %rax, %r12
testq %rax, %rax
je 0x47fa
movq (%rbx), %rax
movb $0x0, (%rax)
movq %r12, %rdi
callq 0x3ee8
addl %eax, (%r14)
movslq 0x24(%r15), %rax
addq %rax, (%rbx)
movq %r15, %rdi
callq 0x5393
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)