LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/arena.c
// Function: mem
char	*mem(char *ptr, int idx, t_arena *arena, t_process *process)
{
	int	temp;

	temp = ptr - process->pc;
	temp %= MEM_SIZE;
	if (idx)
		temp %= IDX_MOD;
	if (process->pc + temp < arena->memory)
		return (process->pc + temp + MEM_SIZE);
	if (process->pc + temp >= arena->memory + MEM_SIZE)
		return (process->pc + temp - MEM_SIZE);
	return (process->pc + temp);
}

// Assembly:
movq 0x48(%rcx), %rax
subl %eax, %edi
leal 0xfff(%rdi), %ecx
testl %edi, %edi
cmovnsl %edi, %ecx
andl $0xfffff000, %ecx       # imm = 0xFFFFF000
movl %edi, %r8d
subl %ecx, %r8d
negl %ecx
addl %edi, %ecx
addl $0x1ff, %ecx            # imm = 0x1FF
testw %r8w, %r8w
cmovnsl %r8d, %ecx
andl $0xfffffe00, %ecx       # imm = 0xFFFFFE00
movl %r8d, %edi
subl %ecx, %edi
testl %esi, %esi
movswl %di, %ecx
cmovel %r8d, %ecx
movslq %ecx, %rcx
addq %rax, %rcx
movq (%rdx), %rdx
movl $0x1000, %esi           # imm = 0x1000
leaq (%rdx,%rsi), %rdi
xorl %eax, %eax
cmpq %rdi, %rcx
setb %al
shll $0xc, %eax
addq $-0x1000, %rax          # imm = 0xF000
cmpq %rdx, %rcx
cmovbq %rsi, %rax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/arena.c
// Function: display_champions
void	display_champions(t_arena *arena)
{
	t_player	*i;

	ft_putendl("Introducing contestants...");
	i = arena->players;
	while (i != NULL)
	{
		ft_printf("* Player %d, weighing %d bytes, \"%s\" (\"%s\") !\n",
				i->id, i->champ_size, i->name, i->comment);
		i = i->next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4c41(%rip), %rdi      # 0x7020
callq 0x53f0
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2416
leaq 0x4c47(%rip), %rbx      # 0x703b
movl (%r14), %esi
movl 0x20(%r14), %edx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5470
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x23f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/arena.c
// Function: dump_memory
void	dump_memory(t_arena *arena)
{
	int			i;
	t_process	*p;

	p = arena->processes;
	ft_printf("\nDumping memory at cycle %d (%d processus):",
			arena->cycle, arena->processes->number);
	i = 0;
	while (i < MEM_SIZE)
	{
		p = arena->processes;
		if (i % 32 == 0 && i != MEM_SIZE - 1)
			ft_printf("\n%0#6x : ", i);
		ft_printf("%02x ", (unsigned char)arena->memory[i]);
		i++;
	}
	ft_putchar('\n');
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %esi
movq 0x28(%rdi), %rax
movl 0x5c(%rax), %edx
leaq 0x4c30(%rip), %rdi      # 0x706a
xorl %eax, %eax
callq 0x5470
leaq 0x4c4e(%rip), %r14      # 0x7096
leaq 0x4c51(%rip), %r15      # 0x70a0
xorl %r12d, %r12d
testb $0x1f, %r12b
jne 0x2465
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x5470
movq (%rbx), %rax
movzbl (%rax,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x5470
incq %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x2452
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x53d4
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/arena.c
// Function: destroy_arena
void	destroy_arena(t_arena *arena)
{
	if (arena->display != NULL)
		destroy_display(arena);
	while (arena->processes != NULL)
		kill_process(arena->processes);
	free_players(arena);
	free(arena->memory);
	free(arena);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x24b2
movq %rbx, %rdi
callq 0x493e
jmp 0x24b2
callq 0x282f
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
jne 0x24ad
movq %rbx, %rdi
callq 0x26d2
movq (%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/player.c
// Function: save_players
void			save_players(int ac, char **av, t_arena *arena)
{
	int			player_id;
	int			attempt;

	while (ac-- > 0)
	{
		player_id = 1;
		if (ft_strcmp("-n", av[0]) == 0)
		{
			check_player(av[1]);
			attempt = ft_atoi(av[1]);
			av += 2;
			ac -= 2;
			if (is_free_player_id(attempt, arena->players, ac, av))
				player_id = attempt;
		}
		else
			while (!is_free_player_id(player_id, arena->players, ac, av))
				player_id++;
		create_player(player_id, arena, av[0]);
		av++;
	}
}

// Assembly:
testl %edi, %edi
jle 0x25cf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x4bb0(%rip), %r15      # 0x70a6
movq (%r14), %rsi
movq %r15, %rdi
callq 0x52f0
testl %eax, %eax
je 0x2524
decl %ebp
xorl %r12d, %r12d
incl %r12d
movq 0x8(%rbx), %rsi
movl %r12d, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x25d0
testl %eax, %eax
je 0x250a
jmp 0x255b
movq 0x8(%r14), %rdi
callq 0x46f8
movq 0x8(%r14), %rdi
callq 0x530c
movl %eax, %r12d
addq $0x10, %r14
addl $-0x3, %ebp
movq 0x8(%rbx), %rsi
movl %eax, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x25d0
testl %eax, %eax
movl $0x1, %eax
cmovel %eax, %r12d
movq (%r14), %r13
movl $0x40, %edi
callq 0x539c
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x259b
cmpl %r12d, (%rcx)
jle 0x2580
movq %rcx, 0x38(%rax)
movq %rax, 0x8(%rbx)
jmp 0x25a7
movq %rcx, %rdx
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
je 0x2591
cmpl %r12d, (%rcx)
jl 0x2580
movq %rcx, 0x38(%rax)
movq %rax, 0x38(%rdx)
jmp 0x25a7
movq %rax, 0x8(%rbx)
movq $0x0, 0x38(%rax)
movl %r12d, (%rax)
movl $0x0, 0x30(%rax)
movq %r13, 0x18(%rax)
addq $0x8, %r14
testl %ebp, %ebp
jg 0x24f6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/player.c
// Function: is_free_player_id
static int		is_free_player_id(int id, t_player *p, int ac, char **av)
{
	if (id < 1)
		return (0);
	ac--;
	av++;
	while (p != NULL)
	{
		if (p->id == id)
			return (0);
		p = p->next;
	}
	while (ac-- > 0)
	{
		if (ft_strcmp("-n", av[0]) == 0)
		{
			if (ft_atoi(av[1]) == id)
				return (0);
			av += 2;
			ac -= 2;
		}
		av++;
	}
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testl %edi, %edi
jle 0x263a
movq %rcx, %r14
movl %edx, %ebp
movl %edi, %r15d
testq %rsi, %rsi
je 0x25f6
cmpl %r15d, (%rsi)
je 0x263a
movq 0x38(%rsi), %rsi
jmp 0x25e6
cmpl $0x2, %ebp
jl 0x2635
decl %ebp
leaq 0x4aa2(%rip), %r12      # 0x70a6
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x52f0
testl %eax, %eax
je 0x261c
addq $0x8, %r14
decl %ebp
jmp 0x2631
movq 0x10(%r14), %rdi
callq 0x530c
cmpl %r15d, %eax
je 0x263a
addq $0x18, %r14
addl $-0x3, %ebp
testl %ebp, %ebp
jg 0x2604
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/player.c
// Function: load_players
void			load_players(t_arena *arena)
{
	t_player	*i;
	int			n;
	int			total;

	total = 0;
	i = arena->players;
	while (i != NULL)
	{
		total++;
		i = i->next;
	}
	if (total < 1 || total > MAX_PLAYERS)
	{
		ft_putendl("Error : too many players");
		exit(1);
	}
	i = arena->players;
	n = 0;
	while (i != NULL)
	{
		i->begin = (arena->memory + n++ * MEM_SIZE / total);
		get_player_code(i);
		create_process(i->id, i->begin, arena, NULL);
		i = i->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x26bc
movq %rdi, %rbx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rax
movq 0x38(%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x2660
cmpl $0x3, %ebp
ja 0x26bc
testq %r14, %r14
je 0x26b1
incl %ebp
xorl %r15d, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl %ebp
addq (%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
callq 0x2a60
movl (%r14), %edi
movq 0x28(%r14), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2787
movq 0x38(%r14), %r14
addl $0x1000, %r15d          # imm = 0x1000
testq %r14, %r14
jne 0x267a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49e6(%rip), %rdi      # 0x70a9
callq 0x53f0
movl $0x1, %edi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/player.c
// Function: free_players
void			free_players(t_arena *arena)
{
	t_player	*next;
	t_player	*current;

	current = arena->players;
	while (current != NULL)
	{
		next = current->next;
		free(current->name);
		free(current->comment);
		free(current);
		current = next;
	}
	arena->players = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x2709
movq 0x8(%r14), %rdi
movq 0x38(%r14), %r15
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movq %r15, %r14
testq %r15, %r15
jne 0x26e3
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/process.c
// Function: create_copy_registers
void	create_copy_registers(t_process *p, t_process *parent, int player)
{
	int		i;

	i = -1;
	while (++i < REG_NUMBER)
	{
		if (parent == NULL)
		{
			if (i == 0)
				ft_write_big_endian(player, p->registers[0], REG_SIZE);
			else
				ft_bzero(p->registers[i], REG_SIZE);
		}
		else
			ft_memcpy(p->registers[i], parent->registers[i], REG_SIZE);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x4, %r14
leaq 0x4(%rsi), %r12
movslq %edx, %r15
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x274e
leaq (%r14,%r13), %rdi
leaq (%r12,%r13), %rsi
movl $0x4, %edx
callq 0x52c0
jmp 0x2773
testq %r13, %r13
je 0x2763
leaq (%r14,%r13), %rdi
movl $0x4, %esi
callq 0x52b0
jmp 0x2773
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x541c
addq $0x4, %r13
cmpq $0x40, %r13
jne 0x2735
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/process.c
// Function: create_process
void	create_process(int player, char *pc, t_arena *arena, t_process *parent)
{
	t_process	*new;
	static int	i = 0;

	i++;
	new = (t_process*)malloc(sizeof(t_process));
	if (new == NULL)
		return ;
	new->player = player;
	new->pc = pc;
	new->carry = (parent == NULL) ? 0 : parent->carry;
	new->lives = (parent == NULL) ? 0 : parent->lives;
	new->count_lives = 0;
	new->cycles_to_wait = -1;
	new->op_code = 0;
	new->arena = arena;
	new->next = arena->processes;
	new->number = i;
	create_copy_registers(new, parent, player);
	arena->processes = new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movl %edi, %ebp
movl 0x8c28(%rip), %r13d     # 0xb3cc
incl %r13d
movl %r13d, 0x8c1e(%rip)     # 0xb3cc
movl $0x78, %edi
callq 0x2180
testq %rax, %rax
je 0x2812
movq %rax, %r15
movl %ebp, (%rax)
movq %r12, 0x48(%rax)
testq %r14, %r14
je 0x27d5
movb 0x50(%r14), %al
movl 0x58(%r14), %ecx
jmp 0x27d9
xorl %eax, %eax
xorl %ecx, %ecx
movb %al, 0x50(%r15)
movl %ecx, 0x58(%r15)
movq $0x0, 0x60(%r15)
movl $0xffffffff, 0x54(%r15) # imm = 0xFFFFFFFF
movq %rbx, 0x68(%r15)
movq 0x28(%rbx), %rax
movq %rax, 0x70(%r15)
movl %r13d, 0x5c(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2718
movq %r15, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/process.c
// Function: kill_process
void	kill_process(t_process *process)
{
	t_process	*i;

	if (process->arena->processes == process)
		process->arena->processes = process->next;
	else
	{
		i = process->arena->processes;
		while (i->next != process)
			i = i->next;
		i->next = process->next;
	}
	free(process);
}

// Assembly:
movq 0x68(%rdi), %rax
movq 0x28(%rax), %rcx
cmpq %rdi, %rcx
je 0x284e
movq %rcx, %rax
movq 0x70(%rcx), %rcx
cmpq %rdi, %rcx
jne 0x283c
addq $0x70, %rax
jmp 0x2852
addq $0x28, %rax
movq 0x70(%rdi), %rcx
movq %rcx, (%rax)
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/vm/get_input.c
// Function: get_input
void				get_input(int fd, t_player *player, unsigned int *prog_size)
{
	int				ret;
	char			buf[BUFF_SIZE];
	int				i;

	i = 0;
	ret = 0;
	check_magic(fd, buf, ret, player);
	player->name = get_name(fd, buf, ret, i);
	*prog_size = get_prog_size(fd, buf, ret, i);
	if (*prog_size > CHAMP_MAX_SIZE)
	{
		ft_printf_fd(2,
				"Error: file %s has too large code(%d bytes > %d bytes)\n",
				player->file_name, *prog_size, CHAMP_MAX_SIZE);
		exit(1);
	}
	player->comment = get_comment(fd, buf, ret, i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
movb 0xf(%rsp), %al
movb %al, 0x10(%rsp,%r12)
incq %r12
cmpq $0x4, %r12
jne 0x2892
cmpl $0xf383ea00, 0x10(%rsp) # imm = 0xF383EA00
jne 0x2a23
movl $0x81, %edi
callq 0x539c
movq %rax, %r15
movb $0x0, 0x80(%rax)
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movl $0x1, %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
movb 0xf(%rsp), %al
movb %al, (%r15,%r13)
incq %r13
cmpq $0x80, %r13
jne 0x28e6
movl $0x4, %r13d
leaq 0xf(%rsp), %r12
movl $0x1, %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
decl %r13d
jne 0x291d
movq %r15, 0x8(%rbx)
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
movb 0xf(%rsp), %al
movb %al, 0x14(%rsp,%r12)
incq %r12
cmpq $0x4, %r12
jne 0x2946
leaq 0x14(%rsp), %rdi
movl $0x4, %esi
callq 0x5439
movl %eax, (%r14)
cmpl $0x2ab, %eax            # imm = 0x2AB
jae 0x2a3c
movl $0x801, %edi            # imm = 0x801
callq 0x539c
movq %rax, %r14
movb $0x0, 0x800(%rax)
xorl %r12d, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
movb 0xf(%rsp), %al
movb %al, (%r14,%r12)
incq %r12
cmpq $0x800, %r12            # imm = 0x800
jne 0x29a9
movl $0x4, %r12d
leaq 0xf(%rsp), %r15
movl $0x1, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2120
cmpl $-0x1, %eax
je 0x2a08
decl %r12d
jne 0x29dc
movq %r14, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x46eb(%rip), %rdi      # 0x70fa
movl $0x2, %esi
callq 0x5404
movl $0x1, %edi
callq 0x21e0
movq 0x18(%rbx), %rdx
leaq 0x46ec(%rip), %rsi      # 0x711a
movl $0x2, %edi
xorl %eax, %eax
callq 0x5624
jmp 0x2a19
movq 0x18(%rbx), %rdx
leaq 0x467b(%rip), %rsi      # 0x70c2
movl $0x2, %edi
movl %eax, %ecx
movl $0x2aa, %r8d            # imm = 0x2AA
xorl %eax, %eax
callq 0x5624
jmp 0x2a19
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2b02
movl %eax, %ebp
leaq 0xc(%rsp), %rdx
movl %eax, %edi
movq %rbx, %rsi
callq 0x2874
movq 0x28(%rbx), %r15
leaq 0xb(%rsp), %rsi
movl $0x1, %edx
movl %ebp, %edi
callq 0x2120
testq %rax, %rax
je 0x2adc
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 0x2aba
movq %r15, 0x28(%rbx)
movl 0xc(%rsp), %eax
cmpl 0x20(%rbx), %eax
jne 0x2b0f
movl %ebp, %edi
callq 0x2100
cmpl $-0x1, %eax
je 0x2b1c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rbx), %rdx
leaq 0x4634(%rip), %rsi      # 0x7141
jmp 0x2b27
movq 0x18(%rbx), %rdx
leaq 0x4644(%rip), %rsi      # 0x715e
jmp 0x2b27
movq 0x18(%rbx), %rdx
leaq 0x467f(%rip), %rsi      # 0x71a6
movl $0x2, %edi
xorl %eax, %eax
callq 0x5624
movl $0x1, %edi
callq 0x21e0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x238d
cmpl $0x1, %ebp
je 0x2cc8
movq %rax, %rbx
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rsi
leaq 0x4992(%rip), %rdi      # 0x74fe
callq 0x52f0
testl %eax, %eax
je 0x2bae
movq (%r15), %rsi
leaq 0x472c(%rip), %rdi      # 0x72ab
callq 0x52f0
testl %eax, %eax
je 0x2bc2
movq (%r15), %rsi
leaq 0x471f(%rip), %rdi      # 0x72b1
callq 0x52f0
testl %eax, %eax
jne 0x2c03
movl $0x1, 0x24(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x8, %ecx
jmp 0x2bfe
movq %r14, %rdi
callq 0x4733
movq $0x1, 0x30(%rbx)
decl %ebp
jmp 0x2c06
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x2cad
movb (%rdi), %al
testb %al, %al
je 0x2bec
leaq 0x1(%rdi), %rcx
addb $-0x30, %al
cmpb $0xa, %al
jae 0x2cad
movb (%rcx), %al
incq %rcx
testb %al, %al
jne 0x2bd9
callq 0x530c
movl %eax, 0x20(%rbx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl $0x10, %ecx
addq %rcx, %r14
addl %eax, %ebp
movq %r14, %r15
addq $0x8, %r15
decl %ebp
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x24d4
movq %rbx, %rdi
callq 0x2645
cmpq $0x0, 0x30(%rbx)
je 0x2c34
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4780
jmp 0x2c3c
movq %rbx, %rdi
callq 0x23d1
movq %rbx, %rdi
callq 0x4475
movl 0x10(%rbx), %eax
cmpl 0x20(%rbx), %eax
je 0x2c98
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2c5b
cmpl $0x0, 0x10(%rax)
je 0x2c90
movq 0x8(%rbx), %rax
movq %rax, %rcx
movl 0x30(%rcx), %edx
cmpl 0x30(%rax), %edx
cmovgeq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x2c62
movl 0x30(%rax), %esi
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rcx
leaq 0x465a(%rip), %rdi      # 0x72e1
xorl %eax, %eax
callq 0x5470
jmp 0x2c98
movq %rbx, %rdi
callq 0x4cb9
movq %rbx, %rdi
callq 0x2498
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4600(%rip), %rdi      # 0x72b4
movl $0x2, %esi
callq 0x5404
movl $0x1, %edi
callq 0x21e0
leaq 0x44f5(%rip), %rdi      # 0x71c4
movl $0x2, %esi
callq 0x5404
leaq 0x450c(%rip), %rdi      # 0x71ec
movl $0x2, %esi
callq 0x5404
leaq 0x452a(%rip), %rdi      # 0x721b
movl $0x2, %esi
callq 0x5404
leaq 0x454a(%rip), %rdi      # 0x724c
movl $0x2, %esi
callq 0x5404
leaq 0x456c(%rip), %rdi      # 0x727f
movl $0x2, %esi
callq 0x5404
leaq 0x4576(%rip), %rdi      # 0x729a
jmp 0x2cb4
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x83df(%rip), %rcx      # 0xb120
cmpl $0x0, 0x8(%rcx,%rax,8)
jle 0x2da2
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 0x2da2
shrl $0x2, %r12d
addl $-0x2, %ebp
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x2d64
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/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 0x8356(%rip), %rcx      # 0xb120
cmpl $0x0, 0x8(%rcx,%rax,8)
jle 0x2e8e
movq %rsi, %rbx
movq %rdi, %r14
leaq (%rcx,%rax,8), %r12
addq $0x8, %r12
movl $0x1, %r13d
movzbl -0x1(%rbx,%r13), %r15d
testl %r15d, %r15d
je 0x2e70
cmpl $0x1, %r15d
je 0x2e24
cmpl $0x2, %r15d
jne 0x2e29
movb 0x2c(%rbx), %al
addb $-0xa, %al
cmpb $0x5, %al
jae 0x2e36
movzbl %al, %eax
leaq 0x4635(%rip), %rcx      # 0x7448
movq (%rcx,%rax,8), %rbp
leaq 0x4652(%rip), %rcx      # 0x7470
movl (%rcx,%rax,4), %r15d
jmp 0x2e41
movq %r15, %rbp
jmp 0x2e41
movl $0x2, %r15d
movl $0x2, %ebp
jmp 0x2e41
movl $0x4, %r15d
movl $0x4, %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 %rbp, %rsi
movq %r14, %rdx
callq 0x4668
movq %rax, (%rbx,%r13,8)
addl %r15d, 0x28(%rbx)
leaq -0x1(%r13), %rax
cmpq $0x2, %rax
ja 0x2e8e
movslq (%r12), %rax
leaq 0x1(%r13), %rcx
cmpq %rax, %r13
movq %rcx, %r13
jl 0x2de9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Orycterope[P]corewar/src/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 0x8275(%rip), %rcx      # 0xb120
movl 0x8(%rcx,%rax,8), %ecx
testl %ecx, %ecx
jle 0x2ee1
decl %ecx
cmpl $0x3, %ecx
movl $0x3, %eax
cmovbl %ecx, %eax
incl %eax
xorl %ecx, %ecx
cmpb $0x1, (%rdi,%rcx)
jne 0x2ed9
movq 0x8(%rdi,%rcx,8), %rdx
addq $-0x11, %rdx
cmpq $-0x10, %rdx
jb 0x2ee4
incq %rcx
cmpq %rcx, %rax
jne 0x2ec4
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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), %edx
leaq 0x822c(%rip), %rax      # 0xb120
movsbl 0x10(%rax), %ecx
cmpl %ecx, %edx
jne 0x2f02
xorl %esi, %esi
xorl %ecx, %ecx
jmp 0x2f22
leaq 0x8217(%rip), %rax      # 0xb120
xorl %ecx, %ecx
cmpq $0x0, (%rax)
je 0x2f32
incq %rcx
movsbl 0x38(%rax), %esi
addq $0x28, %rax
cmpl %esi, %edx
jne 0x2f0b
movl %ecx, %esi
cmpq $0x0, (%rax)
je 0x2f32
leaq 0x7e21(%rip), %rax      # 0xad50
jmpq *(%rax,%rcx,8)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x81d5(%rip), %rsi      # 0xb120
movslq 0x8(%rsi,%rax,8), %rdx
testq %rdx, %rdx
jle 0x2f88
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movzbl %r8b, %r9d
leal -0x1(%r9), %r10d
cmpl $0x2, %r10d
jb 0x2f7c
cmpl $0x3, %r9d
je 0x2f79
testl %r9d, %r9d
je 0x2f88
xorl %r8d, %r8d
jmp 0x2f7c
movb $0x4, %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rdx
jne 0x2f57
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 0x2fbe
movb (%rcx,%rdx), %r8b
leaq 0x1(%rdx), %r9
testb %r8b, 0xc(%rsi,%rdx)
movq %r9, %rdx
jne 0x2fa2
movl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4668
movl $0x1, 0x58(%rbx)
incl 0x60(%rbx)
movq 0x68(%rbx), %rdx
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x302f
movslq (%rcx), %rsi
cmpq %rsi, %rax
je 0x3011
movq 0x38(%rcx), %rcx
jmp 0x2ffe
movl 0x10(%rdx), %eax
movl %eax, 0x30(%rcx)
cmpl $0x1, 0x24(%rdx)
jne 0x302f
movq 0x8(%rcx), %rsi
leaq 0x445c(%rip), %rdi      # 0x7484
xorl %eax, %eax
callq 0x5470
movl $0x5, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x80b7(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x312b
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x3173
cmpb $0x1, 0x31(%rsp)
jne 0x3173
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 0x2f38
cmpl $0x1, %eax
je 0x3173
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jbe 0x3173
movzbl 0x30(%rsp), %eax
cmpl $0x1, %eax
je 0x3132
cmpl $0x3, %eax
jne 0x314f
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 0x4668
jmp 0x3145
movl $0x1, %eax
jmp 0x3177
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, %rdi
movq %rax, 0x38(%rsp)
jmp 0x3154
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x541c
movl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x4432
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7f69(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x325e
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x32f2
leaq (%r12,%r15,8), %r14
cmpl $0x2, 0x8(%r14)
jl 0x32f2
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 0x2f38
cmpl $0x1, %eax
je 0x32f2
cmpl $0x5, 0x8(%r14)
jge 0x32f2
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x3268
cmpl $0x1, %eax
jne 0x3297
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
jmp 0x3292
movl $0x1, %eax
jmp 0x32f6
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 0x4668
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x3, %eax
je 0x32c0
cmpl $0x1, %eax
jne 0x32f2
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x541c
jmp 0x32f2
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 0x45ac
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7dea(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x33e8
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x34a6
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x34a6
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 0x2f38
cmpl $0x1, %eax
je 0x34a6
cmpl $0x4, 0x8(%r14)
jg 0x34a6
cmpb $0x1, 0x32(%rsp)
jne 0x34a6
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x33f2
cmpl $0x1, %eax
jne 0x3421
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
jmp 0x341c
movl $0x1, %eax
jmp 0x34aa
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 0x4668
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x1, %eax
je 0x345c
cmpl $0x3, %eax
jne 0x3479
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 0x4668
jmp 0x346f
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, %rdi
movq %rax, 0x40(%rsp)
jmp 0x347e
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x541c
movl 0x40(%rsp), %esi
addl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x4432
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7a81(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x374a
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x3808
cmpb $0x1, 0x32(%rsp)
jne 0x3808
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 0x2f38
cmpl $0x1, %eax
je 0x3808
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x3, %eax
jbe 0x3808
movzbl 0x30(%rsp), %eax
cmpl $0x3, %eax
je 0x3754
cmpl $0x1, %eax
jne 0x3783
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
jmp 0x377e
movl $0x1, %eax
jmp 0x380c
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 0x4668
movq %rax, 0x38(%rsp)
movzbl 0x31(%rsp), %eax
cmpl $0x1, %eax
je 0x37be
cmpl $0x3, %eax
jne 0x37db
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 0x4668
jmp 0x37d1
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, %rdi
movq %rax, 0x40(%rsp)
jmp 0x37e0
movq 0x40(%rsp), %rdi
andq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x541c
movl 0x40(%rsp), %esi
andl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x4432
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x7528(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3cbb
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x3d51
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x3d51
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 0x2f38
cmpl $0x1, %eax
je 0x3d51
cmpl $0x5, 0x8(%r14)
jge 0x3d51
cmpb $0x1, 0x30(%rsp)
jne 0x3c9a
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x31(%rsp)
jne 0x3cc5
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, 0x40(%rsp)
jmp 0x3cca
movl $0x1, %eax
jmp 0x3d55
movq 0x40(%rsp), %rax
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
addq %rax, %rdi
movl $0x1, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x4668
movq %rax, %r14
movq %rax, 0x38(%rsp)
movzbl 0x32(%rsp), %eax
cmpl $0x3, %eax
je 0x3d26
cmpl $0x1, %eax
jne 0x3d51
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x541c
jmp 0x3d51
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 0x45ac
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_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x731e(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x3ec1
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x3f09
cmpb $0x1, 0x31(%rsp)
jne 0x3f09
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 0x2f38
cmpl $0x1, %eax
je 0x3f09
leaq (%r12,%r15,8), %rax
movl 0x8(%rax), %eax
addl $-0x5, %eax
cmpl $-0x4, %eax
jbe 0x3f09
movzbl 0x30(%rsp), %eax
cmpl $0x1, %eax
je 0x3ec8
cmpl $0x3, %eax
jne 0x3ee5
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 0x4668
jmp 0x3edb
movl $0x1, %eax
jmp 0x3f0d
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, %rdi
movq %rax, 0x38(%rsp)
jmp 0x3eea
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
callq 0x541c
movl 0x38(%rsp), %esi
movq %rbx, %rdi
callq 0x4432
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x71d3(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x4010
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x40a0
leaq (%r12,%r15,8), %r14
cmpl $0x3, 0x8(%r14)
jl 0x40a0
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 0x2f38
cmpl $0x1, %eax
je 0x40a0
cmpl $0x5, 0x8(%r14)
jge 0x40a0
cmpb $0x1, 0x30(%rsp)
jne 0x3fef
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x31(%rsp)
jne 0x401a
movq 0x40(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, 0x40(%rsp)
jmp 0x401f
movl $0x1, %eax
jmp 0x40a4
movq 0x40(%rsp), %rax
movq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rdx
addq 0x38(%rsp), %rdi
addq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x231c
movl $0x4, %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x4668
movq %rax, %r14
movq %rax, 0x38(%rsp)
movzbl 0x32(%rsp), %eax
cmpl $0x3, %eax
je 0x4078
cmpl $0x1, %eax
jne 0x40a0
movq 0x48(%rsp), %rax
leaq (%rbx,%rax,4), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x541c
jmp 0x40a0
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 0x45ac
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d28
movslq %ebp, %rax
leaq (%rax,%rax,4), %r15
leaq 0x6feb(%rip), %r12      # 0xb120
movl 0x20(%r12,%r15,8), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x28(%r14)
testl %eax, %eax
je 0x41eb
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2db1
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e9d
cmpl $0x1, %eax
je 0x4219
leaq (%r12,%r15,8), %r14
cmpl $0x4, 0x8(%r14)
jg 0x4219
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 0x2f38
cmpl $0x1, %eax
je 0x4219
cmpl $0x0, 0x8(%r14)
jle 0x4219
movzbl 0x30(%rsp), %eax
cmpl $0x1, %eax
je 0x41f2
cmpl $0x3, %eax
jne 0x420c
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 0x4668
jmp 0x4205
movl $0x1, %eax
jmp 0x421d
movq 0x38(%rsp), %rax
leaq (%rbx,%rax,4), %rdi
movl $0x4, %esi
callq 0x5439
movq %rax, 0x38(%rsp)
jmp 0x4211
movq 0x38(%rsp), %rax
movsbl %al, %edi
callq 0x53d4
movl 0x58(%rsp), %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop