LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_map.c
// Function: check_map
int	check_map(char	*map_path, t_game *game)
{
	int		fd;
	int		x;
	int		y;

	if (!(check_ex(map_path)))
		return (0);
	fd = open(map_path, O_RDONLY);
	if (fd == -1)
		return (0);
	if (!(get_all_content(fd, game)))
	{
		close(fd);
		return (0);
	}
	close(fd);
	if (!(check_surround_wall(game)))
		return (0);
	if (!(check_structure(game)))
		return (0);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x6fa0
xorl %ebx, %ebx
testl %eax, %eax
je 0x6ddc
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x63f0
cmpl $-0x1, %eax
je 0x6ddc
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x6bbc
movl %eax, %r15d
movl %ebp, %edi
callq 0x6060
testl %r15d, %r15d
je 0x6ddc
movq %r14, %rdi
callq 0x6fd5
testl %eax, %eax
je 0x6ddc
movq %r14, %rdi
callq 0x7034
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_exit.c
// Function: check_exit
void	check_exit(t_game *game)
{
	static int	open;
	int			x;
	int			y;

	if (!game->items && !open)
	{
		open = 1;
		open_exits(game);
	}
	if (!game->items)
	{
		x = game->player.x + game->map.x;
		y = game->player.y + game->map.y;
		if (game->map.layout[y][x] == 'E')
			game->win = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x130(%rdi), %rax
testq %rax, %rax
jne 0x6f25
testb $0x1, 0x13bd0(%rip)     # 0x1aa18
jne 0x6f25
movb $0x1, 0x13bc3(%rip)     # 0x1aa18
movslq 0x12c(%rbx), %r15
testq %r15, %r15
je 0x6f2a
movslq 0x128(%rbx), %rcx
leaq 0xd0(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %rcx, %rax
movq %rcx, 0x10(%rsp)
shll $0x6, %eax
addl $-0x40, %eax
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %r12
decq %r15
cmpl $0x0, 0x10(%rsp)
je 0x6f15
movl %r15d, %ebp
shll $0x6, %ebp
movl 0xc(%rsp), %r13d
movq 0x10(%rsp), %r14
movq 0xc8(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpb $0x45, -0x1(%rax,%r14)
jne 0x6f09
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x3c(%rsp)
movq %r12, %rdi
leaq 0x4135(%rip), %rsi      # 0xb00a
movq %rbx, %rdx
callq 0x6aa8
movl 0x3c(%rsp), %edx
movl 0x40(%rsp), %ecx
movl %r13d, %edi
movl %ebp, %esi
callq 0x6a73
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x69c2
movq 0x20(%rsp), %rdi
callq 0x6190
decq %r14
addl $-0x40, %r13d
testq %r14, %r14
jne 0x6ea9
testq %r15, %r15
jne 0x6e8f
movq 0x130(%rbx), %rax
testq %rax, %rax
jne 0x6f67
movslq 0xb4(%rbx), %rax
movslq 0x120(%rbx), %rcx
addq %rax, %rcx
movslq 0xb8(%rbx), %rax
movslq 0x124(%rbx), %rdx
addq %rax, %rdx
movq 0xc8(%rbx), %rax
movq (%rax,%rdx,8), %rax
cmpb $0x45, (%rax,%rcx)
jne 0x6f67
movl $0x1, 0x158(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_ex
int check_ex(char *file)
{
    int index;

    index = ft_strlen(file);
    if (index-- < 4)
        return (0);
    if (file[index--] != 'r' || file[index--] != 'e' || file[index--] != 'b')
        return (0);
    if (file[index] != '.')
        return (0);
    return (1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x65e8
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
jl 0x6fd3
movl %ecx, %ecx
cmpb $0x72, -0x1(%rbx,%rcx)
jne 0x6fd3
cmpb $0x65, -0x2(%rbx,%rcx)
jne 0x6fd3
cmpb $0x62, -0x3(%rbx,%rcx)
jne 0x6fd3
xorl %eax, %eax
cmpb $0x2e, -0x4(%rbx,%rcx)
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_surround_wall
int check_surround_wall(t_game *game)
{
    char    **layout;
    int     x;
    int     y;

    x = game->map.w;
    y = game->map.h;
    layout = game->map.layout;
    while (x--)
    {
        if (layout[0][x] != '1')
            return (0);
        if (layout[y - 1][x] != '1')
            return (0);
    }
    x = game->map.w - 1;
    while (y--)
    {
        if (layout[y][0] != '1')
            return (0);
        if (layout[y][x] != '1')
            return (0);
    }
    return (1);
}

// Assembly:
movslq 0x128(%rdi), %rcx
movslq 0x12c(%rdi), %rdx
movq 0xc8(%rdi), %rsi
movq %rcx, %rdi
movq %rcx, %r8
xorl %eax, %eax
subq $0x1, %r8
jb 0x7015
movq (%rsi), %r9
cmpb $0x31, -0x1(%r9,%rdi)
jne 0x702d
movq -0x8(%rsi,%rdx,8), %r9
cmpb $0x31, -0x1(%r9,%rdi)
movq %r8, %rdi
je 0x6ff2
jmp 0x702d
xorl %eax, %eax
subq $0x1, %rdx
jb 0x702e
movq (%rsi,%rdx,8), %rdi
cmpb $0x31, (%rdi)
jne 0x702d
cmpb $0x31, -0x1(%rdi,%rcx)
je 0x7017
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_map_utils.c
// Function: check_structure
int check_structure(t_game *game)
{
	int	x;
	int	x_hold;
	int	y;
	int	check[3];

	x = game->map.w;
	x_hold = game->map.w;
	y = game->map.h;
	check[0] = 0;
	check[1] = 0;
	check[2] = 0;
	while (y--)
	{
		while (x--)
		{
			if (game->map.layout[y][x] == 'C')
				check[0] = 1;
			if (game->map.layout[y][x] == 'P')
				check[1] = 1;
			if (game->map.layout[y][x] == 'E')
				check[2] = 1;
		}
		x = x_hold;
	}
	return (check[0] && check[1] && check[2]);
}

// Assembly:
movslq 0x12c(%rdi), %rax
testq %rax, %rax
je 0x70a7
pushq %rbx
movslq 0x128(%rdi), %rsi
xorl %edx, %edx
movl $0x1, %r9d
xorl %r8d, %r8d
xorl %ecx, %ecx
decq %rax
testl %esi, %esi
je 0x7089
movq 0xc8(%rdi), %r10
movq (%r10,%rax,8), %r10
movq %rsi, %r11
movb -0x1(%r10,%r11), %bl
cmpb $0x43, %bl
cmovel %r9d, %edx
cmpb $0x50, %bl
cmovel %r9d, %r8d
cmpb $0x45, %bl
cmovel %r9d, %ecx
decq %r11
jne 0x706a
testq %rax, %rax
jne 0x7055
testl %edx, %edx
setne %al
testl %r8d, %r8d
setne %dl
andb %al, %dl
testl %ecx, %ecx
setne %al
andb %dl, %al
movzbl %al, %eax
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/game_config.c
// Function: game_config
void	game_config(t_game *game)
{
	game->vars.mlx = mlx_init();
	map_config(game);
	player_config(game);
	enemy_config(game);
	if (game->map.w > 14)
		game->width = 14;
	else
		game->width = game->map.w;
	if (game->map.h > 10)
		game->height = 10;
	else
		game->height = game->map.h;
	game->vars.win = mlx_new_window(game->vars.mlx, game->width * BLOCK_SIZE,
			game->height * BLOCK_SIZE, "Dungeon Zone");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x8270
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x719e
movq %rbx, %rdi
callq 0x73b4
movq %rbx, %rdi
callq 0x75d6
movl 0x128(%rbx), %eax
cmpl $0xe, %eax
movl $0xe, %esi
cmovll %eax, %esi
movl %esi, 0x148(%rbx)
movl 0x12c(%rbx), %eax
cmpl $0xa, %eax
movl $0xa, %edx
cmovll %eax, %edx
movl %edx, 0x14c(%rbx)
movq (%rbx), %rdi
shll $0x6, %esi
shll $0x6, %edx
leaq 0x3f42(%rip), %rcx      # 0xb052
callq 0x83c0
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/map_config.c
// Function: get_active_map
void	get_active_map(t_game *game)
{
	int	w;
	int	h;
	int	x;
	int	y;

	w = game->width * BLOCK_SIZE;
	h = game->height * BLOCK_SIZE;
	if (!game->map.map.img)
	{
		create_img(&game->map.map, w, h, game);
		fix_cam(game);
	}
	x = game->map.x * BLOCK_SIZE;
	y = game->map.y * BLOCK_SIZE;
	copy_img_from(&game->map.map, &game->map.full_map, to_array(x, y, w, h));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x148(%rdi), %ebp
movl 0x14c(%rdi), %r14d
shll $0x6, %ebp
shll $0x6, %r14d
leaq 0xf8(%rdi), %r15
cmpq $0x0, 0xf8(%rdi)
jne 0x7163
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x6ad9
movq %rbx, %rdi
callq 0x76e0
movl 0x120(%rbx), %edi
movl 0x124(%rbx), %esi
shll $0x6, %edi
shll $0x6, %esi
addq $0xd0, %rbx
movl %ebp, %edx
movl %r14d, %ecx
callq 0x6a73
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x690d
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/map_config.c
// Function: map_config
void	map_config(t_game *game)
{
	int		x;
	int		x_holder;
	int		y;

	x = game->map.w;
	x_holder = x;
	y = game->map.h;
	game->map.x = 0;
	game->map.y = 0;
	game->map.map.img = 0;
	create_img(&game->map.full_map, x * BLOCK_SIZE, y * BLOCK_SIZE, game);
	while (y--)
	{
		while (x--)
			draw_block(game, x, y);
		x = x_holder;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x128(%rdi), %rcx
movslq 0x12c(%rdi), %r14
xorl %eax, %eax
movq %rax, 0x120(%rdi)
movq %rax, 0xf8(%rdi)
addq $0xd0, %rdi
movq %rcx, (%rsp)
movl %ecx, %esi
shll $0x6, %esi
movl %r14d, %edx
shll $0x6, %edx
movq %rbx, %rcx
callq 0x6ad9
testq %r14, %r14
je 0x72ae
movq %r14, %rdx
movq (%rsp), %rax
movl %eax, %ecx
shll $0x6, %ecx
addl $-0x40, %ecx
movl %ecx, 0xc(%rsp)
decl %eax
movl %eax, 0x8(%rsp)
decq %rdx
cmpl $0x0, (%rsp)
je 0x72a5
movl %edx, %ebp
shll $0x6, %ebp
movl 0x8(%rsp), %r15d
movl 0xc(%rsp), %r12d
movq (%rsp), %r13
movq %rdx, 0x10(%rsp)
movq 0xc8(%rbx), %rax
movq (%rax,%rdx,8), %rax
movzbl -0x1(%rax,%r13), %r14d
cmpl $0x43, %r14d
je 0x7263
cmpl $0x50, %r14d
jne 0x726e
movl %r15d, 0xb4(%rbx)
movq 0x10(%rsp), %rax
movl %eax, 0xb8(%rbx)
jmp 0x726e
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7468
decq %r13
movl $0x30, %edi
movq %rbx, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x72bd
movsbl %r14b, %edi
movq %rbx, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x72bd
addl $-0x40, %r12d
decl %r15d
testq %r13, %r13
movq 0x10(%rsp), %rdx
jne 0x7232
testq %rdx, %rdx
jne 0x720d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/map_config.c
// Function: set_tile
static void	set_tile(char c, t_game *game, int x, int y)
{
	t_data			tile;
	char			*path;
	static size_t	i;
	int				size;

	size = BLOCK_SIZE;
	if (c == '1')
		path = "./imgs/wall3.xpm";
	if (c == 'E')
		path = "./imgs/exit_lock.xpm";
	if (c == 'C' || c == 'P' || c == '0')
	{
		if (i % 18 == 0)
			path = "./imgs/floor4.xpm";
		else if (i % 28 == 0)
			path = "./imgs/floor5.xpm";
		else
			path = "./imgs/floor3.xpm";
		i++;
	}
	load_img(&tile, path, game);
	copy_img_to(&game->map.full_map, &tile, to_array(x, y, size, size));
	free(tile.img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
cmpb $0x45, %dil
leaq 0x3d96(%rip), %rax      # 0xb070
leaq 0x3d7e(%rip), %rsi      # 0xb05f
cmoveq %rax, %rsi
addl $-0x30, %edi
cmpl $0x20, %edi
ja 0x7368
movabsq $0x100080001, %rax      # imm = 0x100080001
btq %rdi, %rax
jae 0x7368
movq 0x1371c(%rip), %rax     # 0x1aa20
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
rorq %rcx
movabsq $0xe38e38e38e38e39, %rdx # imm = 0xE38E38E38E38E39
cmpq %rdx, %rcx
jb 0x7357
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rcx
rorq $0x2, %rcx
movabsq $0x924924924924925, %rdx # imm = 0x924924924924925
cmpq %rdx, %rcx
leaq 0x3d4d(%rip), %rcx      # 0xb097
leaq 0x3d58(%rip), %rsi      # 0xb0a9
cmovbq %rcx, %rsi
jmp 0x735e
leaq 0x3d27(%rip), %rsi      # 0xb085
incq %rax
movq %rax, 0x136b8(%rip)     # 0x1aa20
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6aa8
addq $0xd0, %rbx
movl %r14d, %edi
movl %ebp, %esi
movl $0x40, %edx
movl $0x40, %ecx
callq 0x6a73
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69c2
movq (%r15), %rdi
callq 0x6190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/player_config.c
// Function: player_config
void	player_config(t_game *game)
{
	t_data		full_sprite;
	t_player	*player;
	int			i;

	i = 0;
	player = &game->player;
	player->steps = 0;
	full_sprite.w = 144;
	full_sprite.h = 256;
	player->w = 48;
	player->h = 64;
	player->frame = 2;
	load_img(&full_sprite, "./imgs/male.xpm", game);
	while (i < 4)
	{
		create_img(&player->sprites[i], player->w, player->h, game);
		copy_img_from(&player->sprites[i], &full_sprite,
			to_array(0, player->h * i, player->w, player->h));
		i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movl $0x0, 0xbc(%rdi)
movabsq $0x10000000090, %rax    # imm = 0x10000000090
movq %rsp, %r15
movq %rax, 0x1c(%r15)
movabsq $0x4000000030, %rax     # imm = 0x4000000030
movq %rax, 0xc0(%rdi)
movl $0x2, 0xb0(%rdi)
leaq 0x3cb8(%rip), %rsi      # 0xb0bb
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6aa8
xorl %r12d, %r12d
movl 0xc0(%rbx), %esi
movl 0xc4(%rbx), %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x6ad9
movl 0xc0(%rbx), %edx
movl 0xc4(%rbx), %ecx
movl %r12d, %esi
imull %ecx, %esi
xorl %edi, %edi
callq 0x6a73
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x690d
incq %r12
addq $0x28, %r14
cmpq $0x4, %r12
jne 0x7411
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/new_item.c
// Function: new_item
void	new_item(t_game *game, int x, int y)
{
	t_item	*begin;
	t_item	*new_item;

	new_item = (t_item *) ft_calloc(1, sizeof(t_item));
	new_item->x = x;
	new_item->y = y;
	new_item->sprite.w = BLOCK_SIZE;
	new_item->sprite.h = BLOCK_SIZE;
	load_img(&new_item->sprite, "./imgs/item.xpm", game);
	begin = game->items;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_item;
	else
		game->items = new_item;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x1c(%r14)
leaq 0x3c26(%rip), %rsi      # 0xb0cb
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6aa8
movq 0x130(%rbx), %rcx
addq $0x130, %rbx            # imm = 0x130
testq %rcx, %rcx
je 0x74d6
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x74be
addq $0x38, %rax
movq %rax, %rbx
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/enemy_config.c
// Function: new_enemy
void	new_enemy(t_game *game, int x, int y)
{
	t_enemy	*begin;
	t_enemy	*new_enemy;

	new_enemy = (t_enemy *) ft_calloc(1, sizeof(t_enemy));
	new_enemy->x = x;
	new_enemy->y = y;
	new_enemy->sprites[0].w = 80;
	new_enemy->sprites[0].h = 96;
	new_enemy->sprites[1].w = 122;
	new_enemy->sprites[1].h = 103;
	new_enemy->sprites[2].w = 86;
	new_enemy->sprites[2].h = 110;
	load_img(&new_enemy->sprites[0], "./imgs/enemy.xpm", game);
	load_img(&new_enemy->sprites[1], "./imgs/enemy2.xpm", game);
	load_img(&new_enemy->sprites[2], "./imgs/enemy3.xpm", game);
	begin = game->enemies;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_enemy;
	else
		game->enemies = new_enemy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x98, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x80(%rax)
movl %ebp, 0x84(%rax)
movabsq $0x6000000050, %rax     # imm = 0x6000000050
movq %rax, 0x1c(%r14)
leaq 0x28(%r14), %r15
movabsq $0x670000007a, %rax     # imm = 0x670000007A
movq %rax, 0x44(%r14)
leaq 0x50(%r14), %r12
movabsq $0x6e00000056, %rax     # imm = 0x6E00000056
movq %rax, 0x6c(%r14)
leaq 0x3b6b(%rip), %rsi      # 0xb0db
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6aa8
leaq 0x3b6a(%rip), %rsi      # 0xb0ec
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6aa8
leaq 0x3b6a(%rip), %rsi      # 0xb0fe
movq %r12, %rdi
movq %rbx, %rdx
callq 0x6aa8
movq 0x138(%rbx), %rcx
addq $0x138, %rbx            # imm = 0x138
testq %rcx, %rcx
je 0x75ca
movq %rcx, %rax
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0x75ad
addq $0x90, %rax
movq %rax, %rbx
movq %r14, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/enemy_config.c
// Function: enemy_config
void	enemy_config(t_game *game)
{
	int		y;
	int		x;
	int		x_holder;
	int		number;

	number = 0;
	y = game->map.h;
	x = game->map.w;
	x_holder = x;
	while (y--)
	{
		while (x--)
		{
			if (check_surround(y, x, game) && number < 10)
			{
				new_enemy(game, x, y);
				number++;
			}
		}
		x = x_holder;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x12c(%rdi), %r14
testq %r14, %r14
je 0x7652
movq %rdi, %rbx
movslq 0x128(%rdi), %r12
leal -0x1(%r12), %eax
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
decq %r14
testl %r12d, %r12d
je 0x764d
movl 0x4(%rsp), %ebp
movq %r12, %r15
movq 0xc8(%rbx), %rax
movq (%rax,%r14,8), %rax
cmpb $0x30, -0x1(%rax,%r15)
jne 0x7643
cmpb $0x43, -0x2(%rax,%r15)
jne 0x7643
cmpl $0x9, %r13d
jg 0x7643
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x7508
incl %r13d
decq %r15
decl %ebp
testq %r15, %r15
jne 0x7612
testq %r14, %r14
jne 0x7603
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/fireball_config.c
// Function: new_fireball
void	new_fireball(t_game *game, int x, int y)
{
	t_fireball	*begin;
	t_fireball	*new_item;

	new_item = (t_fireball *) ft_calloc(1, sizeof(t_fireball));
	new_item->x = x;
	new_item->y = y;
	new_item->sprite.w = 64;
	new_item->sprite.h = 64;
	load_img(&new_item->sprite, "./imgs/fireball/1.xpm", game);
	begin = game->fireballs;
	while (begin && begin->next)
		begin = begin->next;
	if (begin)
		begin->next = new_item;
	else
		game->fireballs = new_item;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edi
movl $0x40, %esi
callq 0x65a4
movq %rax, %r14
movl %r15d, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x1c(%r14)
leaq 0x3a6f(%rip), %rsi      # 0xb110
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6aa8
movq 0x140(%rbx), %rcx
addq $0x140, %rbx            # imm = 0x140
testq %rcx, %rcx
je 0x76d2
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x76ba
addq $0x38, %rax
movq %rax, %rbx
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/config/fix_cam.c
// Function: fix_cam
int	fix_cam(t_game *game)
{
	int	x;
	int	y;

	x = 0;
	y = 0;
	while (y + game->height <= game->map.h)
	{
		while (x + game->width <= game->map.w)
		{
			if (player_on_screen(x, y, game))
			{
				game->map.x = x;
				game->map.y = y;
				game->player.x -= x;
				game->player.y -= y;
				return (0);
			}
			x++;
		}
		x = 0;
		y++;
	}
	return (0);
}

// Assembly:
movslq 0x14c(%rdi), %rax
movl 0x12c(%rdi), %ecx
cmpl %ecx, %eax
jg 0x778f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x148(%rdi), %rsi
movslq 0x128(%rdi), %r8
movq %r8, %r9
subq %rsi, %r9
xorl %edx, %edx
cmpl %r8d, %esi
jle 0x7725
incq %rdx
leal (%rdx,%rax), %r10d
cmpl %ecx, %r10d
jle 0x7712
jmp 0x7788
leaq (%rdx,%rax), %r11
xorl %r10d, %r10d
testl %eax, %eax
jle 0x7760
leaq (%r10,%rsi), %rbx
movq %rdx, %r14
testl %esi, %esi
jle 0x7758
movq 0xc8(%rdi), %r15
movq (%r15,%r14,8), %r15
movq %r10, %r12
cmpb $0x50, (%r15,%r12)
je 0x776e
incq %r12
cmpq %rbx, %r12
jl 0x7749
incq %r14
cmpq %r11, %r14
jb 0x7737
leaq 0x1(%r10), %rbx
cmpq %r9, %r10
movq %rbx, %r10
jl 0x772c
jmp 0x7717
movl %r10d, 0x120(%rdi)
movl %edx, 0x124(%rdi)
subl %r10d, 0xb4(%rdi)
subl %edx, 0xb8(%rdi)
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/player_action.c
// Function: player_action
void	player_action(int keycode, t_game *game)
{
	if (keycode == W)
		up(game);
	if (keycode == A)
		left(game);
	if (keycode == S)
		down(game);
	if (keycode == D)
		right(game);
}

// Assembly:
cmpl $0x72, %edi
jg 0x77ab
cmpl $0x61, %edi
je 0x77be
cmpl $0x64, %edi
jne 0x77bd
movq %rsi, %rdi
jmp 0x7c59
cmpl $0x73, %edi
je 0x77c6
cmpl $0x77, %edi
jne 0x77bd
movq %rsi, %rdi
jmp 0x7b40
retq
movq %rsi, %rdi
jmp 0x7bfe
movq %rsi, %rdi
jmp 0x7b9b
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/player_action.c
// Function: render_user
void	render_user(t_game *game)
{	
	t_data	*sprite;
	int		x;
	int		y;

	x = game->player.x * BLOCK_SIZE;
	y = game->player.y * BLOCK_SIZE;
	sprite = &game->player.sprites[game->player.frame];
	copy_img_to(&game->map.map, sprite,
		to_array(x, y, game->player.w, game->player.h));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0xb4(%rdi), %eax
movl 0xb8(%rdi), %esi
shll $0x6, %eax
shll $0x6, %esi
movslq 0xb0(%rdi), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rdi,%rcx,8), %rbx
addq $0x10, %rbx
leaq 0xf8(%rdi), %r14
movl 0xc0(%rdi), %edx
movl 0xc4(%rdi), %ecx
movl %eax, %edi
callq 0x6a73
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x69c2
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/game_init.c
// Function: game_init
void	game_init(t_game *game)
{
	mlx_loop_hook(game->vars.mlx, frame_update, game);
	mlx_hook(game->vars.win, DestroyNotify, StructureNotifyMask, close_game, game);
	mlx_hook(game->vars.win, KeyPress, KeyPressMask, key_hook, game);
	mlx_loop(game->vars.mlx);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x4b(%rip), %rsi        # 0x78ad
movq %rbx, %rdx
callq 0x86c0
movq 0x8(%rbx), %rdi
leaq 0x112(%rip), %rcx       # 0x7987
movl $0x11, %esi
movl $0x20000, %edx          # imm = 0x20000
movq %rbx, %r8
callq 0xa0f0
movq 0x8(%rbx), %rdi
leaq 0x10c(%rip), %rcx       # 0x799e
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0xa0f0
movq (%rbx), %rdi
popq %rbx
jmp 0x8550
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/game_init.c
// Function: frame_update
static int	frame_update(t_game *game)
{
	static int	screen;
	char		*count;

	if (game->game_over)
	{
		if (!screen)
			print_over(game);
		screen = 1;
		return (1);
	}
	if (game->win)
	{
		if (!screen)
			print_screen(game);
		screen = 1;
		return (1);
	}
	get_active_map(game);
	render_user(game);
	render_enemies(game);
	render_items(game);
	render_fireball(game);
	check_exit(game);
	mlx_put_image_to_window(game->vars.mlx, game->vars.win,
		game->map.map.img, 0, 0);
	count = ft_itoa(game->player.steps);
	mlx_string_put(game->vars.mlx, game->vars.win, (game->width * BLOCK_SIZE) - 20\
		, 20, 0xF35C00, count
	);
	free(count);
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x154(%rdi)
je 0x78d0
cmpb $0x0, 0x13164(%rip)     # 0x1aa28
jne 0x78ea
movq %rbx, %rdi
callq 0x7f50
jmp 0x78ea
cmpl $0x0, 0x158(%rbx)
je 0x78fe
cmpb $0x0, 0x13148(%rip)     # 0x1aa28
jne 0x78ea
movq %rbx, %rdi
callq 0x7fdd
movb $0x1, 0x13137(%rip)     # 0x1aa28
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x711c
movq %rbx, %rdi
callq 0x77ce
movq %rbx, %rdi
callq 0x7cee
movq %rbx, %rdi
callq 0x79e8
movq %rbx, %rdi
callq 0x7e68
movq %rbx, %rdi
callq 0x6e20
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8d90
movl 0xbc(%rbx), %edi
callq 0x6b28
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movl 0x148(%rbx), %edx
shll $0x6, %edx
addl $-0x14, %edx
movl $0x14, %ecx
movl $0xf35c00, %r8d         # imm = 0xF35C00
movq %rax, %r9
callq 0x88a0
movq %r14, %rdi
callq 0x6190
jmp 0x78f1
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/game_init.c
// Function: key_hook
static int	key_hook(int keycode, t_game *game)
{
	if (game->game_over || game->win)
		return (1);
	player_action(keycode, game);
	if (keycode == ESC)
		close_game(game);
	return (1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x154(%rsi)
jne 0x79c8
movq %rsi, %rbx
cmpl $0x0, 0x158(%rsi)
jne 0x79c8
movl %edi, %ebp
movq %rbx, %rsi
callq 0x7794
cmpl $0xff1b, %ebp           # imm = 0xFF1B
je 0x79d4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x9e00
xorl %edi, %edi
callq 0x60c0
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/item_action.c
// Function: render_items
void	render_items(t_game *game)
{
	t_item	*item;
	t_item	*last_one;
	int		x;
	int		y;

	item = game->items;
	last_one = 0;
	while (item)
	{
		if (is_on_map(item->x, item->y, game))
		{
			x = (item->x - game->map.x) * BLOCK_SIZE;
			y = (item->y - game->map.y) * BLOCK_SIZE;
			if (item_collision(item->x, item->y, game))
			{
				free_item(last_one, item, game);
				if (!last_one)
					last_one = game->items;
				if (!last_one)
					break ;
				item = last_one->next;
				continue ;
			}	
			copy_img_to(&game->map.map, &item->sprite,
				to_array(x, y + item->frame, BLOCK_SIZE, BLOCK_SIZE));
			item_animation(item);
		}
		last_one = item;
		item = item->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x130(%rdi), %r15
testq %r15, %r15
je 0x7b34
movq %rdi, %rbx
leaq 0x130(%rdi), %r12
leaq 0xf8(%rdi), %r14
xorl %r13d, %r13d
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7cbc
testl %eax, %eax
je 0x7b24
movl 0x28(%r15), %edi
movl 0x2c(%r15), %eax
movl 0x120(%rbx), %ecx
movl 0x124(%rbx), %edx
movl 0xb4(%rbx), %esi
addl %ecx, %esi
cmpl %edi, %esi
jne 0x7a96
movl 0xb8(%rbx), %esi
addl %edx, %esi
cmpl %eax, %esi
jne 0x7a96
leaq 0x38(%r13), %rax
testq %r13, %r13
movq 0x38(%r15), %rcx
cmoveq %r12, %rax
movq %rcx, (%rax)
movq (%r15), %rdi
callq 0x6190
movq %r15, %rdi
callq 0x6190
testq %r13, %r13
jne 0x7b27
movq (%r12), %r13
testq %r13, %r13
jne 0x7b27
jmp 0x7b34
subl %edx, %eax
shll $0x6, %eax
subl %ecx, %edi
shll $0x6, %edi
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss 0x30(%r15), %xmm0
cvttss2si %xmm0, %esi
movl $0x40, %edx
movl $0x40, %ecx
callq 0x6a73
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69c2
cmpl $0x0, 0x34(%r15)
movss 0x30(%r15), %xmm0
je 0x7af1
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7b04
cvtss2sd %xmm0, %xmm0
addsd 0x3639(%rip), %xmm0     # 0xb128
jmp 0x7b1a
ucomiss 0x3640(%rip), %xmm0     # 0xb138
jbe 0x7b0e
movl $0x1, 0x34(%r15)
jmp 0x7b24
movl $0x0, 0x34(%r15)
jmp 0x7b24
cvtss2sd %xmm0, %xmm0
addsd 0x3616(%rip), %xmm0     # 0xb130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%r15)
movq %r15, %r13
movq 0x38(%r13), %r15
testq %r15, %r15
jne 0x7a15
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/moviments.c
// Function: up
void	up(t_game *game)
{
	if (check_mov(game, 0, -1))
	{
		if (game->map.y > 0 && game->player.y < (game->height) / 2)
			game->map.y -= 1;
		else
			game->player.y -= 1;
		game->player.steps += 1;
	}
	game->player.frame = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6dec
testl %eax, %eax
je 0x7b8f
movl 0xb8(%rbx), %eax
movl 0x124(%rbx), %ecx
testl %ecx, %ecx
jle 0x7b81
movl 0x14c(%rbx), %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
cmpl %esi, %eax
jge 0x7b81
decl %ecx
movl %ecx, 0x124(%rbx)
jmp 0x7b89
decl %eax
movl %eax, 0xb8(%rbx)
incl 0xbc(%rbx)
movl $0x0, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/moviments.c
// Function: down
void	down(t_game *game)
{
	if (check_mov(game, 0, 1))
	{
		if (game->map.y < game->map.h - game->height \
			&& game->player.y > game->height / 2)
			game->map.y += 1;
		else
			game->player.y += 1;
		game->player.steps += 1;
	}
	game->player.frame = 2;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
movl $0x1, %edx
callq 0x6dec
testl %eax, %eax
je 0x7bf2
movl 0xb8(%rbx), %eax
movl 0x124(%rbx), %ecx
movl 0x12c(%rbx), %esi
movl 0x14c(%rbx), %edx
subl %edx, %esi
cmpl %esi, %ecx
jge 0x7be4
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
cmpl %esi, %eax
jle 0x7be4
incl %ecx
movl %ecx, 0x124(%rbx)
jmp 0x7bec
incl %eax
movl %eax, 0xb8(%rbx)
incl 0xbc(%rbx)
movl $0x2, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/moviments.c
// Function: left
void	left(t_game *game)
{
	if (check_mov(game, -1, 0))
	{
		if (game->map.x > 0 && game->player.x < (game->width) / 2)
			game->map.x -= 1;
		else
			game->player.x -= 1;
		game->player.steps += 1;
	}
	game->player.frame = 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x6dec
testl %eax, %eax
je 0x7c4d
movl 0xb4(%rbx), %eax
movl 0x120(%rbx), %ecx
testl %ecx, %ecx
jle 0x7c3f
movl 0x148(%rbx), %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
cmpl %esi, %eax
jge 0x7c3f
decl %ecx
movl %ecx, 0x120(%rbx)
jmp 0x7c47
decl %eax
movl %eax, 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x3, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/moviments.c
// Function: right
void	right(t_game *game)
{
	if (check_mov(game, 1, 0))
	{
		if ((game->map.x < game->map.w - game->width) \
			&& game->player.x > game->width / 2
		)
			game->map.x += 1;
		else
			game->player.x += 1;
		game->player.steps += 1;
	}
	game->player.frame = 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x6dec
testl %eax, %eax
je 0x7cb0
movl 0xb4(%rbx), %eax
movl 0x120(%rbx), %ecx
movl 0x128(%rbx), %esi
movl 0x148(%rbx), %edx
subl %edx, %esi
cmpl %esi, %ecx
jge 0x7ca2
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
cmpl %esi, %eax
jle 0x7ca2
incl %ecx
movl %ecx, 0x120(%rbx)
jmp 0x7caa
incl %eax
movl %eax, 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x1, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/enemy_action.c
// Function: render_enemies
void	render_enemies(t_game *game)
{
	t_enemy	*enemy;

	enemy = game->enemies;
	while (enemy)
	{
		if (is_on_map(enemy->x, enemy->y, game))
		{
			draw_enemy(enemy, game);
		}
		enemy_animation(game, enemy);
		enemy = enemy->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x138(%rdi), %r12
testq %r12, %r12
je 0x7e5c
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
xorl %ebp, %ebp
movl 0x80(%r12), %eax
movl 0x120(%rbx), %ecx
movl %eax, %edi
subl %ecx, %edi
jl 0x7d36
movl 0x148(%rbx), %edx
addl %ecx, %edx
cmpl %eax, %edx
jle 0x7d36
xorl %edx, %edx
jmp 0x7d38
movb $0x1, %dl
movl 0x84(%r12), %r8d
movl 0x124(%rbx), %r9d
movl %r8d, %esi
subl %r9d, %esi
jl 0x7dbc
addl 0x14c(%rbx), %r9d
cmpl %r8d, %r9d
setle %r8b
orb %r8b, %dl
jne 0x7dbc
movslq 0x7c(%r12), %r8
incl %eax
movl $0x40, %edx
cmpl %eax, %ecx
jg 0x7d85
addl 0x148(%rbx), %ecx
cmpl %eax, %ecx
jle 0x7d85
leaq (%r8,%r8,4), %rax
movl 0x1c(%r12,%rax,8), %edx
shll $0x6, %esi
xorps %xmm0, %xmm0
cvtsi2ss %esi, %xmm0
subss 0x78(%r12), %xmm0
cvttss2si %xmm0, %esi
shll $0x6, %edi
leaq (%r8,%r8,4), %rax
leaq (%r12,%rax,8), %r15
movl 0x20(%r15), %ecx
callq 0x6a73
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69c2
cmpl $0x0, 0x88(%r12)
movss 0x78(%r12), %xmm0
je 0x7de4
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7dfb
cvtss2sd %xmm0, %xmm0
addsd 0x3346(%rip), %xmm0     # 0xb128
jmp 0x7e40
ucomiss 0x334d(%rip), %xmm0     # 0xb138
jbe 0x7e34
movl $0x1, 0x88(%r12)
jmp 0x7e4b
movl 0x7c(%r12), %eax
movl 0x80(%r12), %esi
leal 0x1(%rax), %ecx
cmpl $0x2, %eax
cmovgel %ebp, %ecx
movl %ecx, 0x7c(%r12)
movl 0x84(%r12), %edx
movq %rbx, %rdi
callq 0x7664
movl $0x0, 0x88(%r12)
jmp 0x7e4b
cvtss2sd %xmm0, %xmm0
addsd 0x32f0(%rip), %xmm0     # 0xb130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x78(%r12)
movq 0x90(%r12), %r12
testq %r12, %r12
jne 0x7d12
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/fireball_action.c
// Function: render_fireball
void	render_fireball(t_game *game)
{
	t_fireball	*fireball;
	t_fireball	*last_one;

	fireball = game->fireballs;
	last_one = 0;
	while (fireball)
	{
		if (is_on_map(fireball->x, fireball->y, game))
			draw_fireball(fireball, game);
		if (fireball->steps == 8)
		{
			free_fireball(last_one, fireball, game);
			fireball = last_one;
			if (!fireball)
				fireball = game->fireballs;
			if (!fireball)
				break ;
		}
		else
		{
			fireball->x += 1;
			fireball->steps += 1;
		}
		last_one = fireball;
		fireball = fireball->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x140(%rdi), %r15
testq %r15, %r15
je 0x7f45
movq %rdi, %rbx
leaq 0x140(%rdi), %r12
leaq 0xf8(%rdi), %r14
xorl %r13d, %r13d
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7cbc
testl %eax, %eax
je 0x7ef0
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
subl 0x120(%rbx), %edi
shll $0x6, %edi
subl 0x124(%rbx), %esi
shll $0x6, %esi
movl $0x40, %edx
movl $0x40, %ecx
callq 0x6a73
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x69c2
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7826
movl 0x30(%r15), %eax
cmpl $0x8, %eax
jne 0x7f2b
leaq 0x38(%r13), %rax
testq %r13, %r13
movq 0x38(%r15), %rcx
cmoveq %r12, %rax
movq %rcx, (%rax)
movq (%r15), %rdi
callq 0x6190
movq %r15, %rdi
callq 0x6190
testq %r13, %r13
jne 0x7f38
movq (%r12), %r13
testq %r13, %r13
jne 0x7f38
jmp 0x7f45
incl 0x28(%r15)
incl %eax
movl %eax, 0x30(%r15)
movq %r15, %r13
movq 0x38(%r13), %r15
testq %r15, %r15
jne 0x7e95
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/game_over.c
// Function: print_over
void	print_over(t_game *game)
{
	t_data			game_over;
	int				x;
	int				y;

	game_over.w = 544;
	game_over.h = 416;
	load_img(&game_over, "./imgs/over.xpm", game);
	x = (game->width * BLOCK_SIZE) - game_over.w;
	if (x < 0)
		x = 0;
	y = (game->height * BLOCK_SIZE) - game_over.h;
	if (y < 0)
		y = 0;
	mlx_clear_window(game->vars.mlx, game->vars.win);
	mlx_put_image_to_window(game->vars.mlx, game->vars.win,
		game_over.img, x, y);
	free(game_over.img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movabsq $0x1a000000220, %rax    # imm = 0x1A000000220
movq %rsp, %rbx
movq %rax, 0x1c(%rbx)
leaq 0x31cb(%rip), %rsi      # 0xb140
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6aa8
movl 0x148(%r14), %ebp
shll $0x6, %ebp
subl 0x1c(%rbx), %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
movl 0x14c(%r14), %r15d
shll $0x6, %r15d
subl 0x20(%rbx), %r15d
testl %r15d, %r15d
cmovlel %eax, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x8f90
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x8d90
movq (%rbx), %rdi
callq 0x6190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/actions/game_over.c
// Function: print_screen
void	print_screen(t_game *game)
{
	t_data			img;
	int				x;
	int				y;

	img.w = 255;
	img.h = 255;
	load_img(&img, "./imgs/v.xpm", game);
	x = (game->width * BLOCK_SIZE) / 2 - img.w;
	if (x < 0)
		x = 0;
	y = ((game->height * BLOCK_SIZE) / 2) - img.h;
	if (y < 0)
		y = 0;
	mlx_clear_window(game->vars.mlx, game->vars.win);
	mlx_put_image_to_window(game->vars.mlx, game->vars.win,
		img.img, x, y);
	free(img.img);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movabsq $0xff000000ff, %rax     # imm = 0xFF000000FF
movq %rsp, %rbx
movq %rax, 0x1c(%rbx)
leaq 0x314e(%rip), %rsi      # 0xb150
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6aa8
movl 0x148(%r14), %ebp
shll $0x5, %ebp
subl 0x1c(%rbx), %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
movl 0x14c(%r14), %r15d
shll $0x5, %r15d
subl 0x20(%rbx), %r15d
testl %r15d, %r15d
cmovlel %eax, %r15d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x8f90
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x8d90
movq (%rbx), %rdi
callq 0x6190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]spiped/tests/pthread_create_blocking_np/main.c
// Function: main
int
main(int argc, char ** argv)
{

	WARNP_INIT;
	(void)argc; /* UNUSED */

	/* Check basic stuff. */
	if (check_basic())
		goto err0;

	/* Check the relative timing of points in the code. */
	if (check_timing())
		goto err0;

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1451
callq 0x1e28
movq $0x0, (%rsp)
leaq 0xc0(%rip), %rdx        # 0x1520
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x20ec
testl %eax, %eax
jne 0x14a3
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x11c0
testl %eax, %eax
jne 0x14cf
movq (%rsp), %rsi
leaq 0x3c9e(%rip), %rax      # 0x512c
cmpq %rax, %rsi
jne 0x14f6
callq 0x1528
testl %eax, %eax
jne 0x1516
xorl %edi, %edi
callq 0x11a0
movl %eax, %ebp
callq 0x1060
movq %rax, %rbx
movl (%rax), %r14d
movl %ebp, %edi
callq 0x11e0
leaq 0x1b46(%rip), %rdi      # 0x3004
movq %rax, %rsi
xorl %eax, %eax
testl %r14d, %r14d
jne 0x14e9
callq 0x1fc7
jmp 0x1516
movl %eax, %edi
callq 0x11e0
leaq 0x1b46(%rip), %rdi      # 0x3023
movq %rax, %rsi
xorl %eax, %eax
callq 0x1fc7
jmp 0x150b
callq 0x1ea8
movl $0x0, (%rbx)
jmp 0x1516
leaq 0x1b37(%rip), %rdi      # 0x3034
leaq 0x3c28(%rip), %rdx      # 0x512c
xorl %eax, %eax
callq 0x1fc7
callq 0x1060
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]spiped/tests/pthread_create_blocking_np/timing.c
// Function: workfunc
static void *
workfunc(void * cookie)
{
	struct info * info = cookie;

	/* For checking the order. */
	if (monoclock_get(&info->thr_start))
		warnp("monoclock_get");

	/* Wait if the test calls for it. */
	if (info->options & WAIT_THREAD_AFTER_START)
		millisleep(WAIT_MS);

	/* For checking the order. */
	if (monoclock_get(&info->thr_stop))
		warnp("monoclock_get");

	return (NULL);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x1bec
testl %eax, %eax
je 0x1b81
callq 0x1060
cmpl $0x0, (%rax)
je 0x1b73
movq %rax, %r14
leaq 0x152d(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1ea8
movl $0x0, (%r14)
jmp 0x1b81
leaq 0x1516(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1fc7
testb $0x1, (%rbx)
je 0x1ba1
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movq $0x989680, 0x8(%rdi)    # imm = 0x989680
xorl %esi, %esi
callq 0x10b0
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x1bec
testl %eax, %eax
je 0x1be2
callq 0x1060
cmpl $0x0, (%rax)
je 0x1bd4
movq %rax, %rbx
leaq 0x14cb(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1ea8
movl $0x0, (%rbx)
jmp 0x1be2
leaq 0x14b5(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1fc7
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/vmtest.c
// Function: main
int
main(void)
{
	printf("Starting VM tests.\n");
	test1();
	test2();
	printf("VM tests complete.\n");

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0xb60(%rip), %rdi       # 0x2128
callq 0x1050
movabsq $0x6060002050100, %rax  # imm = 0x6060002050100
movq %rax, 0x6(%rsp)
movabsq $0x100020503000505, %rax # imm = 0x100020503000505
movq %rax, (%rsp)
callq 0x1398
testq %rax, %rax
je 0x16ad
movq %rax, %rbx
movq %rsp, %rsi
movq %rax, %rdi
movl $0xf, %edx
callq 0x1555
testl %eax, %eax
je 0x16bb
movq %rbx, %rdi
callq 0x1579
cmpw $0x14, %ax
jne 0x169f
leaq 0xb26(%rip), %rdi       # 0x214e
callq 0x1050
movq %rbx, %rdi
callq 0x13ef
movaps 0xa84(%rip), %xmm0      # 0x20c0
movaps %xmm0, (%rsp)
movl $0x60606, 0xf(%rsp)     # imm = 0x60606
callq 0x1398
testq %rax, %rax
je 0x16ad
movq %rax, %rbx
movq %rsp, %rsi
movq %rax, %rdi
movl $0x13, %edx
callq 0x1555
testl %eax, %eax
je 0x16bb
movq %rbx, %rdi
callq 0x1579
cmpw $0x8, %ax
jne 0x16a6
leaq 0xade(%rip), %rdi       # 0x215c
callq 0x1050
movq %rbx, %rdi
callq 0x13ef
leaq 0xaa9(%rip), %rdi       # 0x213b
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x112c
jmp 0x162d
callq 0x114e
jmp 0x1683
leaq 0xa1f(%rip), %rsi       # 0x20d3
movl $0x47, %edi
jmp 0x16c7
leaq 0xa33(%rip), %rsi       # 0x20f5
movl $0x46, %edi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/acidDrain[P]st/st.c
// Function: newterm
void
newterm(const Arg* a)
{
	switch (fork()) {
	case -1:
		die("fork failed: %s\n", strerror(errno));
		break;
	case 0:
		chdir(getcwd_by_pid(pid));
		execlp("st", "./st", "-c", "st-256color", "-t", "Suckless Terminal", "-f", "Fira Code:style=bold:size=11:hinting=true:autohint=true:antialias=true:hintstyle=hintslight", NULL);
		break;
	}
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
callq 0x5890
testl %eax, %eax
je 0x7ca2
cmpl $-0x1, %eax
je 0x7d22
addq $0x20, %rsp
jmp 0x7d20
movl 0x13e54(%rip), %ecx     # 0x1bafc
leaq 0x8bab(%rip), %rdx      # 0x1085a
movq %rsp, %rbx
movl $0x20, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5410
movq %rax, %rdi
callq 0x5060
subq $0x8, %rsp
leaq 0x89c2(%rip), %r10      # 0x106a0
leaq 0x89b8(%rip), %r11      # 0x1069d
leaq 0x898a(%rip), %rdi      # 0x10676
leaq 0x8981(%rip), %rsi      # 0x10674
leaq 0x897f(%rip), %rdx      # 0x10679
leaq 0x897b(%rip), %rcx      # 0x1067c
leaq 0x8980(%rip), %r8       # 0x10688
leaq 0x897c(%rip), %r9       # 0x1068b
xorl %eax, %eax
pushq $0x0
pushq %r10
pushq %r11
callq 0x5230
addq $0x40, %rsp
popq %rbx
retq
callq 0x5600
movl (%rax), %edi
callq 0x54b0
leaq 0x88d3(%rip), %rdi      # 0x10608
movq %rax, %rsi
xorl %eax, %eax
callq 0x5f46
// File: /workspace/github_c_makefile_star2_O3/acidDrain[P]st/x.c
// Function: setpalette
void setpalette(const Arg *arg) {

    if ( arg->i < LEN(palettes) )   {
        colorname = palettes[arg->i];
        xloadcols();
        cresize(win.w, win.h);
    }
}

// Assembly:
movl (%rdi), %eax
cmpq $0x3, %rax
ja 0xe190
pushq %rax
shlq $0x7, %rax
leaq 0x9401(%rip), %rcx      # 0x17570
addq %rax, %rcx
movq %rcx, 0xfee7(%rip)      # 0x1e060
callq 0xaa8a
movl 0xfef4(%rip), %edi      # 0x1e078
movl 0xfef2(%rip), %esi      # 0x1e07c
popq %rax
jmp 0xd6a1
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/moshmap.c
// Function: usage
void usage (void)
{ fprintf (stderr, "Usage: moshmap <commands>\n") ;
  fprintf (stderr, "Commands are executed in order - set parameters before using them!\n") ;
  fprintf (stderr, "  -K | --kmer <kmer size> [%d]\n", params.k) ;
  fprintf (stderr, "  -W | --window <window> [%d]\n", params.w) ;
  fprintf (stderr, "  -S | --seed <random number seed> [%d]\n", params.s) ;
  fprintf (stderr, "  -B | --tableBits <hash index table bitcount> [%d]\n", params.B) ;
  fprintf (stderr, "  -v | --verbose : toggle verbose mode\n") ;
  fprintf (stderr, "  -t | --threads <number of threads for parallel ops> [%d]\n", numThreads) ;
  fprintf (stderr, "  -o | --output <output filename> : '-' for stdout\n") ;
  fprintf (stderr, "  -f | --referenceFasta <reference fasta file>\n") ;
  fprintf (stderr, "  -w | --referenceWrite <file stem> : writes reference hash files\n") ;
  fprintf (stderr, "  -r | --referenceRead <file stem> : read reference hash files\n") ;
  fprintf (stderr, "  -q | --query <query fasta file>\n") ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9dbd(%rip), %r14      # 0xaff8
movq (%r14), %rcx
leaq 0x6165(%rip), %rdi      # 0x73aa
pushq $0x1a
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x6168(%rip), %rdi      # 0x73c5
pushq $0x43
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rdi
movl 0xb0df(%rip), %edx      # 0xc350
leaq 0x6191(%rip), %rsi      # 0x7409
xorl %eax, %eax
callq 0x1120
movq (%r14), %rdi
movl 0xb0cc(%rip), %edx      # 0xc354
leaq 0x619a(%rip), %rsi      # 0x7429
xorl %eax, %eax
callq 0x1120
movq (%r14), %rdi
movl 0xb0b9(%rip), %edx      # 0xc358
leaq 0x61a2(%rip), %rsi      # 0x7448
xorl %eax, %eax
callq 0x1120
movq (%r14), %rdi
movl 0xb0a6(%rip), %edx      # 0xc35c
leaq 0x61b4(%rip), %rsi      # 0x7471
xorl %eax, %eax
callq 0x1120
movq (%r14), %rcx
leaq 0x61d8(%rip), %rdi      # 0x74a6
pushq $0x27
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rdi
movl 0x9e3e(%rip), %edx      # 0xb120
leaq 0x61e5(%rip), %rsi      # 0x74ce
xorl %eax, %eax
callq 0x1120
movq (%r14), %rcx
leaq 0x6210(%rip), %rdi      # 0x750a
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x622f(%rip), %rdi      # 0x753e
pushq $0x2f
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x624a(%rip), %rdi      # 0x756e
pushq $0x42
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x6278(%rip), %rdi      # 0x75b1
pushq $0x3f
popq %rsi
movq %rbx, %rdx
callq 0x11f0
movq (%r14), %rcx
leaq 0x62a3(%rip), %rdi      # 0x75f1
pushq $0x22
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/moshmap.c
// Function: referenceCreate
Reference *referenceCreate (Moshset *ms, U32 size)
{
  if (!ms || !ms->size) die ("moshset must be initialised before reference") ;
  if (!size) die ("refCreate must have size > 0") ;
  Reference *ref = new0 (1, Reference) ;
  ref->ms = ms ;
  ref->depth = ms->max ? new0 (ms->max, U32) : new0 (ms->size, U32) ;
  ref->size = size ;
  ref->index = new (size, U32) ;
  ref->offset = new (size, U32) ;
  ref->id = new (size, U32) ;
  ref->dict = dictCreate (1024) ;
  ref->len = arrayCreate (1024, U32) ;
  /* NB don't create loc and rev here */
  return ref ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
testq %rdi, %rdi
je 0x1e02
cmpl $0x0, 0xc(%r15)
jne 0x1e10
leaq 0x5217(%rip), %rdi      # 0x7020
xorl %eax, %eax
callq 0x63e4
testl %ebx, %ebx
jne 0x1e22
leaq 0x5232(%rip), %rdi      # 0x704d
xorl %eax, %eax
callq 0x63e4
movl $0x1, %edi
movl $0x50, %esi
callq 0x64d4
movq %rax, %r14
movq %r15, (%rax)
movl 0x40(%r15), %eax
testl %eax, %eax
jne 0x1e43
movl 0xc(%r15), %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x64d4
movq %rax, 0x28(%r14)
movl %ebx, 0x8(%r14)
movl %ebx, %ebx
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x64ac
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x64ac
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x64ac
movq %rax, 0x20(%r14)
movl $0x400, %edi            # imm = 0x400
callq 0x5660
movq %rax, 0x40(%r14)
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0x5c74
movq %rax, 0x48(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/richarddurbin[P]hash10x/moshmap.c
// Function: referenceDestroy
void referenceDestroy (Reference *ref)
{ free (ref->depth) ;
  if (ref->loc) free (ref->loc) ; if (ref->rev) free (ref->rev) ;
  free (ref->index) ; free (ref->offset) ; free (ref->id) ;
  dictDestroy (ref->dict) ; arrayDestroy (ref->len) ;
  free (ref) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1040
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1ec6
callq 0x1040
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1ed4
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x1040
movq 0x20(%rbx), %rdi
callq 0x1040
movq 0x40(%rbx), %rdi
callq 0x56d5
movq 0x48(%rbx), %rdi
callq 0x5dc2
movq %rbx, %rdi
popq %rbx
jmp 0x1040