LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/check_inst_param.c
// Function: check_params
void	check_params(char *str, t_instruc *inst, t_data *data, int *order)
{
	int		i;

	i = 0;
	inst->trim = ft_strtrim(str);
	while (g_op[i].name != 0)
	{
		if (inst->opcode == g_op[i].op_code)
		{
			if (g_op[i].param_nbr == 1)
				if_one_param(i, data, inst, order);
			else if (g_op[i].param_nbr == 2)
				if_two_params(i, data, inst, order);
			else if (g_op[i].param_nbr == 3)
				if_three_params(i, data, inst, order);
		}
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6050
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movslq -0x24(%rbp), %rcx
leaq 0xc3f2(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1d40
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movslq -0x24(%rbp), %rdx
leaq 0xc3cf(%rip), %rcx      # 0xe060
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1d32
movslq -0x24(%rbp), %rcx
leaq 0xc3b1(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
jne 0x1cd2
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2940
jmp 0x1d30
movslq -0x24(%rbp), %rcx
leaq 0xc383(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jne 0x1d00
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2ab0
jmp 0x1d2e
movslq -0x24(%rbp), %rcx
leaq 0xc355(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3, 0x8(%rax)
jne 0x1d2c
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2d10
jmp 0x1d2e
jmp 0x1d30
jmp 0x1d32
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c63
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/check_inst_param.c
// Function: check_comm
char	*check_comm(char *str, t_data *data)
{
	char	**comm;

	comm = NULL;
	if (is_in_str(COMMENT_CHAR, str) > 0)
	{
		if ((comm = ft_strsplit(str, COMMENT_CHAR)) == NULL)
			error_line(data, "Malloc error");
		return (comm[0]);
	}
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movl $0x23, %edi
callq 0x5560
cmpl $0x0, %eax
jle 0x1db0
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x6230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1da3
movq -0x18(%rbp), %rdi
leaq 0x8388(%rip), %rsi      # 0xa126
callq 0x2510
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1db8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/check_reg_d_ind.c
// Function: check_reg
void	check_reg(char *str, t_data *data)
{
	int		i;
	int		reg_check;

	i = 1;
	reg_check = 0;
	if (ft_isdigit(str[i]) == 1)
	{
		reg_check = ft_atoi(str + i);
		if (reg_check > REG_NUMBER)
			error_line(data, "Incorrect number of register");
	}
	while (str[i] != '\0' && str[i] != SEPARATOR_CHAR)
	{
		if (ft_isdigit(str[i]) != 1)
			error_line(data, "Register error, incorrect input");
		i++;
	}
	if (str[0] != 'r' || reg_check < 0 || is_in_str('r', str) > 1 || i > 3)
		error_line(data, "Register error, incorrect input");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
jne 0x1e2f
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0x5e20
movl %eax, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jle 0x1e2d
movq -0x10(%rbp), %rdi
leaq 0x830b(%rip), %rsi      # 0xa133
callq 0x2510
jmp 0x1e2f
jmp 0x1e31
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x1e5c
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1e65
jmp 0x1e96
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
je 0x1e8b
movq -0x10(%rbp), %rdi
leaq 0x82ca(%rip), %rsi      # 0xa150
callq 0x2510
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1e31
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x1ec1
cmpl $0x0, -0x18(%rbp)
jl 0x1ec1
movq -0x8(%rbp), %rsi
movl $0x72, %edi
callq 0x5560
cmpl $0x1, %eax
jg 0x1ec1
cmpl $0x3, -0x14(%rbp)
jle 0x1ed1
movq -0x10(%rbp), %rdi
leaq 0x8284(%rip), %rsi      # 0xa150
callq 0x2510
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/check_reg_d_ind.c
// Function: check_direct
void	check_direct(char *str, t_data *data)
{
	int		i;

	i = 1;
	if (str[0] != DIRECT_CHAR && is_in_str(DIRECT_CHAR, str) != 1)
		error_line(data, "Incorrect direct input");
	if (ft_isdigit(str[i]) == 1)
	{
		while (str[i] != '\0' && str[i] != SEPARATOR_CHAR)
		{
			if (ft_isdigit(str[i]) != 1)
				error_line(data, "Direct error, incorrect input");
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
je 0x1f26
movq -0x8(%rbp), %rsi
movl $0x25, %edi
callq 0x5560
cmpl $0x1, %eax
je 0x1f26
movq -0x10(%rbp), %rdi
leaq 0x824f(%rip), %rsi      # 0xa170
callq 0x2510
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
jne 0x1fa5
jmp 0x1f3e
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x1f69
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1f72
jmp 0x1fa3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
je 0x1f98
movq -0x10(%rbp), %rdi
leaq 0x81f4(%rip), %rsi      # 0xa187
callq 0x2510
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1f3e
jmp 0x1fa5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/check_reg_d_ind.c
// Function: check_indirect
void	check_indirect(char *str, t_data *data)
{
	int		i;
	int		ind_check;

	i = 0;
	ind_check = 0;
	if (str[i] == LABEL_CHAR)
	{
		i++;
		if (ft_isdigit(str[i]) == 1)
		{
			ind_check = ft_atoi(str + i);
			while (str[i] && str[i] != SEPARATOR_CHAR)
			{
				if (ft_isdigit(str[i]) != 1)
					error_line(data, "Indirect error, incorrect input");
				i++;
			}
		}
	}
	i = 0;
	if (str[i] == '-')
		i++;
	if (str[i] != LABEL_CHAR && ft_isdigit(str[i]) != 1)
		error_line(data, "Indirect error, incorrect input");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x207e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
jne 0x207c
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
callq 0x5e20
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2040
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2049
jmp 0x207a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
je 0x206f
movq -0x10(%rbp), %rdi
leaq 0x813b(%rip), %rsi      # 0xa1a5
callq 0x2510
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2015
jmp 0x207c
jmp 0x207e
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x209f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x20d6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5f50
cmpl $0x1, %eax
je 0x20d6
movq -0x10(%rbp), %rdi
leaq 0x80d4(%rip), %rsi      # 0xa1a5
callq 0x2510
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/cor.c
// Function: add_to_cor
void	add_to_cor(t_data *data, char c)
{
	char	*tmp;
	int		i;

	data->cor_len++;
	if ((tmp = (char *)malloc(sizeof(char) * data->cor_len)) == NULL)
		error("Malloc error");
	i = 0;
	while (i < data->cor_len - 1)
	{
		tmp[i] = data->cor[i];
		i++;
	}
	tmp[i] = c;
	free(data->cor);
	data->cor = 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 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2126
leaq 0x8005(%rip), %rdi      # 0xa126
callq 0x2580
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2163
movq -0x8(%rbp), %rax
movq 0x28(%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 0x212d
movb -0x9(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/cor.c
// Function: add_str_to_cor
void	add_str_to_cor(t_data *data, char *str, int len)
{
	char	*tmp;
	int		i;
	int		j;

	data->cor_len += len;
	if ((tmp = (char *)malloc(sizeof(char) * data->cor_len)) == NULL)
		error("Malloc error");
	i = 0;
	while (i < data->cor_len - len)
	{
		tmp[i] = data->cor[i];
		i++;
	}
	j = 0;
	while (j < len)
	{
		tmp[i] = str[j];
		i++;
		j++;
	}
	free(data->cor);
	data->cor = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x21d7
leaq 0x7f54(%rip), %rdi      # 0xa126
callq 0x2580
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2214
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21de
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x224d
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x221b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/cor.c
// Function: set_filename
void	set_filename(t_data *data, char *name)
{
	int		i;
	int		ext;
	char	*tmp;

	ext = 0;
	i = 0;
	while (name[i] != '\0')
	{
		if (++ext >= 0 && name[i++] == '.')
			ext = 0;
	}
	ext = i - ext;
	if ((tmp = (char *)malloc(sizeof(char) * (ext + 4))) == NULL)
		error("Malloc error");
	i = 0;
	while (name[i] != '\0' && i < ext)
	{
		tmp[i] = name[i];
		i++;
	}
	tmp[i++] = 'c';
	tmp[i++] = 'o';
	tmp[i++] = 'r';
	tmp[i++] = '\0';
	data->filename = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x22d1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x22cf
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x22cf
movl $0x0, -0x18(%rbp)
jmp 0x228e
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2302
leaq 0x7e29(%rip), %rdi      # 0xa126
callq 0x2580
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x232b
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2334
jmp 0x2355
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2309
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x63, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x6f, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x72, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/cor.c
// Function: set_magic_to_cor
void	set_magic_to_cor(t_data *data)
{
	int		magic;

	magic = COREWAR_EXEC_MAGIC;
	add_to_cor(data, ((unsigned char *)(&magic))[3]);
	add_to_cor(data, ((unsigned char *)(&magic))[2]);
	add_to_cor(data, ((unsigned char *)(&magic))[1]);
	add_to_cor(data, ((unsigned char *)(&magic))[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xea83f3, -0xc(%rbp)   # imm = 0xEA83F3
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movsbl -0xa(%rbp), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movsbl -0xb(%rbp), %esi
callq 0x20e0
movq -0x8(%rbp), %rdi
movsbl -0xc(%rbp), %esi
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/cor.c
// Function: write_file
void	write_file(t_data *data)
{
	int		fd;

	if (data->binary)
	{
		write(1, data->cor, data->cor_len);
	}
	else
	{
		fd = open(data->filename, O_WRONLY | O_CREAT | O_TRUNC,
															S_IRUSR | S_IWUSR);
		if (fd < 0)
			error("Open fail");
		write(fd, data->cor, data->cor_len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x2442
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rdx
movl $0x1, %edi
callq 0x1040
jmp 0x2488
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1070
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x2470
leaq 0x7c83(%rip), %rdi      # 0xa0ee
callq 0x2580
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rdx
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/error.c
// Function: error_at
void	error_at(char *err, int line, int column)
{
	ft_putendl_fd(err, 2);
	ft_putstr_fd(" [", 2);
	ft_putnbr_fd(line, 2);
	ft_putstr_fd(":", 2);
	ft_putnbr_fd(column, 2);
	ft_putstr_fd("]", 2);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6580
leaq 0x7d0e(%rip), %rdi      # 0xa1c5
movl $0x2, %esi
callq 0x6540
movl -0xc(%rbp), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7cf3(%rip), %rdi      # 0xa1c8
movl $0x2, %esi
callq 0x6540
movl -0x10(%rbp), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7cd7(%rip), %rdi      # 0xa1ca
movl $0x2, %esi
callq 0x6540
movl $0x1, %edi
callq 0x1080
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/error.c
// Function: error_line
void	error_line(t_data *data, char *err)
{
	if (data != NULL)
	{
		ft_putstr_fd("Error line ", 2);
		ft_putnbr_fd(data->line, 2);
		ft_putstr_fd(" : ", 2);
	}
	ft_putendl_fd(err, 2);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x255a
leaq 0x7c9e(%rip), %rdi      # 0xa1cc
movl $0x2, %esi
callq 0x6540
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7ab9(%rip), %rdi      # 0xa009
movl $0x2, %esi
callq 0x6540
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6580
movl $0x1, %edi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/error.c
// Function: error_str
void	error_str(t_data *data, char *err, char *str)
{
	if (data != NULL)
	{
		ft_putstr_fd("Error line ", 2);
		ft_putnbr_fd(data->line, 2);
		ft_putstr_fd(" : ", 2);
	}
	ft_putstr_fd(err, 2);
	ft_putendl_fd(str, 2);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25fe
leaq 0x7bfa(%rip), %rdi      # 0xa1cc
movl $0x2, %esi
callq 0x6540
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7a15(%rip), %rdi      # 0xa009
movl $0x2, %esi
callq 0x6540
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6540
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x6580
movl $0x1, %edi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/error.c
// Function: error_limit
void	error_limit(t_data *data, char *err, char *str, int limit)
{
	if (data != NULL)
	{
		ft_putstr_fd("Error line ", 2);
		ft_putnbr_fd(data->line, 2);
		ft_putstr_fd(" : ", 2);
	}
	ft_putstr_fd(err, 2);
	ft_putstr_fd(str, 2);
	ft_putstr_fd(" (limit is ", 2);
	ft_putnbr_fd(limit, 2);
	ft_putendl_fd(")", 2);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2681
leaq 0x7b77(%rip), %rdi      # 0xa1cc
movl $0x2, %esi
callq 0x6540
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7992(%rip), %rdi      # 0xa009
movl $0x2, %esi
callq 0x6540
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6540
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x6540
leaq 0x7b34(%rip), %rdi      # 0xa1d8
movl $0x2, %esi
callq 0x6540
movl -0x1c(%rbp), %edi
movl $0x2, %esi
callq 0x65b0
leaq 0x7f9e(%rip), %rdi      # 0xa660
movl $0x2, %esi
callq 0x6580
movl $0x1, %edi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/get_ocp.c
// Function: get_ocp
int		get_ocp(int ocp, int index)
{
	if (index >= 0 && index <= 3)
	{
		if (index == 0)
			ocp = (ocp >> 6) & 3;
		if (index == 1)
			ocp = (ocp >> 4) & 3;
		if (index == 2)
			ocp = (ocp >> 2) & 3;
		if (index == 3)
			ocp = ocp & 3;
		return (ocp);
	}
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x2743
cmpl $0x3, -0xc(%rbp)
jg 0x2743
cmpl $0x0, -0xc(%rbp)
jne 0x2708
movl -0x8(%rbp), %eax
sarl $0x6, %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x271a
movl -0x8(%rbp), %eax
sarl $0x4, %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x272c
movl -0x8(%rbp), %eax
sarl $0x2, %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x273b
movl -0x8(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x274a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/get_ocp.c
// Function: get_params_size_ocp_2
int		get_params_size_ocp_2(int ret, int i, int *arr, t_instruc *inst)
{
	if (ft_strcmp(inst->name, "live") != 0 &&
			ft_strcmp(inst->name, "zjump") != 0 &&
			ft_strcmp(inst->name, "fork") != 0 &&
			ft_strcmp(inst->name, "lfork") != 0)
		ret++;
	while (i < 4)
	{
		if (arr[i] == REG_CODE)
		{
			ret += 1;
		}
		if (arr[i] == DIR_CODE)
		{
			if (ft_strcmp(inst->name, "sti") == 0 ||
					ft_strcmp(inst->name, "lldi") == 0 ||
					ft_strcmp(inst->name, "ldi") == 0)
				ret += 2;
			else
				ret += 4;
		}
		if (arr[i] == IND_CODE)
			ret += 2;
		i++;
	}
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7ce8(%rip), %rsi      # 0xa45d
callq 0x5ce0
cmpl $0x0, %eax
je 0x27d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7a56(%rip), %rsi      # 0xa1e4
callq 0x5ce0
cmpl $0x0, %eax
je 0x27d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7d91(%rip), %rsi      # 0xa538
callq 0x5ce0
cmpl $0x0, %eax
je 0x27d3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x7a2a(%rip), %rsi      # 0xa1ea
callq 0x5ce0
cmpl $0x0, %eax
je 0x27d3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x27d5
cmpl $0x4, -0x8(%rbp)
jge 0x288a
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x27f6
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x2865
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x78ee(%rip), %rsi      # 0xa101
callq 0x5ce0
cmpl $0x0, %eax
je 0x284f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x78d9(%rip), %rsi      # 0xa105
callq 0x5ce0
cmpl $0x0, %eax
je 0x284f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x78c1(%rip), %rsi      # 0xa106
callq 0x5ce0
cmpl $0x0, %eax
jne 0x285a
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x2863
movl -0x4(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0x2865
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x287c
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x27d5
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/get_ocp.c
// Function: get_params_size_ocp
int		get_params_size_ocp(t_instruc *inst)
{
	int		arr[4];

	arr[0] = get_ocp(inst->ocp, 0);
	arr[1] = get_ocp(inst->ocp, 1);
	arr[2] = get_ocp(inst->ocp, 2);
	arr[3] = get_ocp(inst->ocp, 3);
	if (inst->ocp == -4)
		return (4);
	if (inst->ocp == -2)
		return (2);
	return (get_params_size_ocp_2(0, 0, arr, inst));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
xorl %esi, %esi
callq 0x26e0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x1, %esi
callq 0x26e0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x2, %esi
callq 0x26e0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edi
movl $0x3, %esi
callq 0x26e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x4, 0x38(%rax)
jne 0x290c
movl $0x4, -0x4(%rbp)
jmp 0x2933
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x38(%rax)
jne 0x291f
movl $0x2, -0x4(%rbp)
jmp 0x2933
leaq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %esi, %esi
movl %esi, %edi
callq 0x2750
movl %eax, -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/if_params.c
// Function: if_one_param
void	if_one_param(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[0] == T_DIR)
	{
		if (g_op[i].c1 == 0 && g_op[i].c2 == 1 &&
			without_ocp(inst->trim, data, inst) == 1)
			return ;
		else if (g_op[i].c1 == 0 && g_op[i].c2 == 0 &&
			without_ocp_live(inst->trim, data, inst) == 1)
			return ;
		else if (is_direct(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[0] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorect input parameters");
	}
	else
		error_line(data, "Incorrect input parameters");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb6fe(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0xc(%rax)
jne 0x2a47
movslq -0x4(%rbp), %rcx
leaq 0xb6e2(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x28(%rax)
jne 0x29c2
movslq -0x4(%rbp), %rcx
leaq 0xb6ca(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x2c(%rax)
jne 0x29c2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3500
cmpl $0x1, %eax
jne 0x29c2
jmp 0x2aa3
movslq -0x4(%rbp), %rcx
leaq 0xb693(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x28(%rax)
jne 0x2a11
movslq -0x4(%rbp), %rcx
leaq 0xb67b(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x2c(%rax)
jne 0x2a11
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3560
cmpl $0x1, %eax
jne 0x2a11
jmp 0x2aa3
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x2a31
jmp 0x2aa3
movq -0x10(%rbp), %rdi
leaq 0x77b4(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2a43
jmp 0x2a45
jmp 0x2aa3
movslq -0x4(%rbp), %rcx
leaq 0xb60e(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0xc(%rax)
jne 0x2a91
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2a7f
jmp 0x2aa3
movq -0x10(%rbp), %rdi
leaq 0x7781(%rip), %rsi      # 0xa20b
callq 0x2510
jmp 0x2aa1
movq -0x10(%rbp), %rdi
leaq 0x7754(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2aa3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params.c
// Function: if_two_params
void	if_two_params(int i, t_data *data, t_instruc *inst, int *order)
{
	if (*order == 0)
		two_params_first(i, data, inst, order);
	else if (*order == 1)
		two_params_second(i, data, inst, order);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2ae6
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2b10
jmp 0x2b05
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2b03
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2c10
jmp 0x2b05
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params.c
// Function: two_params_first
void	two_params_first(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[*order] == (T_DIR | T_IND))
	{
		if (is_direct(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_indirect(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[*order] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else
		error_line(data, "Incorrect input parameters");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb52e(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x6, 0xc(%rax,%rcx,4)
jne 0x2b9e
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x2b6a
jmp 0x2c02
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x33d0
cmpl $0x1, %eax
jne 0x2b8a
jmp 0x2c02
movq -0x10(%rbp), %rdi
leaq 0x765b(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2b9c
jmp 0x2c02
movslq -0x4(%rbp), %rcx
leaq 0xb4b7(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x1, 0xc(%rax,%rcx,4)
jne 0x2bf0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2bde
jmp 0x2c02
movq -0x10(%rbp), %rdi
leaq 0x7607(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2c00
movq -0x10(%rbp), %rdi
leaq 0x75f5(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2c02
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params.c
// Function: two_params_second
void	two_params_second(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[*order] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[*order] == (T_IND | T_REG))
	{
		if (is_indirect(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else
		error_line(data, "Incorrect input parameters");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb42e(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x1, 0xc(%rax,%rcx,4)
jne 0x2c7f
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2c6a
jmp 0x2d05
movq -0x10(%rbp), %rdi
leaq 0x757b(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2d05
movslq -0x4(%rbp), %rcx
leaq 0xb3d6(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x5, 0xc(%rax,%rcx,4)
jne 0x2cf3
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x33d0
cmpl $0x1, %eax
jne 0x2cbf
jmp 0x2d05
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2cdf
jmp 0x2d05
movq -0x10(%rbp), %rdi
leaq 0x7506(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2cf1
jmp 0x2d03
movq -0x10(%rbp), %rdi
leaq 0x74f2(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2d05
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params_next.c
// Function: if_three_params
void	if_three_params(int i, t_data *data, t_instruc *inst, int *order)
{
	if (*order == 0)
		three_params_first(i, data, inst, order);
	else if (*order == 1)
		three_params_second(i, data, inst, order);
	else if (*order == 2)
		three_params_third(i, data, inst, order);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2d46
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2d90
jmp 0x2d86
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x2d65
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2eb0
jmp 0x2d84
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2d82
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2ff0
jmp 0x2d84
jmp 0x2d86
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params_next.c
// Function: three_params_first
void	three_params_first(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[*order] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[*order] == (T_REG | T_DIR | T_IND))
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_direct(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_indirect(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else
		error_line(data, "Incorrect input parameters");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb2ae(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x1, 0xc(%rax,%rcx,4)
jne 0x2dff
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2dea
jmp 0x2ea7
movq -0x10(%rbp), %rdi
leaq 0x73fb(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2ea7
movslq -0x4(%rbp), %rcx
leaq 0xb256(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x7, 0xc(%rax,%rcx,4)
jne 0x2e95
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2e3f
jmp 0x2ea7
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x2e5f
jmp 0x2ea7
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x33d0
cmpl $0x1, %eax
jne 0x2e7f
jmp 0x2ea7
movq -0x10(%rbp), %rdi
leaq 0x7366(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2e91
jmp 0x2e93
jmp 0x2ea5
movq -0x10(%rbp), %rdi
leaq 0x7350(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2ea7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params_next.c
// Function: three_params_second
void	three_params_second(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[*order] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[*order] == (T_REG | T_DIR | T_IND))
	{
		if (three_params_second_cut(data, inst, order) == 1)
			return ;
	}
	else if (g_op[i].param_type[*order] == (T_DIR | T_REG))
	{
		if (is_direct(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else
		error_line(data, "Incorrect input parameters");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb18e(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x1, 0xc(%rax,%rcx,4)
jne 0x2f1f
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2f0a
jmp 0x2fe7
movq -0x10(%rbp), %rdi
leaq 0x72db(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2fe7
movslq -0x4(%rbp), %rcx
leaq 0xb136(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x7, 0xc(%rax,%rcx,4)
jne 0x2f5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x30e0
cmpl $0x1, %eax
jne 0x2f5a
jmp 0x2fe7
jmp 0x2fe5
movslq -0x4(%rbp), %rcx
leaq 0xb0f6(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x3, 0xc(%rax,%rcx,4)
jne 0x2fd3
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x2f9f
jmp 0x2fe7
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x2fbf
jmp 0x2fe7
movq -0x10(%rbp), %rdi
leaq 0x7226(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2fd1
jmp 0x2fe3
movq -0x10(%rbp), %rdi
leaq 0x7212(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x2fe5
jmp 0x2fe7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params_next.c
// Function: three_params_third
void	three_params_third(int i, t_data *data, t_instruc *inst, int *order)
{
	if (g_op[i].param_type[*order] == T_REG)
	{
		if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
	else if (g_op[i].param_type[*order] == (T_DIR | T_REG))
	{
		if (is_direct(inst->trim, data, inst, order) == 1)
			return ;
		else if (is_register(inst->trim, data, inst, order) == 1)
			return ;
		else
			error_line(data, "Incorrect input parameters");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xb04e(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x1, 0xc(%rax,%rcx,4)
jne 0x305c
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x304a
jmp 0x30d2
movq -0x10(%rbp), %rdi
leaq 0x719b(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x30d2
movslq -0x4(%rbp), %rcx
leaq 0xaff9(%rip), %rax      # 0xe060
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
cmpl $0x3, 0xc(%rax,%rcx,4)
jne 0x30d0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x309c
jmp 0x30d2
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x30bc
jmp 0x30d2
movq -0x10(%rbp), %rdi
leaq 0x7129(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x30ce
jmp 0x30d0
jmp 0x30d2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/if_params_next.c
// Function: three_params_second_cut
int		three_params_second_cut(t_data *data, t_instruc *inst, int *order)
{
	if (is_register(inst->trim, data, inst, order) == 1)
		return (1);
	else if (is_direct(inst->trim, data, inst, order) == 1)
		return (1);
	else if (is_indirect(inst->trim, data, inst, order) == 1)
		return (1);
	else
		error_line(data, "Incorrect input parameters");
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3480
cmpl $0x1, %eax
jne 0x311b
movl $0x1, -0x4(%rbp)
jmp 0x3184
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3350
cmpl $0x1, %eax
jne 0x3142
movl $0x1, -0x4(%rbp)
jmp 0x3184
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x33d0
cmpl $0x1, %eax
jne 0x3169
movl $0x1, -0x4(%rbp)
jmp 0x3184
movq -0x10(%rbp), %rdi
leaq 0x707c(%rip), %rsi      # 0xa1f0
callq 0x2510
jmp 0x317b
jmp 0x317d
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/instruc_list_fct.c
// Function: inst_new_elem
t_instruc	*inst_new_elem(char *name)
{
	t_instruc	*new_element;

	if ((new_element = (t_instruc *)malloc(sizeof(t_instruc))) == NULL)
		error("Malloc error");
	if (new_element != NULL)
	{
		new_element->next = NULL;
		new_element->name = name;
		new_element->opcode = 0;
		new_element->param_1 = NULL;
		new_element->param_2 = NULL;
		new_element->param_3 = NULL;
		new_element->ocp = 0;
	}
	return (new_element);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x322c
leaq 0x6eff(%rip), %rdi      # 0xa126
callq 0x2580
cmpq $0x0, -0x10(%rbp)
je 0x3284
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/asm/instruc_list_fct.c
// Function: addend_inst_lst
void		addend_inst_lst(t_instruc **lst, t_instruc *new_elem)
{
	t_instruc	*tmp;

	tmp = *lst;
	if (*lst == 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)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x32be
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x32e2
jmp 0x32c0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x32d7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x32c0
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/instruc_list_fct.c
// Function: print_inst_lst
void		print_inst_lst(t_instruc *lst)
{
	t_instruc	*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 0x333b
movl $0x7b, %edi
callq 0x64a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x64d0
leaq 0x6efc(%rip), %rdi      # 0xa225
callq 0x64d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3304
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/is_reg_d_ind.c
// Function: is_direct
int		is_direct(char *trim, t_data *data, t_instruc *inst, int *order)
{
	if (trim[0] == DIRECT_CHAR)
	{
		check_direct(trim, data);
		inst->ocp = set_ocp(inst->ocp, *order, 2);
		*order = *order + 1;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x25, %eax
jne 0x33b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ee0
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movl $0x2, %edx
callq 0x57d0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x33c0
movl $0x0, -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/is_reg_d_ind.c
// Function: is_indirect
int		is_indirect(char *trim, t_data *data, t_instruc *inst, int *order)
{
	if (trim[0] == ':' || ft_isdigit(trim[0]) || trim[0] == '-'
		|| trim[0] == '+')
	{
		check_indirect(trim, data);
		inst->ocp = set_ocp(inst->ocp, *order, 3);
		*order = *order + 1;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x341d
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x5f50
cmpl $0x0, %eax
jne 0x341d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x341d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x3462
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1fb0
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movl $0x3, %edx
callq 0x57d0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3469
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/is_reg_d_ind.c
// Function: is_register
int		is_register(char *trim, t_data *data, t_instruc *inst, int *order)
{
	if (trim[0] == 'r')
	{
		check_reg(trim, data);
		inst->ocp = set_ocp(inst->ocp, *order, 1);
		*order = *order + 1;
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x34e9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dd0
movq -0x20(%rbp), %rax
movl 0x38(%rax), %edi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movl $0x1, %edx
callq 0x57d0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x34f0
movl $0x0, -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/is_reg_d_ind.c
// Function: without_ocp
int		without_ocp(char *trim, t_data *data, t_instruc *inst)
{
	if (trim[0] == DIRECT_CHAR)
	{
		check_direct(trim, data);
		inst->ocp = -2;
		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 0x3541
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ee0
movq -0x20(%rbp), %rax
movl $0xfffffffe, 0x38(%rax) # imm = 0xFFFFFFFE
movl $0x1, -0x4(%rbp)
jmp 0x3548
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)