LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/get_input.c
// Function: get_prog_size
static unsigned int	get_prog_size(int fd, char *buf, int ret, int i)
{
	char	size[4];

	while (i < 4)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		else
			size[i] = buf[0];
		i++;
	}
	return (ft_read_big_endian(size, 4));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x2fe8
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2fcf
leaq 0x7123(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
movb (%rax), %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x1c(%rbp,%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2f95
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
callq 0x7280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/get_input.c
// Function: get_comment
static char			*get_comment(int fd, char *buf, int ret, int i)
{
	char	*comment;

	comment = ft_memalloc(COMMENT_LENGTH + 1);
	comment[COMMENT_LENGTH] = '\0';
	while (i < COMMENT_LENGTH)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		else
			comment[i] = buf[0];
		i++;
	}
	while (i < COMMENT_LENGTH + 4)
	{
		if ((ret = read(fd, buf, BUFF_SIZE)) == -1)
		{
			ft_putendl_fd("Error : The reading has failed.", 2);
			exit(1);
		}
		i++;
	}
	return (comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x801, %edi            # imm = 0x801
callq 0x70f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x800(%rax)
cmpl $0x800, -0x18(%rbp)     # imm = 0x800
jge 0x3087
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x306b
leaq 0x7087(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
movb (%rax), %dl
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x302e
jmp 0x3089
cmpl $0x804, -0x18(%rbp)     # imm = 0x804
jge 0x30d1
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x30c6
leaq 0x702c(%rip), %rdi      # 0xa0de
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3089
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x21a0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x3135
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x2, %edi
leaq 0x7001(%rip), %rsi      # 0xa125
movb $0x0, %al
callq 0x75c0
movl $0x1, %edi
callq 0x21d0
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x2d00
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rdx
addq $0x20, %rdx
callq 0x31e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x3199
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x2, %edi
leaq 0x6fba(%rip), %rsi      # 0xa142
movb $0x0, %al
callq 0x75c0
movl $0x1, %edi
callq 0x21d0
movl -0xc(%rbp), %edi
callq 0x20f0
cmpl $-0x1, %eax
jne 0x31cb
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x2, %edi
leaq 0x6fd0(%rip), %rsi      # 0xa18a
movb $0x0, %al
callq 0x75c0
movl $0x1, %edi
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/get_player_code.c
// Function: read_prog
static char	*read_prog(int fd, char *memory, unsigned int *prog_size_read)
{
	int		i;
	int		ret;
	char	buf[BUFF_SIZE];

	i = 0;
	while ((ret = read(fd, buf, BUFF_SIZE) != 0))
	{
		if (ret == -1)
		{
			ft_putendl_fd("Error: The reading has failed.", 2);
			exit(1);
		}
		memory[i] = buf[0];
		*prog_size_read += 1;
		i++;
	}
	return (memory);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x2110
cmpq $0x0, %rax
setne %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x20(%rbp)
testb $0x1, %al
jne 0x3223
jmp 0x3268
cmpl $-0x1, -0x20(%rbp)
jne 0x3244
leaq 0x6f78(%rip), %rdi      # 0xa1a8
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movb -0x21(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x31fa
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x23e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3350
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2610
movq -0x18(%rbp), %rdi
callq 0x28f0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x32e1
movq -0x18(%rbp), %rdi
movb $0x0, %al
callq 0x5e20
jmp 0x32ea
movq -0x18(%rbp), %rdi
callq 0x2480
movq -0x18(%rbp), %rdi
callq 0x5830
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
je 0x3332
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3327
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x10(%rax)
jne 0x3327
movq -0x18(%rbp), %rdi
callq 0x6610
jmp 0x3330
movq -0x18(%rbp), %rdi
callq 0x3460
jmp 0x3332
movq -0x18(%rbp), %rdi
callq 0x25b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/main.c
// Function: check_param
static void		check_param(int *argc, char ***argv, t_arena *arena)
{
	if (*argc == 1)
	{
		ft_putendl_fd("Error: No parameters. Expected entry :\n", 2);
		ft_putendl_fd("./corewar [-dump N] [[-n N] champion1.cor] ...", 2);
		ft_putendl_fd("-dump N : Dumps memory after N cycles then exits", 2);
		ft_putendl_fd("-n N : The following champion will be the number N", 2);
		ft_putendl_fd("-v : Display corewar arena", 2);
		ft_putendl_fd("-l : Print lives", 2);
		exit(1);
	}
	if (ft_strcmp("-v", (*argv)[1]) == 0)
	{
		check_display_and_n_flags(*argv);
		arena->display = (t_display *)1;
		*argv += 1;
		*argc -= 1;
	}
	else
		check_param2(argc, argv, arena);
	*argv += 1;
	*argc -= 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x33dd
leaq 0x6e53(%rip), %rdi      # 0xa1c7
movl $0x2, %esi
callq 0x71c0
leaq 0x6e6a(%rip), %rdi      # 0xa1ef
movl $0x2, %esi
callq 0x71c0
leaq 0x6e88(%rip), %rdi      # 0xa21e
movl $0x2, %esi
callq 0x71c0
leaq 0x6ea8(%rip), %rdi      # 0xa24f
movl $0x2, %esi
callq 0x71c0
leaq 0x6eca(%rip), %rdi      # 0xa282
movl $0x2, %esi
callq 0x71c0
leaq 0x6ed4(%rip), %rdi      # 0xa29d
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x70d0(%rip), %rdi      # 0xa4bf
callq 0x6f10
cmpl $0x0, %eax
jne 0x342d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5dc0
movq -0x18(%rbp), %rax
movl $0x1, %ecx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x343e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x34e0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/main.c
// Function: print_winner
static void		print_winner(t_arena *arena)
{
	t_player	*p;
	t_player	*best;

	best = arena->players;
	p = arena->players;
	while (p != NULL)
	{
		if (p->last_live >= best->last_live)
			best = p;
		p = p->next;
	}
	ft_printf("The fight has ended with the last survivor dying at cycle %d.\n"
		"The winner is %s ! Its last words : \"%s\".\n",
		best->last_live, best->name, best->comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34b1
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jl 0x34a3
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3484
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x6e15(%rip), %rdi      # 0xa2e4
movb $0x0, %al
callq 0x7320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/main.c
// Function: check_param2
static void		check_param2(int *argc, char ***argv, t_arena *arena)
{
	if (ft_strcmp("-dump", (*argv)[1]) == 0)
	{
		check_dump(*argv, arena);
		*argv += 2;
		*argc -= 2;
	}
	else if (ft_strcmp("-l", (*argv)[1]) == 0)
	{
		arena->print_lives = 1;
		*argv += 1;
		*argc -= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x6da8(%rip), %rdi      # 0xa2ae
callq 0x6f10
cmpl $0x0, %eax
jne 0x353b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3590
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x357d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x6d67(%rip), %rdi      # 0xa2b4
callq 0x6f10
cmpl $0x0, %eax
jne 0x357b
movq -0x18(%rbp), %rax
movl $0x1, 0x24(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x357d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/main.c
// Function: check_dump
static void		check_dump(char **argv, t_arena *arena)
{
	int		i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x35cd
leaq 0x6cfe(%rip), %rdi      # 0xa2b7
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
jmp 0x35cf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3631
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x360b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x3626
leaq 0x6ca5(%rip), %rdi      # 0xa2b7
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35cf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6f90
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xc0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x6, -0x1c(%rbp)
movl -0x24(%rbp), %ecx
movslq -0x14(%rbp), %rax
leaq 0x9a9a(%rip), %rdx      # 0xd120
imulq $0x28, %rax, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x25(%rbp)
jge 0x36a1
cmpl $0x4, -0x24(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x36aa
jmp 0x370a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movsbl (%rax), %eax
andl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
sarl %cl, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3678
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movslq -0x1c(%rbp), %rax
leaq 0x980c(%rip), %rdx      # 0xd120
imulq $0x28, %rax, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x21(%rbp)
jge 0x392f
cmpl $0x4, -0x20(%rbp)
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3938
jmp 0x39a8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x399a
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
subq $0x1, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
je 0x398f
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x10, 0x8(%rax,%rcx,8)
jg 0x398f
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x1, 0x8(%rax,%rcx,8)
jge 0x3998
movl $0x1, -0x4(%rbp)
jmp 0x39af
jmp 0x399a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3906
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x9742(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsbl 0x10(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x64(%rdx), %ecx
movb %al, -0x15(%rbp)
je 0x3a13
movslq -0x14(%rbp), %rcx
leaq 0x971e(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x3a1c
jmp 0x3a27
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39d3
movslq -0x14(%rbp), %rcx
leaq 0x96ee(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x3a48
movl $0x1, -0x4(%rbp)
jmp 0x3a63
movslq -0x14(%rbp), %rcx
leaq 0x997d(%rip), %rax      # 0xd3d0
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movslq -0x8(%rbp), %rax
leaq 0x968c(%rip), %rdx      # 0xd120
imulq $0x28, %rax, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x19(%rbp)
jge 0x3aba
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3ac6
jmp 0x3b60
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jne 0x3aef
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x1, (%rax,%rcx)
jmp 0x3b5b
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2, %eax
jne 0x3b18
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x2, (%rax,%rcx)
jmp 0x3b59
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3, %eax
jne 0x3b41
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x4, (%rax,%rcx)
jmp 0x3b57
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x3b59
jmp 0x3b5b
jmp 0x3a86
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq -0x8(%rbp), %rax
leaq 0x95a5(%rip), %rdx      # 0xd120
imulq $0x28, %rax, %rax
addq %rax, %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x1a(%rbp)
jge 0x3b96
cmpl $0x4, -0xc(%rbp)
setl %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x3b9f
jmp 0x3bd8
movq -0x18(%rbp), %rcx
movslq -0x8(%rbp), %rdx
leaq 0x9572(%rip), %rax      # 0xd120
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movslq -0xc(%rbp), %rdx
movsbl 0xc(%rax,%rdx), %eax
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x3bd6
movl $0x1, -0x4(%rbp)
jmp 0x3bdf
jmp 0x3b67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movb $0x2, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq %rax, %rdi
movq -0x8(%rbp), %rdx
movl $0x4, %esi
callq 0x5c10
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x48(%rbp)
movb %al, -0x49(%rbp)
je 0x3c88
movq -0x48(%rbp), %rax
movslq (%rax), %rax
cmpq -0x38(%rbp), %rax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3c91
jmp 0x3c9f
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x3c6b
cmpq $0x0, -0x48(%rbp)
je 0x3cde
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movl 0x10(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
cmpl $0x1, 0x24(%rax)
jne 0x3cdc
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x6770(%rip), %rdi      # 0xa445
movb $0x0, %al
callq 0x7320
jmp 0x3cde
movl $0x5, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb $0x2, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3650
movslq -0x14(%rbp), %rcx
leaq 0x93ff(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x93e4(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x3d55
movl $0x1, -0x4(%rbp)
jmp 0x3e91
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3710
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x38f0
cmpl $0x1, %eax
je 0x3dda
movsbl -0x47(%rbp), %eax
cmpl $0x1, %eax
jne 0x3dda
movl -0x14(%rbp), %edi
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3a70
cmpl $0x1, %eax
je 0x3dda
movslq -0x14(%rbp), %rcx
leaq 0x936b(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jl 0x3dda
movslq -0x14(%rbp), %rcx
leaq 0x9353(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jle 0x3de5
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3e91
movsbl -0x48(%rbp), %eax
cmpl $0x1, %eax
jne 0x3e15
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x40(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x7280
movq %rax, -0x40(%rbp)
jmp 0x3e57
movsbl -0x48(%rbp), %eax
cmpl $0x3, %eax
jne 0x3e55
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x4, %esi
callq 0x5c10
movq %rax, -0x40(%rbp)
jmp 0x3e57
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x38(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x71f0
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %esi
callq 0x5760
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/instructions_p2.c
// Function: zjump
int		zjump(t_process *process, int i)
{
	t_parameters	param;

	i += 1;
	param.o = 9;
	param.type[0] = IND_CODE;
	param.value[0] = rm(mem(process->pc + 1, 1, PA, process), IND_SIZE, PP);
	if (process->carry == 1)
		return ((short)PV[0] % IDX_MOD);
	return (1 + IND_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movb $0x9, -0x1c(%rbp)
movb $0x3, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x5c10
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x50(%rax), %eax
cmpl $0x1, %eax
jne 0x4bf6
movq -0x40(%rbp), %rax
cwtl
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
jmp 0x4bfd
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/instructions_p3.c
// Function: ft_fork
int		ft_fork(t_process *process, int i)
{
	t_parameters	param;

	i += 1;
	param.o = 12;
	param.type[0] = DIR_CODE;
	param.value[0] = rm(mem(process->pc + 1, 1, PA, process), IND_SIZE, PP);
	fork_process(process, mem(PC + (short)PV[0] % IDX_MOD, 1, PA, process));
	return (1 + IND_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movb $0xc, -0x14(%rbp)
movb $0x2, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq %rax, %rdi
movq -0x8(%rbp), %rdx
movl $0x2, %esi
callq 0x5c10
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x38(%rbp), %rax
cwtl
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
movslq %edx, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2c00
movl $0x3, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb $0x2, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3650
movslq -0x14(%rbp), %rcx
leaq 0x821f(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x8204(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x4f35
movl $0x1, -0x4(%rbp)
jmp 0x506e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3710
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x38f0
cmpl $0x1, %eax
je 0x4fba
movsbl -0x47(%rbp), %eax
cmpl $0x1, %eax
jne 0x4fba
movl -0x14(%rbp), %edi
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3a70
cmpl $0x1, %eax
je 0x4fba
movslq -0x14(%rbp), %rcx
leaq 0x818b(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jl 0x4fba
movslq -0x14(%rbp), %rcx
leaq 0x8173(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jle 0x4fc5
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x506e
movsbl -0x48(%rbp), %eax
cmpl $0x1, %eax
jne 0x4ff5
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x40(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x7280
movq %rax, -0x40(%rbp)
jmp 0x5034
movsbl -0x48(%rbp), %eax
cmpl $0x3, %eax
jne 0x5032
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rcx
xorl %esi, %esi
callq 0x2310
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x4, %esi
callq 0x5c10
movq %rax, -0x40(%rbp)
jmp 0x5034
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x38(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x71f0
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movl %eax, %esi
callq 0x5760
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/instructions_p3.c
// Function: long_fork
int		long_fork(t_process *process, int i)
{
	t_parameters	param;

	i += 1;
	param.o = 15;
	param.type[0] = DIR_CODE;
	param.value[0] = rm(mem(process->pc + 1, 0, PA, process), IND_SIZE, PP);
	fork_process(process, mem(process->pc + (short)PV[0], 0, PA, process));
	return (1 + IND_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movb $0xf, -0x14(%rbp)
movb $0x2, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x1, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
xorl %esi, %esi
callq 0x2310
movq %rax, %rdi
movq -0x8(%rbp), %rdx
movl $0x2, %esi
callq 0x5c10
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x38(%rbp), %rax
cwtl
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x8(%rbp), %rcx
xorl %esi, %esi
callq 0x2310
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2c00
movl $0x3, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb $0x10, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3650
movslq -0x14(%rbp), %rcx
leaq 0x7dbf(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x7da4(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x20(%rax)
jne 0x5395
movl $0x1, -0x4(%rbp)
jmp 0x54ac
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rsi
callq 0x3710
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x38f0
cmpl $0x1, %eax
je 0x5411
movslq -0x14(%rbp), %rcx
leaq 0x7d5b(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x4, 0x8(%rax)
jg 0x5411
movl -0x14(%rbp), %edi
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3a70
cmpl $0x1, %eax
je 0x5411
movslq -0x14(%rbp), %rcx
leaq 0x7d1c(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x8(%rax)
jge 0x541c
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x54ac
movsbl -0x48(%rbp), %eax
cmpl $0x1, %eax
jne 0x544c
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x40(%rbp), %rax
subq $0x1, %rax
shlq $0x2, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x7280
movq %rax, -0x40(%rbp)
jmp 0x548e
movsbl -0x48(%rbp), %eax
cmpl $0x3, %eax
jne 0x548c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
addq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x2310
movq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0x4, %esi
callq 0x5c10
movq %rax, -0x40(%rbp)
jmp 0x548e
movq -0x40(%rbp), %rax
movl $0x100, %ecx            # imm = 0x100
cqto
idivq %rcx
movb %dl, %al
movsbl %al, %edi
callq 0x7160
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x64(%rax)
movslq -0x10(%rbp), %rcx
leaq 0x7958(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x582a
movslq -0x10(%rbp), %rcx
leaq 0x7940(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsbl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x581f
movslq -0x10(%rbp), %rcx
leaq 0x7925(%rip), %rax      # 0xd120
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x54(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x64(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x57bd
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, -0xd(%rbp)
je 0x585e
movq -0x8(%rbp), %rdi
callq 0x6020
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0x586a
jmp 0x5913
movq -0x8(%rbp), %rdi
callq 0x5920
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0x14(%rdx), %ecx
cmpl %ecx, %eax
jl 0x58e6
movq -0x8(%rbp), %rdi
callq 0x59c0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5a10
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
cmpl $0xa, 0x1c(%rax)
jge 0x58cc
cmpl $0x15, -0xc(%rbp)
jl 0x58e4
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x32, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x58e6
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x5901
movq -0x8(%rbp), %rdi
callq 0x24f0
jmp 0x5913
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x583c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/execution.c
// Function: execute_processes
static void		execute_processes(t_arena *arena)
{
	t_process	*p;

	p = arena->processes;
	while (p != NULL)
	{
		if (p->cycles_to_wait < 0)
			get_wait_time(&p);
		if (p->cycles_to_wait <= 0)
			p->pc = mem(p->pc + execute_instruction(p), 0, arena, p);
		p->cycles_to_wait--;
		p = p->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59af
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jge 0x5952
leaq -0x10(%rbp), %rdi
callq 0x5790
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jg 0x5994
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39c0
movq -0x18(%rbp), %rdi
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
xorl %esi, %esi
callq 0x2310
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5938
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/execution.c
// Function: count_lives
static int		count_lives(t_arena *arena)
{
	t_process	*p;
	int			count;

	count = 0;
	p = arena->processes;
	while (p != NULL)
	{
		count += p->count_lives;
		p = p->next;
	}
	return (count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59fd
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x59db
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/execution.c
// Function: check_processes
static void		check_processes(t_arena *arena)
{
	t_process	*p;
	t_process	*next;

	p = arena->processes;
	while (p != NULL)
	{
		next = p->next;
		if (p->lives == 0)
			kill_process(p);
		else
		{
			p->count_lives = 0;
			p->lives = 0;
		}
		p = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5a70
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x5a50
movq -0x10(%rbp), %rdi
callq 0x2c40
jmp 0x5a66
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5a28
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5aab
movl $0x0, -0x4(%rbp)
jmp 0x5b86
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5b7f
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x5b04
movq -0x38(%rbp), %rax
addq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x38(%rbp)
jmp 0x5b21
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5b1f
movq -0x38(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x38(%rbp)
jmp 0x5b21
movq -0x40(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x5b45
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x5b90
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5acf
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/read_write.c
// Function: save_for_display
static void	save_for_display(t_process *p, int index)
{
	t_d_update	*u;

	if (index < 0 || index >= MEM_SIZE)
		return ;
	u = get_update_struct_of(index, p->arena);
	if (u == NULL)
		return ;
	u->owner = p->player;
	u->w_turns = D_WRITE_TURNS;
	p->arena->display->owner_tab[index] = (char)p->player;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x5bae
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jl 0x5bb0
jmp 0x5bff
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x6760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5bcd
jmp 0x5bff
movq -0x8(%rbp), %rax
movl (%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb $0x8, 0x1(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, 0x38(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x5cd7
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x68(%rcx), %rcx
movq (%rcx), %rcx
addq $0x1000, %rcx           # imm = 0x1000
cmpq %rcx, %rax
jb 0x5c79
movq -0x30(%rbp), %rax
addq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x30(%rbp)
jmp 0x5c9a
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x68(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x5c98
movq -0x30(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x30(%rbp)
jmp 0x5c9a
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
imulq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5c43
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
sarq %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x5d0f
jmp 0x5ced
cmpq $0x0, -0x28(%rbp)
je 0x5d0d
movq -0x28(%rbp), %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
jmp 0x5ced
jmp 0x5d0f
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5d55
leaq 0x4733(%rip), %rdi      # 0xa474
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
jmp 0x5d57
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x5dad
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x5d87
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x5da2
leaq 0x46e6(%rip), %rdi      # 0xa474
movl $0x2, %esi
callq 0x71c0
movl $0x1, %edi
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5d57
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)