LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/check_player.c
// Function: check_display_and_n_flags
void	check_display_and_n_flags(char **argv)
{
	while (*++argv)
	{
		if (ft_strcmp("-n", *argv) == 0)
		{
			ft_putendl_fd("Flag -n cannot be used with flag -v", 2);
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x5e14
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x429a(%rip), %rdi      # 0xa08a
callq 0x6f10
cmpl $0x0, %eax
jne 0x5e12
leaq 0x469d(%rip), %rdi      # 0xa49e
movl $0x2, %esi
callq 0x71c0
xorl %edi, %edi
callq 0x21d0
jmp 0x5dcc
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display.c
// Function: init_display
void		init_display(t_arena *arena)
{
	initscr();
	start_color();
	cbreak();
	noecho();
	curs_set(0);
	init_color(COLOR_WHITE, 400, 400, 400);
	init_pair(0, COLOR_WHITE, COLOR_BLACK);
	init_colors(arena->players);
	arena->display = (t_display *)ft_memalloc(sizeof(t_display));
	arena->display->updates = NULL;
	arena->display->running = 0;
	arena->display->quitting = 0;
	arena->display->cps = 50;
	init_mem_display(arena);
	attribute_src_code(arena);
	init_info_display(arena);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x20b0
callq 0x20e0
callq 0x2150
callq 0x20a0
xorl %edi, %edi
callq 0x2060
movl $0x7, %edi
movl $0x190, %ecx            # imm = 0x190
movl %ecx, %esi
movl %ecx, %edx
callq 0x2190
xorl %edx, %edx
movl $0x7, %esi
movl %edx, %edi
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6cc0
movl $0x1038, %edi           # imm = 0x1038
callq 0x70f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x32, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0x68e0
movq -0x8(%rbp), %rdi
callq 0x5ef0
movq -0x8(%rbp), %rdi
callq 0x6160
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display.c
// Function: attribute_src_code
static void	attribute_src_code(t_arena *arena)
{
	t_player		*p;
	unsigned int	size;
	unsigned int	begin;

	p = arena->players;
	while (p != NULL)
	{
		wattron(arena->display->w_bkp, COLOR_PAIR(
			p->id * 10 + MAX_PLAYERS + 2));
		size = 0;
		begin = p->begin - arena->memory;
		while (size < p->champ_size)
		{
			mvwprintw(arena->display->w_bkp,
					(begin + size) / 64,
					((begin + size) % 64) * 3 + 9,
					"%02x ", (unsigned char)arena->memory[begin + size]);
			arena->display->owner_tab[begin + size++] = (char)p->id;
		}
		wattroff(arena->display->w_bkp, COLOR_PAIR(
			p->id * 10 + MAX_PLAYERS + 2));
		p = p->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6010
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
imull $0xa, (%rax), %esi
addl $0x4, %esi
addl $0x2, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x5fd4
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movl -0x18(%rbp), %esi
addl -0x14(%rbp), %esi
shrl $0x6, %esi
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
andl $0x3f, %eax
imull $0x3, %eax, %edx
addl $0x9, %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %r8d
leaq 0x40df(%rip), %rcx      # 0xa084
movb $0x0, %al
callq 0x20d0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %esi
movl %esi, %edi
addl $0x1, %edi
movl %edi, -0x14(%rbp)
addl %esi, %ecx
movl %ecx, %ecx
movb %dl, 0x38(%rax,%rcx)
jmp 0x5f5a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
imull $0xa, (%rax), %esi
addl $0x4, %esi
addl $0x2, %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5f08
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display.c
// Function: update_display
int			update_display(t_arena *arena)
{
	if (arena->display == NULL)
		return (1);
	highlight_rw(arena);
	highlight_pcs(arena);
	overwrite(arena->display->w_bkp, arena->display->w_mem);
	overlay(arena->display->w_pcs, arena->display->w_mem);
	wrefresh(arena->display->w_mem);
	regulate_speed(arena);
	return (!arena->display->quitting);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x6040
movl $0x1, -0x4(%rbp)
jmp 0x60bf
movq -0x10(%rbp), %rdi
callq 0x6b20
movq -0x10(%rbp), %rdi
callq 0x6a00
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x2130
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x2180
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x20c0
movq -0x10(%rbp), %rdi
callq 0x6580
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display.c
// Function: destroy_display
void		destroy_display(t_arena *arena)
{
	delwin(arena->display->w_mem);
	delwin(arena->display->w_info);
	delwin(arena->display->w_bkp);
	while (arena->display->updates != NULL)
		remove_update_struct(arena->display->updates, arena);
	free(arena->display);
	init_color(COLOR_WHITE, 680, 680, 680);
	endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, (%rax)
je 0x6133
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x6840
jmp 0x610f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movl $0x7, %edi
movl $0x2a8, %ecx            # imm = 0x2A8
movl %ecx, %esi
movl %ecx, %edx
callq 0x2190
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_infos.c
// Function: init_info_display
void		init_info_display(t_arena *arena)
{
	int			line;
	t_player	*player;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1e, %edi
movl $0x32, %esi
movl $0xa, %edx
movl $0xcf, %ecx
callq 0x2050
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
xorl %esi, %esi
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cc0
movq -0x20(%rbp), %rdi
movl %eax, %ecx
leaq 0x42f5(%rip), %rsi      # 0xa4c2
xorl %r8d, %r8d
movl %r8d, %edx
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x5, -0xc(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x62a6
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
xorl %r9d, %r9d
leaq 0x42f7(%rip), %rcx      # 0xa508
movl $0x1, %r8d
movl %r9d, %edx
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x8, %edx
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x61ed
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_infos.c
// Function: update_infos
void		update_infos(t_arena *a)
{
	t_player	*player;
	t_process	*p;
	int			line;
	int			i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cc0
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %r8d
movl %eax, %r9d
xorl %esi, %esi
movl $0x18, %edx
leaq 0x4239(%rip), %rcx      # 0xa531
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl 0xc(%rax), %r8d
movl $0x3, %esi
movl $0x14, %edx
leaq 0x41dc(%rip), %rcx      # 0xa504
movb $0x0, %al
callq 0x20d0
movl $0x6, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x63f9
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x638c
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x637e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6360
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %r8d
movl $0x14, %edx
leaq 0x4182(%rip), %rcx      # 0xa52d
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movl -0x1c(%rbp), %esi
addl $0x1, %esi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %r8d
movl $0x14, %edx
leaq 0x4155(%rip), %rcx      # 0xa52d
movb $0x0, %al
callq 0x20d0
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6342
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_infos.c
// Function: check_keystroke
int			check_keystroke(t_arena *a)
{
	char	c;
	int		*cps;

	cps = &(a->display->cps);
	c = wgetch(a->display->w_info);
	if (c == 's')
		return (1);
	else if (c == ' ')
		a->display->running = !a->display->running;
	else if (c == 'j')
		*cps += (*cps < 1000) ? 10 : 1000 - *cps;
	else if (c == 'k')
		*cps -= (*cps >= 11) ? 10 : *cps - 1;
	else if (c == 'l')
		*cps += (*cps < 1000) ? 1 : 0;
	else if (c == ';')
		*cps -= (*cps > 1) ? 1 : 0;
	else if (c == 'q')
		a->display->quitting = 1;
	update_infos(a);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $0xc, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2080
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x73, %eax
jne 0x6445
movl $0x1, -0x4(%rbp)
jmp 0x656d
movsbl -0x11(%rbp), %eax
cmpl $0x20, %eax
jne 0x6474
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, 0x8(%rax)
jmp 0x655b
movsbl -0x11(%rbp), %eax
cmpl $0x6a, %eax
jne 0x64b1
movq -0x20(%rbp), %rax
cmpl $0x3e8, (%rax)          # imm = 0x3E8
jge 0x6493
movl $0xa, %eax
movl %eax, -0x24(%rbp)
jmp 0x64a1
movq -0x20(%rbp), %rcx
movl $0x3e8, %eax            # imm = 0x3E8
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x6559
movsbl -0x11(%rbp), %eax
cmpl $0x6b, %eax
jne 0x64e8
movq -0x20(%rbp), %rax
cmpl $0xb, (%rax)
jl 0x64cd
movl $0xa, %eax
movl %eax, -0x28(%rbp)
jmp 0x64d9
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x6557
movsbl -0x11(%rbp), %eax
cmpl $0x6c, %eax
jne 0x6511
movq -0x20(%rbp), %rax
movl (%rax), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x3e8, %edx            # imm = 0x3E8
cmovll %eax, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x6555
movsbl -0x11(%rbp), %eax
cmpl $0x3b, %eax
jne 0x6539
movq -0x20(%rbp), %rax
movl (%rax), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x1, %ecx
cmovgl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0x6553
movsbl -0x11(%rbp), %eax
cmpl $0x71, %eax
jne 0x6551
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x1, 0x10(%rax)
jmp 0x6553
jmp 0x6555
jmp 0x6557
jmp 0x6559
jmp 0x655b
jmp 0x655d
movq -0x10(%rbp), %rdi
callq 0x62b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_infos.c
// Function: regulate_speed
void		regulate_speed(t_arena *a)
{
	static clock_t	last_release = 0;
	clock_t			now;

	while (1)
	{
		if (check_keystroke(a))
			break ;
		now = clock();
		if ((a->display->running == 1
					&& now >= last_release + CLOCKS_PER_SEC / a->display->cps)
				|| a->display->quitting)
			break ;
	}
	last_release = now;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6400
cmpl $0x0, %eax
je 0x659c
jmp 0x65f9
callq 0x2090
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x65e7
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x6e96(%rip), %rcx      # 0xd458
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq 0xc(%rax), %rsi
movl $0xf4240, %eax          # imm = 0xF4240
cqto
idivq %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jge 0x65f5
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x65f7
jmp 0x65f9
jmp 0x658c
movq -0x10(%rbp), %rax
movq %rax, 0x6e54(%rip)      # 0xd458
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_infos.c
// Function: print_winner_display
void		print_winner_display(t_arena *a)
{
	t_player	*p;
	t_player	*best;

	best = a->players;
	p = a->players;
	while (p != NULL)
	{
		if (p->last_live >= best->last_live)
			best = p;
		p = p->next;
	}
	a->display->running = 0;
	update_infos(a);
	wtimeout(a->display->w_info, -1);
	wprintw(a->display->w_info, "\n\n\nThe fight as ended.\n\n");
	wprintw(a->display->w_info, "The winner is ");
	wattron(a->display->w_info, COLOR_PAIR(best->id));
	wprintw(a->display->w_info, "%s\n\n", best->name);
	wattroff(a->display->w_info, COLOR_PAIR(best->id));
	wprintw(a->display->w_info, "Press any key to exit");
	wgetch(a->display->w_info);
}

// 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 0x6661
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jl 0x6653
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6634
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x62b0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
leaq 0x3ea3(%rip), %rsi      # 0xa545
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
leaq 0x3ea2(%rip), %rsi      # 0xa55e
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x3e6b(%rip), %rsi      # 0xa56d
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
leaq 0x3e32(%rip), %rsi      # 0xa572
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x30(%rax), %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_mem.c
// Function: get_update_struct_of
t_d_update	*get_update_struct_of(int i, t_arena *arena)
{
	t_d_update	*u;
	t_d_update	*previous;

	u = arena->display->updates;
	previous = NULL;
	while (u != NULL && u->index != i)
	{
		previous = u;
		u = u->next;
	}
	if (u != NULL)
		return (u);
	u = (t_d_update *)malloc(sizeof(t_d_update));
	if (u == NULL)
		return (NULL);
	ft_bzero(u, sizeof(t_d_update));
	if (previous == NULL)
		arena->display->updates = u;
	else
		previous->next = u;
	u->index = i;
	return (u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x67a2
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x67ab
jmp 0x67c1
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6786
cmpq $0x0, -0x20(%rbp)
je 0x67d2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6835
movl $0x10, %edi
callq 0x2170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x67f1
movq $0x0, -0x8(%rbp)
jmp 0x6835
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x6e40
cmpq $0x0, -0x28(%rbp)
jne 0x6817
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
jmp 0x6823
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_mem.c
// Function: remove_update_struct
void		remove_update_struct(t_d_update *u, t_arena *arena)
{
	t_d_update	*previous;
	t_d_update	*current;

	if (arena->display->updates == u)
		arena->display->updates = arena->display->updates->next;
	else
	{
		previous = arena->display->updates;
		current = previous->next;
		while (current != u)
		{
			previous = current;
			current = current->next;
		}
		previous->next = current->next;
	}
	free(u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x687d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
jmp 0x68c8
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x68b8
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6898
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_mem.c
// Function: init_mem_display
void		init_mem_display(t_arena *arena)
{
	int	i;

	arena->display->w_bkp = newwin(MEM_SIZE / 64, 64 * 3 + 10, 0, 0);
	arena->display->w_mem = newwin(MEM_SIZE / 64, 64 * 3 + 10, 0, 0);
	arena->display->w_pcs = newwin(MEM_SIZE / 64, 64 * 3 + 10, 0, 0);
	i = -1;
	while (++i < MEM_SIZE)
	{
		if (i % 64 == 0 && i != MEM_SIZE - 1)
		{
			if (i != 0)
				wprintw(arena->display->w_bkp, "\n");
			wprintw(arena->display->w_bkp, "%0#6x : ", i);
		}
		wprintw(arena->display->w_bkp, "%02x ",
				(unsigned char)arena->memory[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
movl $0xca, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2050
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movl $0x40, %edi
movl $0xca, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2050
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x40, %edi
movl $0xca, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x2050
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x20(%rax)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1000, %eax           # imm = 0x1000
jge 0x69f1
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x69c3
cmpl $0xfff, -0xc(%rbp)      # imm = 0xFFF
je 0x69c3
cmpl $0x0, -0xc(%rbp)
je 0x69a6
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
leaq 0x3bbd(%rip), %rsi      # 0xa55c
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x36bf(%rip), %rsi      # 0xa07b
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x369f(%rip), %rsi      # 0xa084
movb $0x0, %al
callq 0x21e0
jmp 0x6959
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_mem.c
// Function: highlight_pcs
int			highlight_pcs(t_arena *arena)
{
	int			p_nbr;
	t_process	*p;

	p_nbr = 0;
	p = arena->processes;
	werase(arena->display->w_pcs);
	while (p != NULL)
	{
		wattron(arena->display->w_pcs, COLOR_PAIR(p->player) | A_BOLD);
		mvwprintw(arena->display->w_pcs,
				(int)(p->pc - arena->memory) / 64,
				((int)(p->pc - arena->memory) % 64) * 3 + 9,
				"%02x", (unsigned char)*(p->pc));
		wattroff(arena->display->w_pcs, COLOR_PAIR(p->player) | A_BOLD);
		p_nbr++;
		p = p->next;
	}
	return (p_nbr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
callq 0x2030
cmpq $0x0, -0x18(%rbp)
je 0x6b0b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x40, %ecx
cltd
idivl %ecx
imull $0x3, %edx, %edx
addl $0x9, %edx
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movzbl (%rax), %r8d
leaq 0x3ac8(%rip), %rcx      # 0xa588
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6a30
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_mem.c
// Function: highlight_rw
void		highlight_rw(t_arena *arena)
{
	t_d_update	*u;
	t_d_update	*next;
	int			pair;

	u = arena->display->updates;
	while (u != NULL)
	{
		next = u->next;
		pair = u->owner * 10 + u->w_turns + MAX_PLAYERS + 1;
		wmove(arena->display->w_bkp, u->index / 64, (u->index % 64) * 3 + 9);
		wattron(arena->display->w_bkp, COLOR_PAIR(pair));
		wprintw(arena->display->w_bkp,
				"%02x", (unsigned char)arena->memory[u->index]);
		wattroff(arena->display->w_bkp, COLOR_PAIR(pair));
		u->w_turns--;
		if (u->w_turns == 0)
			remove_update_struct(u, arena);
		u = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c49
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
imull $0xa, %eax, %eax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
addl %ecx, %eax
addl $0x4, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
imull $0x3, %edx, %edx
addl $0x9, %edx
callq 0x21c0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movl -0x1c(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x399b(%rip), %rsi      # 0xa588
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rdi
movl -0x1c(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2200
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x6c3c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6840
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x6b3b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_color.c
// Function: init_pairs
void		init_pairs(int players)
{
	int		o;
	int		oi;

	o = 0;
	while (++o <= players)
	{
		oi = -1;
		while (++oi < D_WRITE_TURNS + 1)
		{
			init_pair(10 * o + oi + MAX_PLAYERS + 1,
						100 + o * 10 + D_WRITE_TURNS - oi,
						0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl -0x4(%rbp), %eax
jg 0x6cb3
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x9, %eax
jge 0x6cb1
imull $0xa, -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
addl $0x4, %eax
addl $0x1, %eax
movw %ax, %cx
imull $0xa, -0x8(%rbp), %eax
addl $0x64, %eax
addl $0x8, %eax
subl -0xc(%rbp), %eax
xorl %edx, %edx
movswl %cx, %edi
movswl %ax, %esi
callq 0x2160
jmp 0x6c77
jmp 0x6c62
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/src/vm/display_color.c
// Function: init_colors
void		init_colors(t_player *p)
{
	float		i;
	short		r;
	short		g;
	short		b;
	int			c;

	c = 0;
	while (p != NULL)
	{
		color_content(p->id, &r, &g, &b);
		i = 11;
		while (--i > 0)
			init_color(
					100 + p->id * 10 + 9 - i,
					r + (((r + g + b) / 3 - r) + 400) * (i) / 25,
					g + (((r + g + b) / 3 - g) + 800) * (i) / 25,
					b + (((r + g + b) / 3 - b) + 700) * (i) / 25);
		init_pair(p->id, p->id, COLOR_BLACK);
		c++;
		p = p->next;
	}
	init_pairs(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6e2e
movq -0x8(%rbp), %rax
movl (%rax), %eax
leaq -0xe(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x12(%rbp), %rcx
movswl %ax, %edi
callq 0x21b0
movss 0x3890(%rip), %xmm0     # 0xa590
movss %xmm0, -0xc(%rbp)
movss 0x3887(%rip), %xmm0     # 0xa594
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x6df8
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %ecx
movl %ecx, %eax
leal 0x6d(%rax,%rax), %eax
cvtsi2ss %eax, %xmm0
movss -0xc(%rbp), %xmm3
subss %xmm3, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %si
movswl -0xe(%rbp), %edx
cvtsi2ss %edx, %xmm0
movswl -0x10(%rbp), %r8d
movl %edx, %eax
addl %r8d, %eax
movswl -0x12(%rbp), %edi
addl %edi, %eax
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
subl %edx, %ecx
addl $0x190, %ecx            # imm = 0x190
cvtsi2ss %ecx, %xmm1
mulss %xmm3, %xmm1
movss 0x3808(%rip), %xmm2     # 0xa598
divss %xmm2, %xmm1
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movw %cx, %dx
cvtsi2ss %r8d, %xmm0
movl %eax, %ecx
subl %r8d, %ecx
addl $0x320, %ecx            # imm = 0x320
cvtsi2ss %ecx, %xmm1
mulss %xmm3, %xmm1
divss %xmm2, %xmm1
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
cvtsi2ss %edi, %xmm0
subl %edi, %eax
addl $0x2bc, %eax            # imm = 0x2BC
cvtsi2ss %eax, %xmm1
mulss %xmm3, %xmm1
divss %xmm2, %xmm1
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movswl %si, %edi
movswl %dx, %esi
movswl %cx, %edx
movswl %ax, %ecx
callq 0x2190
jmp 0x6d05
movq -0x8(%rbp), %rax
movl (%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movl (%rax), %eax
xorl %edx, %edx
movswl %cx, %edi
movswl %ax, %esi
callq 0x2160
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6cd3
movl -0x18(%rbp), %edi
callq 0x6c50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_endianness.c
// Function: ft_write_big_endian
int			ft_write_big_endian(long long n, void *dst, size_t lenght)
{
	size_t	i;
	char	*dest;

	if (lenght == 0)
		return (0);
	dest = (char *)(dst + lenght - 1);
	i = 0;
	while (i < lenght)
	{
		*dest-- = (n & 0xFF);
		n >>= 8;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7210
movl $0x0, -0x4(%rbp)
jmp 0x7270
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7269
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
sarq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7228
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/ft_endianness.c
// Function: ft_read_big_endian
long long	ft_read_big_endian(void *src, size_t length)
{
	long long		n;
	long long		power;
	unsigned char	*ptr;

	n = 0;
	power = 1;
	ptr = (unsigned char *)src;
	while (length > 0)
	{
		n += ((long long)ptr[length - 1]) * power;
		power <<= 8;
		length--;
	}
	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 $0x0, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x72e2
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
imulq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x72a4
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
sarq %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x731a
jmp 0x72f8
cmpq $0x0, -0x20(%rbp)
je 0x7318
movq -0x20(%rbp), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x72f8
jmp 0x731a
movq -0x18(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Orycterope[P]corewar/libft/printf/ft_printf_fd.c
// Function: ft_printf_fd
int			ft_printf_fd(int fd, const char *format, ...)
{
	va_list args;
	int		count;
	int		error;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x75fb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x7690
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x7661
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0x766d
movq -0x10(%rbp), %rdi
callq 0x7a00
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x7ce0
movq -0x10(%rbp), %rdi
callq 0x2040
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/cosy/cosy.c
// Function: writeCard
int writeCard(
  FILE *dest
)
{
  /*
   * Remove trailing spaces.
   */
  while (idx && (card[idx - 1] == ' '))
    card[--idx] = '\0';

  if (fprintf(dest, "%s\n", card) < 0)
    return -1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x2d1b(%rip)      # 0x42c0
movb %al, -0x11(%rbp)
je 0x15ca
movl 0x2d10(%rip), %eax      # 0x42c0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x2d13(%rip), %rax      # 0x42d0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x15d3
jmp 0x15f2
movl 0x2ce7(%rip), %eax      # 0x42c0
addl $-0x1, %eax
movl %eax, 0x2cde(%rip)      # 0x42c0
movslq %eax, %rcx
leaq 0x2ce4(%rip), %rax      # 0x42d0
movb $0x0, (%rax,%rcx)
jmp 0x159c
movq -0x10(%rbp), %rdi
leaq 0xcb5(%rip), %rsi       # 0x22b2
leaq 0x2ccc(%rip), %rdx      # 0x42d0
movb $0x0, %al
callq 0x10c0
cmpl $0x0, %eax
jge 0x1619
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1620
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/cosy/cosy.c
// Function: usage
void usage(void)
{
  fprintf(stderr,
          "Usage: cosy [-cd] <cosyfile> [file ...]\n");
  fprintf(stderr,
          "   Compress/decompress a COSY file\n");
  fprintf(stderr, "\nSwitches:\n\n");
  fprintf(stderr, " -c   Perform COSY compression\n");
  fprintf(stderr, " -d   Perform COSY decompression (the default)\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x29bd(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xba1(%rip), %rsi       # 0x21e6
movb $0x0, %al
callq 0x10c0
movq 0x29a5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbb2(%rip), %rsi       # 0x220f
movb $0x0, %al
callq 0x10c0
movq 0x298d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbbe(%rip), %rsi       # 0x2233
movb $0x0, %al
callq 0x10c0
movq 0x2975(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbb3(%rip), %rsi       # 0x2240
movb $0x0, %al
callq 0x10c0
movq 0x295d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbbb(%rip), %rsi       # 0x2260
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/cosy/cosy.c
// Function: main
int main(
  int argc,
  char *argv[]
)
{
  int ch;
  FILE *cosy;

  while ((ch = getopt(argc, argv, "cd")) != -1) {
    switch (ch) {
      case 'c':
        compress = 1;
        break;

      case 'd':
        compress = 0;
        break;

      default:
        usage();
    }
  }
  argc -= optind;
  argv += optind;

  if (argc < (compress ? 2 : 1))
    usage();

  /*
   * Open the COSY file.
   */
  if ((cosy = fopen(argv[0], compress ? "w" : "r")) == NULL) {
    fprintf(stderr, "Failed to open COSY file - %s\n", argv[0]);
    return 2;
  }
  argc--, argv++;

  if (compress) {
    return doCompress(cosy, argc, argv);
  }
  return doDecompress(cosy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xbac(%rip), %rdx       # 0x2290
callq 0x10e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x1727
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x63, %eax
je 0x1708
jmp 0x16fe
movl -0x24(%rbp), %eax
subl $0x64, %eax
je 0x1714
jmp 0x1720
movl $0x1, 0x2bb6(%rip)      # 0x42c8
jmp 0x1725
movl $0x0, 0x2baa(%rip)      # 0x42c8
jmp 0x1725
callq 0x1630
jmp 0x16d6
movq 0x28aa(%rip), %rax      # 0x3fd8
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0x2899(%rip), %rax      # 0x3fd8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl 0x2b6c(%rip), %esi      # 0x42c8
movl $0x1, %ecx
movl $0x2, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jge 0x1775
callq 0x1630
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0x2b46(%rip), %ecx      # 0x42c8
leaq 0xb0c(%rip), %rsi       # 0x2295
leaq 0xb03(%rip), %rax       # 0x2293
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x10d0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x17ce
movq 0x284b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xad9(%rip), %rsi       # 0x2297
movb $0x0, %al
callq 0x10c0
movl $0x2, -0x4(%rbp)
jmp 0x180d
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x2ade(%rip)      # 0x42c8
je 0x1801
movq -0x20(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x1820
movl %eax, -0x4(%rbp)
jmp 0x180d
movq -0x20(%rbp), %rdi
callq 0x1b20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eridanhq[P]miraclelib/setpwr.c
// Function: main
int main(int argc, char *argv[])
{
	FILE * fp;
	int memfd;
	void *mapped_base;

	int pwr_val;

	pwr_val = atoi(argv[1]);

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page
	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, SPI_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}

	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	set_pwr_tx(pwr_val, mapped_base);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */

	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);


	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1100
movl %eax, -0x2c(%rbp)
leaq 0x1d97(%rip), %rdi      # 0x3004
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0x10e0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1297
leaq 0x1d84(%rip), %rdi      # 0x300d
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1120
movl -0x1c(%rbp), %r8d
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x11, %ecx
movl $0x64000000, %r9d       # imm = 0x64000000
callq 0x1070
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x12e0
leaq 0x1d51(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1120
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x1ff0
movq -0x28(%rbp), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x10d0
cmpl $-0x1, %eax
jne 0x1314
leaq 0x1d42(%rip), %rdi      # 0x3048
movb $0x0, %al
callq 0x1090
xorl %edi, %edi
callq 0x1120
movl -0x1c(%rbp), %edi
callq 0x10b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm.c
// Function: main
int main(void)
{
	int seconds;
	char line[128], message[64];

	while (printf("Alarm> ") && fgets(line, sizeof(line), stdin))
	{
		if (strlen(line) <= 1)
			continue;
		if (sscanf(line, "%d %64[^\n]", &seconds, message) < 2)
			fputs("Bad command\n", stderr);
		else
		{
			sleep(seconds);
			printf("(%d) %s\n", seconds, message);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe5b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd1(%rbp)
je 0x11e7
leaq -0x90(%rbp), %rdi
movq 0x2e0b(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x80, %esi
callq 0x1060
cmpq $0x0, %rax
setne %al
movb %al, -0xd1(%rbp)
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x11f3
jmp 0x1269
leaq -0x90(%rbp), %rdi
callq 0x1030
cmpq $0x1, %rax
ja 0x1207
jmp 0x11a2
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rcx
leaq 0xdf0(%rip), %rsi       # 0x200c
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x1070
cmpl $0x2, %eax
jge 0x1244
movq 0x2dc5(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xdda(%rip), %rdi       # 0x2017
callq 0x1050
jmp 0x1264
movl -0x8(%rbp), %edi
callq 0x1080
movl -0x8(%rbp), %esi
leaq -0xd0(%rbp), %rdx
leaq 0xdc7(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1040
jmp 0x11a2
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/util.c
// Function: xmalloc
SOLOCAL void *xmalloc(size_t size)
{
    void *m = malloc(size);
    if (!m)
    {
        logmsg(L_FATAL, "memory allocation failed.");
        abort();
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5510
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5903
xorl %edi, %edi
leaq 0xe343(%rip), %rsi      # 0x13c3c
callq 0x5a60
callq 0x50a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/util.c
// Function: xrealloc
SOLOCAL void *xrealloc(void *ptr, size_t size)
{
    void *m = realloc(ptr, size);
    if (!m)
    {
        logmsg(L_FATAL, "memory allocation failed.");
        abort();
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x594b
xorl %edi, %edi
leaq 0xe2fb(%rip), %rsi      # 0x13c3c
callq 0x5a60
callq 0x50a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/util.c
// Function: copystr
SOLOCAL char *copystr(const char *src)
{
    if (!src) return 0;
    char *copy = xmalloc(strlen(src) +1);
    strcpy(copy, src);
    return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x597d
movq $0x0, -0x8(%rbp)
jmp 0x59ab
movq -0x10(%rbp), %rdi
callq 0x5270
movq %rax, %rdi
addq $0x1, %rdi
callq 0x58d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5100
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/excess-c64[P]lib1541img/src/lib/1541img/util.c
// Function: upperstr
SOLOCAL char *upperstr(const char *src)
{
    if (!src) return 0;
    char *upper = xmalloc(strlen(src) +1);
    const char *r = src;
    char *w = upper;
    while (*r)
    {
	*w++ = toupper(*r++);
    }
    *w = 0;
    return upper;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x59dd
movq $0x0, -0x8(%rbp)
jmp 0x5a4a
movq -0x10(%rbp), %rdi
callq 0x5270
movq %rax, %rdi
addq $0x1, %rdi
callq 0x58d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5a3b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %edi
callq 0x5120
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x5a06
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop