LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/get_player_code.c
// Function: get_player_code
void		get_player_code(t_player *player)
{
	int				fd;
	unsigned int	prog_size;

	player->champ_size = 0;
	if ((fd = open(player->file_name, O_RDONLY)) < 0)
	{
		ft_printf_fd(2, "Error: Open file %s failed.\n", player->file_name);
		exit(1);
	}
	get_input(fd, player, &prog_size);
	player->begin = read_prog(fd, player->begin, &player->champ_size);
	if (prog_size != player->champ_size)
	{
		ft_printf_fd(2, "Error: File %s has a code size that differs \
from what its header says.\n", player->file_name);
		exit(1);
	}
	if ((close(fd)) == -1)
	{
		ft_printf_fd(2, "Error: Close file %s failed.\n", player->file_name);
		exit(1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x0, 0x20(%rdi)
movq 0x18(%rdi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21b0
testl %eax, %eax
js 0x2b32
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x2888
movq 0x28(%rbx), %r15
leaq 0xb(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x2120
testq %rax, %rax
je 0x2b0c
leaq 0xb(%rsp), %r14
movq %r15, %r12
movb 0xb(%rsp), %al
movb %al, (%r12)
incl 0x20(%rbx)
movl $0x1, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x2120
incq %r12
testq %rax, %rax
jne 0x2aea
movq %r15, 0x28(%rbx)
movl 0xc(%rsp), %eax
cmpl 0x20(%rbx), %eax
jne 0x2b3f
movl %ebp, %edi
callq 0x2100
cmpl $-0x1, %eax
je 0x2b4c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rdx
leaq 0x45e8(%rip), %rsi      # 0x7125
jmp 0x2b57
movq 0x18(%rbx), %rdx
leaq 0x45f8(%rip), %rsi      # 0x7142
jmp 0x2b57
movq 0x18(%rbx), %rdx
leaq 0x4633(%rip), %rsi      # 0x718a
movl $0x2, %edi
xorl %eax, %eax
callq 0x55d0
movl $0x1, %edi
callq 0x21e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/main.c
// Function: main
int				main(int argc, char **argv)
{
	t_arena	*arena;

	arena = create_arena();
	check_param(&argc, &argv, arena);
	save_players(argc, argv, arena);
	load_players(arena);
	if (arena->display != NULL)
		init_display(arena);
	else
		display_champions(arena);
	start_fight(arena);
	if (arena->cycle != arena->dump_cycle)
	{
		if (arena->display != NULL && !arena->display->quitting)
			print_winner_display(arena);
		else
			print_winner(arena);
	}
	destroy_arena(arena);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
callq 0x2389
cmpl $0x1, %ebp
je 0x2ceb
movq %rax, %rbx
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rsi
leaq 0x4904(%rip), %rdi      # 0x74a0
callq 0x5290
testl %eax, %eax
je 0x2bd4
movq (%r15), %rsi
leaq 0x46e0(%rip), %rdi      # 0x728f
callq 0x5290
testl %eax, %eax
je 0x2be8
movq (%r15), %rsi
leaq 0x46d3(%rip), %rdi      # 0x7295
callq 0x5290
testl %eax, %eax
jne 0x2c21
movl $0x1, 0x24(%rbx)
jmp 0x2be4
movq %r14, %rdi
callq 0x46f7
movq $0x1, 0x30(%rbx)
decl %ebp
jmp 0x2c24
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x2cd0
movb (%rdi), %al
testb %al, %al
je 0x2c12
leaq 0x1(%rdi), %rcx
addb $-0x30, %al
cmpb $0xa, %al
jae 0x2cd0
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x2bff
addq $0x10, %r14
callq 0x52b8
movl %eax, 0x20(%rbx)
addl $-0x2, %ebp
movq %r14, %r15
addq $0x8, %r15
decl %ebp
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x24e0
movq %rbx, %rdi
callq 0x2651
cmpq $0x0, 0x30(%rbx)
je 0x2c52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4744
jmp 0x2c5a
movq %rbx, %rdi
callq 0x23dc
movq %rbx, %rdi
callq 0x4439
movl 0x10(%rbx), %eax
cmpl 0x20(%rbx), %eax
je 0x2cbb
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2c79
cmpl $0x0, 0x10(%rax)
je 0x2cb3
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2c98
movq %rax, %rcx
movl 0x30(%rcx), %edx
cmpl 0x30(%rax), %edx
cmovgeq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x2c85
movl 0x30(%rax), %esi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
leaq 0x461b(%rip), %rdi      # 0x72c5
xorl %eax, %eax
callq 0x541c
jmp 0x2cbb
movq %rbx, %rdi
callq 0x4c7f
movq %rbx, %rdi
callq 0x24a3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x45c1(%rip), %rdi      # 0x7298
movl $0x2, %esi
callq 0x53b0
movl $0x1, %edi
callq 0x21e0
leaq 0x44b6(%rip), %rdi      # 0x71a8
movl $0x2, %esi
callq 0x53b0
leaq 0x44cd(%rip), %rdi      # 0x71d0
movl $0x2, %esi
callq 0x53b0
leaq 0x44eb(%rip), %rdi      # 0x71ff
movl $0x2, %esi
callq 0x53b0
leaq 0x450b(%rip), %rdi      # 0x7230
movl $0x2, %esi
callq 0x53b0
leaq 0x452d(%rip), %rdi      # 0x7263
movl $0x2, %esi
callq 0x53b0
leaq 0x4537(%rip), %rdi      # 0x727e
jmp 0x2cd7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instruction_param.c
// Function: decode_ocp
void		decode_ocp(t_process *process, t_parameters *param, int i)
{
	int		select;
	int		decal;
	int		temp;
	int		j;

	select = 0xC0;
	j = 0;
	decal = 6;
	while (j < g_op_tab[i].param_nbr && j < 4)
	{
		temp = mem(PC + 1, 1, PA, process)[0] & select;
		param->type[j] = temp >> decal;
		select = select >> 2;
		decal -= 2;
		j++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edx, %rax
leaq (%rax,%rax,4), %rax
leaq 0x83bb(%rip), %rcx      # 0xb120
cmpl $0x0, 0x8(%rcx,%rax,8)
jle 0x2dc6
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rcx,%rax,8), %r15
addq $0x8, %r15
movl $0x6, %ebp
movl $0xc0, %r12d
xorl %r13d, %r13d
movq 0x48(%r14), %rdi
movq 0x68(%r14), %rdx
incq %rdi
movl $0x1, %esi
movq %r14, %rcx
callq 0x231c
movzbl (%rax), %eax
andl %r12d, %eax
movl %ebp, %ecx
shrl %cl, %eax
movb %al, (%rbx,%r13)
cmpq $0x2, %r13
ja 0x2dc6
shrl $0x2, %r12d
addl $-0x2, %ebp
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x2d88
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instruction_param.c
// Function: params_value
void		params_value(t_process *process, t_parameters *param, int j)
{
	int	i;

	i = 0;
	while (i < g_op_tab[j].param_nbr && i < 4)
	{
		if (param->type[i] == REG_CODE)
		{
			param->value[i] = rm(mem(PC + param->jump, 1, PA, process), 1, PP);
			param->jump += 1;
		}
		else if (param->type[i] == DIR_CODE && param->o != 11 && param->o != 10
				&& param->o != 14)
		{
			param->value[i] = rm(mem(PC + PJ, 1, PA, process), DIR_SIZE, PP);
			param->jump += DIR_SIZE;
		}
		else if (param->type[i] == 0)
			;
		else
		{
			param->value[i] = rm(mem(PC + PJ, 1, PA, process), IND_SIZE, PP);
			param->jump += IND_SIZE;
		}
		i++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edx, %rax
leaq (%rax,%rax,4), %rax
leaq 0x8332(%rip), %rcx      # 0xb120
cmpl $0x0, 0x8(%rcx,%rax,8)
jle 0x2ea1
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rcx,%rax,8), %r12
addq $0x8, %r12
movl $0x1, %r13d
movzbl -0x1(%rbx,%r13), %eax
testl %eax, %eax
je 0x2e83
cmpl $0x1, %eax
je 0x2e50
cmpl $0x2, %eax
jne 0x2e43
movzbl 0x2c(%rbx), %ecx
movl $0x4, %ebp
movl $0x4, %r15d
cmpl $0xe, %ecx
ja 0x2e55
movl $0x4c00, %edx           # imm = 0x4C00
btl %ecx, %edx
jae 0x2e55
testl %eax, %eax
je 0x2e83
movl $0x2, %ebp
movl $0x2, %r15d
jmp 0x2e55
movq %rax, %r15
movl %eax, %ebp
movslq 0x28(%rbx), %rdi
addq 0x48(%r14), %rdi
movq 0x68(%r14), %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x231c
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x462c
movq %rax, (%rbx,%r13,8)
addl %ebp, 0x28(%rbx)
leaq -0x1(%r13), %rax
cmpq $0x2, %rax
ja 0x2ea1
movslq (%r12), %rax
leaq 0x1(%r13), %rcx
cmpq %rax, %r13
movq %rcx, %r13
jl 0x2e0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instruction_param.c
// Function: check_registers
int			check_registers(t_parameters *param, t_process *process, int j)
{
	int	i;

	i = 0;
	while (i < g_op_tab[j].param_nbr && i < 4)
	{
		if (param->type[i] == REG_CODE)
		{
			if (PR[param->value[i] - 1] == NULL || param->value[i] > REG_NUMBER
					|| param->value[i] < 1)
				return (1);
		}
		i++;
	}
	return (0);
}

// Assembly:
movslq %edx, %rax
leaq (%rax,%rax,4), %rax
leaq 0x8262(%rip), %rcx      # 0xb120
movl 0x8(%rcx,%rax,8), %ecx
testl %ecx, %ecx
jle 0x2ef4
decl %ecx
cmpl $0x3, %ecx
movl $0x3, %eax
cmovbl %ecx, %eax
incl %eax
xorl %ecx, %ecx
cmpb $0x1, (%rdi,%rcx)
jne 0x2eec
movq 0x8(%rdi,%rcx,8), %rdx
addq $-0x11, %rdx
cmpq $-0x10, %rdx
jb 0x2ef7
incq %rcx
cmpq %rcx, %rax
jne 0x2ed7
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instruction_param.c
// Function: execute_instruction
int			execute_instruction(t_process *process)
{
	static int		(*instruction[16])(t_process *process, int i) =
	{alive, load, store, addition, soustraction, ft_and, ft_or, ft_xor, zjump,
		load_index, store_index, ft_fork, long_load, long_load_index, long_fork,
		aff};
	int				i;

	i = 0;
	while (g_op_tab[i].op_code != process->op_code && g_op_tab[i].name != NULL)
		i++;
	if (g_op_tab[i].name == NULL)
		return (1);
	return ((*instruction[i])(process, i));
}

// Assembly:
movl 0x64(%rdi), %ecx
leaq 0x8219(%rip), %rax      # 0xb120
movsbl 0x10(%rax), %edx
cmpl %edx, %ecx
jne 0x2f13
xorl %esi, %esi
jmp 0x2f31
leaq 0x8206(%rip), %rax      # 0xb120
xorl %esi, %esi
cmpq $0x0, (%rax)
je 0x2f31
incq %rsi
movsbl 0x38(%rax), %edx
addq $0x28, %rax
cmpl %edx, %ecx
jne 0x2f1c
cmpq $0x0, (%rax)
je 0x2f41
leaq 0x7e12(%rip), %rax      # 0xad50
jmpq *(%rax,%rsi,8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instruction_param.c
// Function: check_param_error
int			check_param_error(t_parameters param, int i)
{
	int	j;

	j = 0;
	while (j < g_op_tab[i].param_nbr && param.type[j])
	{
		if (param.type[j] == REG_CODE)
			param.type[j++] = T_REG;
		else if (param.type[j] == DIR_CODE)
			param.type[j++] = T_DIR;
		else if (param.type[j] == IND_CODE)
			param.type[j++] = T_IND;
		else
			param.type[j++] = 0;
	}
	j = -1;
	while (++j < g_op_tab[i].param_nbr && j < 4)
	{
		if ((g_op_tab[i].param_type[j] & param.type[j]) == 0)
			return (1);
	}
	return (0);
}

// Assembly:
leaq 0x8(%rsp), %rcx
movslq %edi, %rax
leaq (%rax,%rax,4), %rax
leaq 0x81c6(%rip), %rsi      # 0xb120
movslq 0x8(%rsi,%rax,8), %rdx
testq %rdx, %rdx
jle 0x2f97
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movzbl %r8b, %r9d
leal -0x1(%r9), %r10d
cmpl $0x2, %r10d
jb 0x2f8b
cmpl $0x3, %r9d
je 0x2f88
testl %r9d, %r9d
je 0x2f97
xorl %r8d, %r8d
jmp 0x2f8b
movb $0x4, %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x2f66
leaq (%rsi,%rax,8), %rsi
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq $0x4, %rdx
movl $0x4, %edi
cmovbq %rdx, %rdi
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x2fcd
movb (%rcx,%rdx), %r8b
leaq 0x1(%rdx), %r9
testb %r8b, 0xc(%rsi,%rdx)
movq %r9, %rdx
jne 0x2fb1
movl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p1.c
// Function: alive
int		alive(t_process *process, int i)
{
	t_parameters	param;
	t_player		*temp;

	i += 1;
	param.type[0] = DIR_CODE;
	param.value[0] = rm(mem(process->pc + 1, 1, PA, process), DIR_SIZE, PP);
	process->lives = 1;
	process->count_lives += 1;
	temp = process->arena->players;
	while (temp != NULL && temp->id != param.value[0])
		temp = temp->next;
	if (temp != NULL)
	{
		temp->last_live = process->arena->cycle;
		if (process->arena->print_lives == 1)
			ft_printf("Un processus dit que le joueur %s est en vie.\n",
				temp->name);
	}
	return (1 + DIR_SIZE);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq 0x68(%rbx), %rdx
incq %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movl $0x1, 0x58(%rbx)
incl 0x60(%rbx)
movq 0x68(%rbx), %rdx
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x303f
movslq (%rcx), %rsi
cmpq %rsi, %rax
je 0x3021
movq 0x38(%rcx), %rcx
jmp 0x300e
movl 0x10(%rdx), %eax
movl %eax, 0x30(%rcx)
cmpl $0x1, 0x24(%rdx)
jne 0x303f
movq 0x8(%rcx), %rsi
leaq 0x43ee(%rip), %rdi      # 0x7426
xorl %eax, %eax
callq 0x541c
movl $0x5, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p1.c
// Function: load
int		load(t_process *process, int i)
{
	t_parameters	param;

	param.o = 2;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || param.type[1] != REG_CODE
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr < 2
	|| g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(PR[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	WBE(param.value[0], PR[param.value[1] - 1], REG_SIZE);
	change_carry(process, PV[0]);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x2, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x80a7(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3120
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x317a
cmpb $0x1, 0x31(%rsp)
jne 0x317a
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x317a
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jbe 0x317a
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x3127
cmpl $0x1, %eax
jne 0x3156
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x3151
movl $0x1, %eax
jmp 0x317e
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x53c8
movl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x43f9
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p1.c
// Function: store
int		store(t_process *process, int i)
{
	t_parameters	param;

	param.o = 3;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || g_op_tab[i].param_nbr < 2
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(PR[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	if (param.type[1] == REG_CODE)
		WBE(PV[0], PR[PV[1] - 1], REG_SIZE);
	else if (param.type[1] == IND_CODE)
		wm(PV[0], mem(process->pc + PV[1], 1, PA, process), REG_SIZE, PP);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x3, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7f62(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3265
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x32f9
leaq (%r12,%r15,8), %r14
cmpl $0x2, 0x8(%r14)
jl 0x32f9
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x32f9
cmpl $0x5, 0x8(%r14)
jge 0x32f9
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x326f
cmpl $0x1, %eax
jne 0x329e
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x3299
movl $0x1, %eax
jmp 0x32fd
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x3, %eax
je 0x32c7
cmpl $0x1, %eax
jne 0x32f9
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x53c8
jmp 0x32f9
movq 0x38(%rsp), %r14
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x40(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x4570
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p1.c
// Function: addition
int		addition(t_process *process, int i)
{
	t_parameters	param;

	param.o = 4;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || g_op_tab[i].param_nbr < 3
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr > 4
	|| param.type[2] != REG_CODE)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(PR[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	if (param.type[1] == REG_CODE)
		param.value[1] = RBE(PR[param.value[1] - 1], REG_SIZE);
	else if (param.type[1] == IND_CODE)
		PV[1] = rm(mem(process->pc + PV[1], 1, PA, process), REG_SIZE, PP);
	WBE(PV[0] + PV[1], PR[PV[2] - 1], REG_SIZE);
	change_carry(process, (PV[0] + PV[1]));
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x4, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7de3(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x33ef
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x34a8
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x34a8
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x34a8
cmpl $0x4, 0x8(%r14)
jg 0x34a8
cmpb $0x1, 0x32(%rsp)
jne 0x34a8
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x33f9
cmpl $0x1, %eax
jne 0x3428
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x3423
movl $0x1, %eax
jmp 0x34ac
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x3, %eax
je 0x344c
cmpl $0x1, %eax
jne 0x347b
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x3476
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x40(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
addq 0x38(%rsp), %rdi
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x53c8
movl 0x40(%rsp), %esi
addl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x43f9
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p2.c
// Function: ft_and
int		ft_and(t_process *process, int i)
{
	t_parameters	param;

	param.o = 6;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || param.type[2] != REG_CODE
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr < 3
	|| g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(process->registers[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	if (param.type[1] == REG_CODE)
		param.value[1] = RBE(process->registers[param.value[1] - 1], REG_SIZE);
	else if (param.type[1] == IND_CODE)
		PV[1] = rm(mem(process->pc + PV[1], 1, PA, process), REG_SIZE, PP);
	ft_write_big_endian((PV[0] & PV[1]), PR[PV[2] - 1], REG_SIZE);
	change_carry(process, (PV[0] & PV[1]));
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x6, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7a85(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3746
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x37ff
cmpb $0x1, 0x32(%rsp)
jne 0x37ff
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x37ff
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x3, %eax
jbe 0x37ff
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x3750
cmpl $0x1, %eax
jne 0x377f
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x377a
movl $0x1, %eax
jmp 0x3803
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x3, %eax
je 0x37a3
cmpl $0x1, %eax
jne 0x37d2
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x37cd
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x40(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
andq 0x38(%rsp), %rdi
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x53c8
movl 0x40(%rsp), %esi
andl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x43f9
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p2.c
// Function: load_index
int		load_index(t_process *process, int i)
{
	t_parameters	param;

	param.o = 10;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || g_op_tab[i].param_nbr < 3
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(process->registers[param.value[0] - 1], REG_SIZE);
	if (param.type[1] == REG_CODE)
		param.value[1] = RBE(process->registers[param.value[1] - 1], REG_SIZE);
	PV[0] = rm(mem(process->pc + PV[0] + PV[1], 1, PA, process), REG_SIZE, PP);
	if (param.type[2] == REG_CODE)
		WBE(PV[0], PR[PV[2] - 1], REG_SIZE);
	else if (param.type[2] == IND_CODE)
		wm(PV[0], mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0xa, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x753b(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3d04
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x3d36
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x3d36
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x3d36
cmpl $0x5, 0x8(%r14)
jge 0x3d36
cmpb $0x1, 0x30(%rsp)
jne 0x3c87
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x31(%rsp)
jne 0x3ca6
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
movq %rax, 0x40(%rsp)
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
addq 0x40(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, %r14
movq %rax, 0x38(%rsp)
movzbl 0x32(%rsp), %eax
cmpl $0x3, %eax
je 0x3d0b
cmpl $0x1, %eax
jne 0x3d36
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x53c8
jmp 0x3d36
movl $0x1, %eax
jmp 0x3d3a
movq 0x48(%rbx), %rdi
addq %r14, %rdi
movq 0x68(%rbx), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x4570
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p3.c
// Function: long_load
int		long_load(t_process *process, int i)
{
	t_parameters	param;

	param.o = 2;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || param.type[1] != REG_CODE
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr < 2
	|| g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = ft_read_big_endian(PR[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 0, PA, process), REG_SIZE, PP);
	ft_write_big_endian(param.value[0], PR[param.value[1] - 1], REG_SIZE);
	change_carry(process, PV[0]);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x2, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x733b(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3e8c
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x3ee3
cmpb $0x1, 0x31(%rsp)
jne 0x3ee3
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x3ee3
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jbe 0x3ee3
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x3e93
cmpl $0x1, %eax
jne 0x3ebf
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x3eba
movl $0x1, %eax
jmp 0x3ee7
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x53c8
movl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x43f9
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p3.c
// Function: long_load_index
int		long_load_index(t_process *process, int i)
{
	t_parameters	param;

	param.o = 14;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || g_op_tab[i].param_nbr < 3
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr > 4)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(process->registers[param.value[1] - 1], REG_SIZE);
	if (param.type[1] == REG_CODE)
		param.value[1] = RBE(process->registers[param.value[1] - 1], REG_SIZE);
	PV[0] = rm(mem(process->pc + PV[0] + PV[1], 0, PA, process), REG_SIZE, PP);
	if (param.type[2] == REG_CODE)
		WBE(PV[0], PR[PV[2] - 1], REG_SIZE);
	else if (param.type[2] == IND_CODE)
		wm(PV[0], mem(process->pc + PV[0], 0, PA, process), REG_SIZE, PP);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0xe, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x71f9(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x4043
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x4072
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x4072
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x4072
cmpl $0x5, 0x8(%r14)
jge 0x4072
cmpb $0x1, 0x30(%rsp)
jne 0x3fc9
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x31(%rsp)
jne 0x3fe8
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
movq %rax, 0x40(%rsp)
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
addq 0x40(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, %r14
movq %rax, 0x38(%rsp)
movzbl 0x32(%rsp), %eax
cmpl $0x3, %eax
je 0x404a
cmpl $0x1, %eax
jne 0x4072
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x53c8
jmp 0x4072
movl $0x1, %eax
jmp 0x4076
movq 0x48(%rbx), %rdi
addq %r14, %rdi
movq 0x68(%rbx), %rdx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %edx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x4570
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/instructions_p3.c
// Function: aff
int		aff(t_process *process, int i)
{
	t_parameters	param;

	param.o = 16;
	decode_ocp(process, &param, i);
	param.jump = 1 + g_op_tab[i].has_ocp;
	if (g_op_tab[i].has_ocp == 0)
		return (1);
	params_value(process, &param, i);
	if (check_registers(&param, process, i) == 1 || g_op_tab[i].param_nbr > 4
	|| check_param_error(param, i) == 1 || g_op_tab[i].param_nbr < 1)
		return (param.jump);
	if (param.type[0] == REG_CODE)
		param.value[0] = RBE(process->registers[param.value[0] - 1], REG_SIZE);
	else if (param.type[0] == IND_CODE)
		PV[0] = rm(mem(process->pc + PV[0], 1, PA, process), REG_SIZE, PP);
	ft_putchar(PV[0] % 256);
	return (param.jump);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movb $0x10, 0x2c(%r14)
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d4c
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7019(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x41a6
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd5
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2eb0
cmpl $0x1, %eax
je 0x41e6
leaq (%r12,%r15,8), %r14
cmpl $0x4, 0x8(%r14)
jg 0x41e6
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebp, %edi
callq 0x2f47
cmpl $0x1, %eax
je 0x41e6
cmpl $0x0, 0x8(%r14)
jle 0x41e6
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x41ad
cmpl $0x1, %eax
jne 0x41dc
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x53e5
jmp 0x41d7
movl $0x1, %eax
jmp 0x41ea
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x462c
movq %rax, 0x38(%rsp)
movsbl 0x38(%rsp), %edi
callq 0x5380
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/execution.c
// Function: get_wait_time
void			get_wait_time(t_process **p)
{
	int	op_code;
	int	i;

	i = 0;
	op_code = (*p)->pc[0];
	(*p)->op_code = op_code;
	while (g_op_tab[i].name != NULL)
	{
		if (g_op_tab[i].op_code == op_code)
		{
			(*p)->cycles_to_wait = g_op_tab[i].cycles - 1;
			(*p)->op_code = op_code;
		}
		i++;
	}
}

// Assembly:
movq (%rdi), %rax
movq 0x48(%rax), %rcx
movsbl (%rcx), %ecx
movl %ecx, 0x64(%rax)
leaq 0x6d0c(%rip), %rdx      # 0xb120
cmpq $0x0, (%rdx)
je 0x4438
addq $0x10, %rdx
cmpb %cl, (%rdx)
jne 0x442d
movl 0x4(%rdx), %esi
decl %esi
movl %esi, 0x54(%rax)
movl %ecx, 0x64(%rax)
cmpq $0x0, 0x18(%rdx)
leaq 0x28(%rdx), %rdx
jne 0x441e
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/execution.c
// Function: start_fight
void			start_fight(t_arena *arena)
{
	int		lives;

	while (arena->processes != NULL && update_display(arena))
	{
		execute_processes(arena);
		if (arena->cycle >= arena->last_check_cycle + arena->cycle_to_die)
		{
			lives = count_lives(arena);
			check_processes(arena);
			arena->last_check_cycle = arena->cycle;
			arena->checks_without_decrement++;
			if (arena->checks_without_decrement >= MAX_CHECKS
					|| lives >= NBR_LIVE)
			{
				arena->cycle_to_die -= CYCLE_DELTA;
				arena->checks_without_decrement = 0;
			}
		}
		if (arena->cycle == arena->dump_cycle)
		{
			dump_memory(arena);
			break ;
		}
		arena->cycle++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x454d
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
callq 0x489e
testl %eax, %eax
je 0x454d
movq 0x28(%rbx), %r15
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x44bb
cmpl $0x0, 0x54(%r15)
jns 0x4487
movq %r14, %rdi
callq 0x4400
cmpl $0x0, 0x54(%r15)
jg 0x44b1
movq 0x48(%r15), %r12
movq %r15, %rdi
callq 0x2efd
movslq %eax, %rdi
addq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x231c
movq %rax, 0x48(%r15)
decl 0x54(%r15)
movq 0x70(%r15), %r15
jmp 0x446e
movl 0x14(%rbx), %eax
addl 0x18(%rbx), %eax
cmpl %eax, 0x10(%rbx)
jl 0x4535
movq 0x28(%rbx), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x44ea
movq %rdi, %rax
addl 0x60(%rax), %r15d
movq 0x70(%rax), %rax
testq %rax, %rax
jne 0x44d5
cmpl $0x15, %r15d
setge %r15b
testq %rdi, %rdi
je 0x450e
movq 0x70(%rdi), %r12
cmpl $0x0, 0x58(%rdi)
je 0x4501
movl %ebp, 0x60(%rdi)
movl %ebp, 0x58(%rdi)
jmp 0x4506
callq 0x2842
movq %r12, %rdi
testq %r12, %r12
jne 0x44ef
movl 0x10(%rbx), %eax
movl 0x1c(%rbx), %ecx
movl %eax, 0x18(%rbx)
leal 0x1(%rcx), %eax
movl %eax, 0x1c(%rbx)
cmpl $0x9, %ecx
setge %al
orb %r15b, %al
testb $0x1, %al
je 0x4535
addl $-0x32, 0x14(%rbx)
movl $0x0, 0x1c(%rbx)
movl 0x10(%rbx), %eax
cmpl 0x20(%rbx), %eax
je 0x455a
incl %eax
movl %eax, 0x10(%rbx)
cmpq $0x0, 0x28(%rbx)
jne 0x445a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2429
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/read_write.c
// Function: wm
int			wm(long long n, void *dst, size_t l, t_process *p)
{
	size_t	i;
	char	*dest;
	t_arena	*a;

	if (l == 0)
		return (0);
	dest = (char *)(dst + l - 1);
	a = p->arena;
	i = 0;
	while (i < l)
	{
		if (dest >= a->memory + MEM_SIZE)
			dest -= MEM_SIZE;
		else if (dest < a->memory)
			dest += MEM_SIZE;
		if (a->display != NULL)
			save_for_display(p, (int)(dest - a->memory));
		*dest-- = (n & 0xFF);
		n >>= 8;
		i++;
	}
	return (i);
}

// Assembly:
testq %rdx, %rdx
je 0x4629
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
addq %rdx, %r15
movq 0x68(%rcx), %rbp
movq %rdx, (%rsp)
movq %rdx, %rbx
leaq -0x1(%r15), %rcx
movq (%rbp), %rax
leaq 0x1000(%rax), %rdx
leaq -0x1001(%r15), %rsi
addq $0xfff, %r15            # imm = 0xFFF
cmpq %rax, %rcx
cmovaeq %rcx, %r15
cmpq %rdx, %rcx
cmovaeq %rsi, %r15
cmpq $0x0, 0x30(%rbp)
je 0x460a
movq %r15, %r13
subq %rax, %r13
cmpl $0xfff, %r13d           # imm = 0xFFF
ja 0x460a
movq 0x68(%r14), %rsi
movl %r13d, %edi
callq 0x4d6c
testq %rax, %rax
je 0x460a
movb (%r14), %cl
movb %cl, (%rax)
movb $0x8, 0x1(%rax)
movq 0x68(%r14), %rax
movq 0x30(%rax), %rax
andl $0xfff, %r13d           # imm = 0xFFF
movb %cl, 0x38(%rax,%r13)
movb %r12b, (%r15)
sarq $0x8, %r12
decq %rbx
jne 0x459b
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/read_write.c
// Function: rm
long long	rm(char *src, size_t length, t_process *p)
{
	long long		n;
	long long		power;
	unsigned char	*ptr;

	n = 0;
	power = 1;
	ptr = (unsigned char *)src + (length - 1);
	while (length > 0)
	{
		if (ptr >= (unsigned char *)p->arena->memory + MEM_SIZE)
			ptr -= MEM_SIZE;
		else if (ptr < (unsigned char *)p->arena->memory)
			ptr += MEM_SIZE;
		n += ((long long)ptr[0]) * power;
		power <<= 8;
		length--;
		ptr--;
	}
	if ((n & (power >> 1)) != 0)
		while (power != 0x0)
		{
			n |= power;
			power <<= 1;
		}
	return (n);
}

// Assembly:
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x469e
addq %rsi, %rdi
movq 0x68(%rdx), %rax
movq (%rax), %rdx
leaq 0x1000(%rdx), %r8
movl $0x1, %ecx
xorl %eax, %eax
movl $0xfff, %r9d            # imm = 0xFFF
movq $-0x1001, %r10          # imm = 0xEFFF
leaq -0x1(%rdi), %r11
leaq (%rdi,%r9), %rbx
cmpq %rdx, %r11
movl $0x0, %r14d
adcq $-0x1, %r14
cmpq %rdx, %r11
cmovaeq %r11, %rbx
orq %r9, %r14
cmpq %r8, %r11
cmovaeq %r10, %r14
movzbl (%rdi,%r14), %r11d
leaq (%rdi,%r10), %rdi
cmovbq %rbx, %rdi
imulq %rcx, %r11
addq %r11, %rax
shlq $0x8, %rcx
decq %rsi
jne 0x4659
jmp 0x46a5
movl $0x1, %ecx
xorl %eax, %eax
movq %rcx, %rdx
sarq %rdx
testq %rax, %rdx
je 0x46b8
orq %rcx, %rax
addq %rcx, %rcx
jne 0x46b0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/check_player.c
// Function: check_player
void	check_player(char *argv)
{
	int		i;

	i = 0;
	if (argv == NULL)
	{
		ft_putendl_fd("Error: Positive number expected after -n.", 2);
		exit(1);
	}
	while (argv[i])
	{
		if (!(argv[i] >= '0' && argv[i] <= '9'))
		{
			ft_putendl_fd("Error: Positive number expected after -n.", 2);
			exit(1);
		}
		i++;
	}
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x46dc
movb (%rdi), %al
testb %al, %al
je 0x46da
incq %rdi
addb $-0x30, %al
cmpb $0xa, %al
jae 0x46dc
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x46cb
popq %rax
retq
leaq 0x2d72(%rip), %rdi      # 0x7455
movl $0x2, %esi
callq 0x53b0
movl $0x1, %edi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/check_player.c
// Function: check_display_and_n_flags
void	check_display_and_n_flags(char **argv)
{
	while (*++argv)
	{
		if (ft_strcmp("-n", *argv) == 0)
		{
			ft_putendl_fd("Flag -n cannot be used with flag -v", 2);
			exit(0);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
leaq 0x2981(%rip), %r14      # 0x708a
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x4739
movq %r14, %rdi
callq 0x5290
addq $0x8, %rbx
testl %eax, %eax
jne 0x4709
leaq 0x2d57(%rip), %rdi      # 0x747f
movl $0x2, %esi
callq 0x53b0
xorl %edi, %edi
callq 0x21e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/display.c
// Function: init_display
void		init_display(t_arena *arena)
{
	initscr();
	start_color();
	cbreak();
	noecho();
	curs_set(0);
	init_color(COLOR_WHITE, 400, 400, 400);
	init_pair(0, COLOR_WHITE, COLOR_BLACK);
	init_colors(arena->players);
	arena->display = (t_display *)ft_memalloc(sizeof(t_display));
	arena->display->updates = NULL;
	arena->display->running = 0;
	arena->display->quitting = 0;
	arena->display->cps = 50;
	init_mem_display(arena);
	attribute_src_code(arena);
	init_info_display(arena);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20b0
callq 0x20f0
callq 0x2160
callq 0x20a0
xorl %edi, %edi
callq 0x2060
movl $0x7, %edi
movl $0x190, %esi            # imm = 0x190
movl $0x190, %edx            # imm = 0x190
movl $0x190, %ecx            # imm = 0x190
callq 0x21a0
xorl %edi, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x50ee
movl $0x1038, %edi           # imm = 0x1038
callq 0x5348
movq %rax, 0x30(%rbx)
movq $0x0, (%rax)
movabsq $0x3200000000, %rcx     # imm = 0x3200000000
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x4e13
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x4888
leaq 0x28a1(%rip), %r14      # 0x7084
movq 0x30(%rbx), %rax
movq 0x28(%rax), %rdi
movl (%r15), %eax
leal (%rax,%rax,4), %eax
shll $0x9, %eax
addl $0x600, %eax            # imm = 0x600
movzwl %ax, %esi
xorl %edx, %edx
callq 0x2110
cmpl $0x0, 0x20(%r15)
je 0x485b
movl 0x28(%r15), %eax
subl (%rbx), %eax
movl %eax, %r12d
xorl %r13d, %r13d
movq (%rbx), %rax
movq 0x30(%rbx), %rcx
movq 0x28(%rcx), %rdi
leal (%r12,%r13), %ebp
movl %ebp, %esi
shrl $0x6, %esi
movl %ebp, %ecx
andl $0x3f, %ecx
leal (%rcx,%rcx,2), %edx
addl $0x9, %edx
movzbl (%rax,%rbp), %r8d
movq %r14, %rcx
xorl %eax, %eax
callq 0x20d0
movb (%r15), %al
movq 0x30(%rbx), %rcx
incq %r13
movb %al, 0x38(%rcx,%rbp)
movl 0x20(%r15), %eax
cmpq %rax, %r13
jb 0x4816
movq 0x30(%rbx), %rax
movq 0x28(%rax), %rdi
movl (%r15), %eax
leal (%rax,%rax,4), %eax
shll $0x9, %eax
addl $0x600, %eax            # imm = 0x600
movzwl %ax, %esi
xorl %edx, %edx
callq 0x2210
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x47e3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x496c
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/display.c
// Function: update_display
int			update_display(t_arena *arena)
{
	if (arena->display == NULL)
		return (1);
	highlight_rw(arena);
	highlight_pcs(arena);
	overwrite(arena->display->w_bkp, arena->display->w_mem);
	overlay(arena->display->w_pcs, arena->display->w_mem);
	wrefresh(arena->display->w_mem);
	regulate_speed(arena);
	return (!arena->display->quitting);
}

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x48fc
pushq %rbx
movq %rdi, %rbx
callq 0x4fb3
movq %rbx, %rdi
callq 0x4eea
movq 0x30(%rbx), %rax
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdi
callq 0x2140
movq 0x30(%rbx), %rax
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdi
callq 0x2190
movq 0x30(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x4c24
movq 0x30(%rbx), %rcx
xorl %eax, %eax
cmpl $0x0, 0x10(%rcx)
sete %al
popq %rbx
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/display.c
// Function: destroy_display
void		destroy_display(t_arena *arena)
{
	delwin(arena->display->w_mem);
	delwin(arena->display->w_info);
	delwin(arena->display->w_bkp);
	while (arena->display->updates != NULL)
		remove_update_struct(arena->display->updates, arena);
	free(arena->display);
	init_color(COLOR_WHITE, 680, 680, 680);
	endwin();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x2150
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
callq 0x2150
movq 0x30(%rbx), %rax
movq 0x28(%rax), %rdi
callq 0x2150
movq 0x30(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4943
movq %rbx, %rsi
callq 0x4deb
jmp 0x492d
movq %rax, %rdi
callq 0x2040
movl $0x7, %edi
movl $0x2a8, %esi            # imm = 0x2A8
movl $0x2a8, %edx            # imm = 0x2A8
movl $0x2a8, %ecx            # imm = 0x2A8
callq 0x21a0
popq %rbx
jmp 0x2200
nop
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/display_infos.c
// Function: init_info_display
void		init_info_display(t_arena *arena)
{
	int			line;
	t_player	*player;

	arena->display->w_info = newwin(30, 50, 10, 64 * 3 + 15);
	wtimeout(arena->display->w_info, 0);
	wprintw(arena->display->w_info,
			"Dumping memory at cycle %-5d (%d processus)"
			"\n\n\nCycles per second : %4d", 0, count_processes(arena), 0);
	player = arena->players;
	line = 5;
	while (player != NULL)
	{
		mvwprintw(arena->display->w_info, line, 0,
				"Player \n\tProcessus : %6d\n\tLast live: %6d", 1, 0);
		wattron(arena->display->w_info, COLOR_PAIR(player->id));
		mvwprintw(arena->display->w_info, line, 8, player->name);
		wattroff(arena->display->w_info, COLOR_PAIR(player->id));
		line += 4;
		player = player->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1e, %edi
movl $0x32, %esi
movl $0xa, %edx
movl $0xcf, %ecx
callq 0x2050
movq 0x30(%rbx), %rcx
movq %rax, 0x30(%rcx)
movq %rax, %rdi
xorl %esi, %esi
callq 0x2130
movq 0x30(%rbx), %rax
movq 0x30(%rax), %r14
movq %rbx, %rdi
callq 0x2871
leaq 0x2b13(%rip), %rsi      # 0x74cc
movq %r14, %rdi
xorl %edx, %edx
movl %eax, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x21f0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x4a5e
movl $0x5, %ebp
leaq 0x2b2f(%rip), %r14      # 0x7512
movl $0xffff, %r12d          # imm = 0xFFFF
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r14, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x20d0
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl (%r15), %esi
shll $0x8, %esi
andl %r12d, %esi
xorl %edx, %edx
callq 0x2110
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movq 0x8(%r15), %rcx
movl %ebp, %esi
movl $0x8, %edx
xorl %eax, %eax
callq 0x20d0
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl (%r15), %esi
shll $0x8, %esi
andl %r12d, %esi
xorl %edx, %edx
callq 0x2210
addl $0x4, %ebp
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x49e9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Orycterope[P]corewar/src/vm/display_infos.c
// Function: update_infos
void		update_infos(t_arena *a)
{
	t_player	*player;
	t_process	*p;
	int			line;
	int			i;

	mvwprintw(a->display->w_info, 0, 24, "%-5d (%d processus)",
			a->cycle, count_processes(a));
	mvwprintw(a->display->w_info, 3, 20, "%4d", a->display->cps);
	line = 6;
	player = a->players;
	while (player != NULL)
	{
		i = 0;
		p = a->processes;
		while (p != NULL)
		{
			if (p->player == player->id)
				i++;
			p = p->next;
		}
		mvwprintw(a->display->w_info, line, 20, "%6d", i);
		mvwprintw(a->display->w_info, line + 1, 20, "%6d", player->last_live);
		line += 4;
		player = player->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x30(%rax), %r14
movl 0x10(%rdi), %ebp
callq 0x2871
leaq 0x2ab3(%rip), %rcx      # 0x753b
movq %r14, %rdi
xorl %esi, %esi
movl $0x18, %edx
movl %ebp, %r8d
movl %eax, %r9d
xorl %eax, %eax
callq 0x20d0
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl 0xc(%rax), %r8d
leaq 0x2a5c(%rip), %rcx      # 0x750e
movl $0x3, %esi
movl $0x14, %edx
xorl %eax, %eax
callq 0x20d0
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x4b45
movl $0x6, %ebp
leaq 0x2a5f(%rip), %r14      # 0x7537
movq 0x28(%rbx), %rax
movl $0x0, %r8d
testq %rax, %rax
je 0x4b00
movl (%r15), %ecx
xorl %r8d, %r8d
xorl %edx, %edx
cmpl %ecx, (%rax)
sete %dl
addl %edx, %r8d
movq 0x70(%rax), %rax
testq %rax, %rax
jne 0x4aed
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl %ebp, %esi
movl $0x14, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x20d0
movq 0x30(%rbx), %rax
movq 0x30(%rax), %rdi
movl %ebp, %esi
orl $0x1, %esi
movl 0x30(%r15), %r8d
movl $0x14, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x20d0
addl $0x4, %ebp
movq 0x38(%r15), %r15
testq %r15, %r15
jne 0x4ad8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq