LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, 0xac(%rax)
movl $0x90, -0x14(%rbp)
movl $0x100, -0x10(%rbp)     # imm = 0x100
movq -0x38(%rbp), %rax
movl $0x30, 0xb0(%rax)
movq -0x38(%rbp), %rax
movl $0x40, 0xb4(%rax)
movq -0x38(%rbp), %rax
movl $0x2, 0xa0(%rax)
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x41e9(%rip), %rsi      # 0xc0bd
callq 0x6e60
cmpl $0x4, -0x3c(%rbp)
jge 0x7f69
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rax
movl 0xb0(%rax), %esi
movq -0x38(%rbp), %rax
movl 0xb4(%rax), %edx
movq -0x8(%rbp), %rcx
callq 0x6ee0
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl 0xb4(%rax), %esi
imull -0x3c(%rbp), %esi
movq -0x38(%rbp), %rax
movl 0xb0(%rax), %edx
movq -0x38(%rbp), %rax
movl 0xb4(%rax), %ecx
xorl %edi, %edi
callq 0x6e00
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq -0x30(%rbp), %rsi
callq 0x6c40
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7ed9
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x65f0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x40, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x40, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x40ff(%rip), %rsi      # 0xc0cd
callq 0x6e60
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x7ffd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8006
jmp 0x8014
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7fe2
cmpq $0x0, -0x18(%rbp)
je 0x8029
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x8038
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x130(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/enemy_config.c
// Function: check_surround
int	check_surround(int y, int x, t_game *game)
{
	char	**layout;
	int		range;
	int		index;

	index = 0;
	range = 5;
	layout = game->map.layout;
	if (layout[y][x] != '0')
		return (0);
	if (layout[y][x - 1] == 'C')
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x5, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
je 0x808d
movl $0x0, -0x4(%rbp)
jmp 0x80bb
movq -0x20(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0x80b4
movl $0x1, -0x4(%rbp)
jmp 0x80bb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, %edi
movl $0x98, %esi
callq 0x65f0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x80(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x20(%rbp), %rax
movl $0x50, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x60, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x7a, 0x44(%rax)
movq -0x20(%rbp), %rax
movl $0x67, 0x48(%rax)
movq -0x20(%rbp), %rax
movl $0x56, 0x6c(%rax)
movq -0x20(%rbp), %rax
movl $0x6e, 0x70(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3f8d(%rip), %rsi      # 0xc0dd
callq 0x6e60
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rdx
leaq 0x3f86(%rip), %rsi      # 0xc0ee
callq 0x6e60
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rdx
leaq 0x3f80(%rip), %rsi      # 0xc100
callq 0x6e60
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x81b2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x81bb
jmp 0x81cc
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8194
cmpq $0x0, -0x18(%rbp)
je 0x81e4
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0x81f3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x138(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x12c(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x8291
jmp 0x8245
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
je 0x8289
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x8040
cmpl $0x0, %eax
je 0x8287
cmpl $0xa, -0x18(%rbp)
jge 0x8287
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x80c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8245
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x8233
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x65f0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x40, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x40, 0x20(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3e14(%rip), %rsi      # 0xc112
callq 0x6e60
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x832d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x8336
jmp 0x8344
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8312
cmpq $0x0, -0x18(%rbp)
je 0x8359
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x8368
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x140(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x14c(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x12c(%rcx), %eax
jg 0x8446
jmp 0x83a9
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x148(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x128(%rcx), %eax
jg 0x8431
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x8460
cmpl $0x0, %eax
je 0x8423
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x120(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x124(%rax)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0xb4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xb4(%rax)
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xb8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x844d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x83a9
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x838a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/config/fix_cam.c
// Function: player_on_screen
static int	player_on_screen(int x, int y, t_game *game)
{
	int	x_max;
	int	x_hold;
	int	y_max;

	x_hold = x;
	x_max = x + game->width;
	y_max = y + game->height;
	while (y < y_max)
	{
		while (x < x_max)
		{
			if (game->map.layout[y][x] == 'P')
				return (1);
			x++;
		}
		x = x_hold;
		y++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0x148(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0x14c(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x84eb
jmp 0x849e
movl -0x8(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x84da
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x50, %eax
jne 0x84cf
movl $0x1, -0x4(%rbp)
jmp 0x84f2
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x849e
movl -0x20(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8494
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x77, -0x4(%rbp)
jne 0x851e
movq -0x10(%rbp), %rdi
callq 0x8b40
cmpl $0x61, -0x4(%rbp)
jne 0x852d
movq -0x10(%rbp), %rdi
callq 0x8cb0
cmpl $0x73, -0x4(%rbp)
jne 0x853c
movq -0x10(%rbp), %rdi
callq 0x8bf0
cmpl $0x64, -0x4(%rbp)
jne 0x854b
movq -0x10(%rbp), %rdi
callq 0x8d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
shll $0x6, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq -0x8(%rbp), %rcx
movslq 0xb0(%rcx), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xc8, %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0xc0(%rax), %edx
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %ecx
callq 0x6e00
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x6d20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x62(%rip), %rsi        # 0x86d0
callq 0x9af0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %r8
movl $0x11, %esi
movl $0x20000, %edx          # imm = 0x20000
leaq 0x170(%rip), %rcx       # 0x8800
callq 0xb520
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %r8
movl $0x2, %esi
movl $0x1, %edx
leaq 0x17e(%rip), %rcx       # 0x8830
callq 0xb520
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x9980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x154(%rax)
je 0x8711
cmpl $0x0, 0x13358(%rip)     # 0x1ba48
jne 0x86fb
movq -0x10(%rbp), %rdi
callq 0x9330
movl $0x1, 0x13343(%rip)     # 0x1ba48
movl $0x1, -0x4(%rbp)
jmp 0x87f7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x158(%rax)
je 0x8746
cmpl $0x0, 0x13323(%rip)     # 0x1ba48
jne 0x8730
movq -0x10(%rbp), %rdi
callq 0x93e0
movl $0x1, 0x1330e(%rip)     # 0x1ba48
movl $0x1, -0x4(%rbp)
jmp 0x87f7
movq -0x10(%rbp), %rdi
callq 0x7b00
movq -0x10(%rbp), %rdi
callq 0x8560
movq -0x10(%rbp), %rdi
callq 0x8ea0
movq -0x10(%rbp), %rdi
callq 0x8890
movq -0x10(%rbp), %rdi
callq 0x9150
movq -0x10(%rbp), %rdi
callq 0x7530
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xa1c0
movq -0x10(%rbp), %rax
movl 0xbc(%rax), %edi
callq 0x6fd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x148(%rax), %edx
shll $0x6, %edx
subl $0x14, %edx
movq -0x18(%rbp), %r9
movl $0x14, %ecx
movl $0xf35c00, %r8d         # imm = 0xF35C00
callq 0x9cd0
movq -0x18(%rbp), %rdi
callq 0x61a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x154(%rax)
jne 0x8859
movq -0x10(%rbp), %rax
cmpl $0x0, 0x158(%rax)
je 0x8862
movl $0x1, -0x4(%rbp)
jmp 0x8887
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x8500
cmpl $0xff1b, -0x8(%rbp)     # imm = 0xFF1B
jne 0x8880
movq -0x10(%rbp), %rdi
callq 0x8800
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x89d6
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x8e20
cmpl $0x0, %eax
je 0x89bd
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x120(%rcx), %eax
shll $0x6, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x124(%rcx), %eax
shll $0x6, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x89e0
cmpl $0x0, %eax
je 0x8969
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x8a40
cmpq $0x0, -0x18(%rbp)
jne 0x894f
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8958
jmp 0x89d6
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x88b3
movq -0x8(%rbp), %rax
addq $0xc8, %rax
addq $0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
cvtsi2ssl -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0x30(%rax), %xmm0
cvttss2si %xmm0, %esi
movl $0x40, %ecx
movl %ecx, %edx
callq 0x6e00
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x6d20
movq -0x10(%rbp), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x88b3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/item_action.c
// Function: item_collision
static int	item_collision(int x,int y, t_game *game)
{
	if ((game->player.x + game->map.x) == x && \
		(game->player.y + game->map.y) == y)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0xb4(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x120(%rcx), %eax
cmpl -0x8(%rbp), %eax
jne 0x8a29
movq -0x18(%rbp), %rax
movl 0xb8(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x124(%rcx), %eax
cmpl -0xc(%rbp), %eax
jne 0x8a29
movl $0x1, -0x4(%rbp)
jmp 0x8a30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/item_action.c
// Function: free_item
static void	free_item(t_item *last_one, t_item *item, t_game *game)
{
	if (!last_one)
		game->items = item->next;
	else
		last_one->next = item->next;
	free(item->sprite.img);
	free(item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8a70
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x130(%rax)
jmp 0x8a80
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x61a0
movq -0x10(%rbp), %rdi
callq 0x61a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/item_action.c
// Function: item_animation
static void	item_animation(t_item *item)
{
	if (item->going_up)
	{
		if (item->frame <= 0)
			item->going_up = 0;
		else
			item->frame -= .6;
	}
	else
	{
		if (item->frame > 7)
			item->going_up = 1;
		else
			item->frame += .6;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x8af0
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x30(%rax), %xmm0
jb 0x8acc
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
jmp 0x8aee
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x364f(%rip), %xmm1     # 0xc130
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
jmp 0x8b37
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm0
movss 0x3627(%rip), %xmm1     # 0xc128
ucomiss %xmm1, %xmm0
jbe 0x8b13
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
jmp 0x8b35
movq -0x8(%rbp), %rax
movss 0x30(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3608(%rip), %xmm1     # 0xc130
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
jmp 0x8b37
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x74b0
cmpl $0x0, %eax
je 0x8bd1
movq -0x8(%rbp), %rax
cmpl $0x0, 0x124(%rax)
jle 0x8bab
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jge 0x8bab
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x124(%rax)
jmp 0x8bbe
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x74b0
cmpl $0x0, %eax
je 0x8c9a
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x12c(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x14c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8c74
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jle 0x8c74
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x124(%rax)
jmp 0x8c87
movq -0x8(%rbp), %rax
movl 0xb8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x74b0
cmpl $0x0, %eax
je 0x8d41
movq -0x8(%rbp), %rax
cmpl $0x0, 0x120(%rax)
jle 0x8d1b
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x148(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jge 0x8d1b
movq -0x8(%rbp), %rax
movl 0x120(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x120(%rax)
jmp 0x8d2e
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x74b0
cmpl $0x0, %eax
je 0x8e0a
movq -0x8(%rbp), %rax
movl 0x120(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x128(%rcx), %ecx
movq -0x8(%rbp), %rdx
subl 0x148(%rdx), %ecx
cmpl %ecx, %eax
jge 0x8de4
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x148(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jle 0x8de4
movq -0x8(%rbp), %rax
movl 0x120(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x120(%rax)
jmp 0x8df7
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb4(%rax)
movq -0x8(%rbp), %rax
movl 0xbc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xb0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/enemy_action.c
// Function: is_on_map
int	is_on_map(int x, int y, t_game *game)
{
	int	is_on_map;

	is_on_map = 1;
	if (!(x >= game->map.x && x < game->map.x + game->width))
		is_on_map = 0;
	if (!(y >= game->map.y && y < game->map.y + game->height))
		is_on_map = 0;
	return (is_on_map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jl 0x8e5f
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x120(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x148(%rdx), %ecx
cmpl %ecx, %eax
jl 0x8e66
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jl 0x8e90
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x124(%rcx), %ecx
movq -0x10(%rbp), %rdx
addl 0x14c(%rdx), %ecx
cmpl %ecx, %eax
jl 0x8e97
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8f0f
movq -0x10(%rbp), %rax
movl 0x80(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x84(%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x8e20
cmpl $0x0, %eax
je 0x8ef1
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x8f20
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9030
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8ebb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/enemy_action.c
// Function: draw_enemy
static void	draw_enemy(t_enemy *enemy, t_game *game)
{
	int		i;
	int		x;
	int		y;
	int		w;
	t_enemy	cpy;

	i = enemy->active;
	x = ((enemy->x - game->map.x) * BLOCK_SIZE);
	y = (((enemy->y - game->map.y) * BLOCK_SIZE)) - enemy->frame;
	if (is_on_map(enemy->x + 1, enemy->y, game))
		w = enemy->sprites[i].w;
	else
		w = BLOCK_SIZE;
	copy_img_to(&game->map.map, &enemy->sprites[i],
		to_array(x, y, w, enemy->sprites[i].h));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x80(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x120(%rcx), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x84(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x124(%rcx), %eax
shll $0x6, %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
subss 0x78(%rax), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x80(%rax), %edi
addl $0x1, %edi
movq -0x8(%rbp), %rax
movl 0x84(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x8e20
cmpl $0x0, %eax
je 0x8fbe
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x8fc5
movl $0x40, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0xc8, %rax
addq $0x30, %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
callq 0x6e00
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
callq 0x6d20
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/enemy_action.c
// Function: enemy_animation
static void	enemy_animation(t_game *game, t_enemy *enemy)
{
	if (enemy->going_up)
	{
		if (enemy->frame <= 0)
		{
			change_active(game, enemy);
			enemy->going_up = 0;
		}
		else
			enemy->frame -= .6;
	}
	else
	{
		if (enemy->frame > 7)
			enemy->going_up = 1;
		else
			enemy->frame += .6;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x909b
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x78(%rax), %xmm0
jb 0x9077
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x90f0
movq -0x10(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x9099
movq -0x10(%rbp), %rax
movss 0x78(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x30a4(%rip), %xmm1     # 0xc130
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x78(%rax)
jmp 0x90e5
movq -0x10(%rbp), %rax
movss 0x78(%rax), %xmm0
movss 0x307c(%rip), %xmm1     # 0xc128
ucomiss %xmm1, %xmm0
jbe 0x90c1
movq -0x10(%rbp), %rax
movl $0x1, 0x88(%rax)
jmp 0x90e3
movq -0x10(%rbp), %rax
movss 0x78(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x305a(%rip), %xmm1     # 0xc130
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x78(%rax)
jmp 0x90e5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/enemy_action.c
// Function: change_active
static void	change_active(t_game *game, t_enemy *enemy)
{
	if (enemy->active < 2)
		enemy->active += 1;
	else
		enemy->active = 0;
	new_fireball(game, enemy->x, enemy->y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x7c(%rax)
jge 0x9119
movq -0x10(%rbp), %rax
movl 0x7c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x7c(%rax)
jmp 0x9124
movq -0x10(%rbp), %rax
movl $0x0, 0x7c(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x80(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edx
callq 0x82a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x921e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x8(%rbp), %rdx
callq 0x8e20
cmpl $0x0, %eax
je 0x91a7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x9230
movq -0x10(%rbp), %rax
cmpl $0x8, 0x30(%rax)
jne 0x91eb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x92d0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x91e0
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x91e9
jmp 0x921e
jmp 0x9205
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9173
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/fireball_action.c
// Function: draw_fireball
static void	draw_fireball(t_fireball *fireball, t_game *game)
{
	int			x;
	int			y;

	x = (fireball->x - game->map.x) * BLOCK_SIZE;
	y = (fireball->y - game->map.y) * BLOCK_SIZE;
	copy_img_to(&game->map.map, &fireball->sprite,
		to_array(x, y, BLOCK_SIZE, BLOCK_SIZE));
	check_player_collision(fireball->x, fireball->y, game);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x120(%rcx), %eax
shll $0x6, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x124(%rcx), %eax
shll $0x6, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0xc8, %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl $0x40, %ecx
movl %ecx, %edx
callq 0x6e00
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x6d20
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x8600
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/alsmd[P]so_long/src/actions/fireball_action.c
// Function: free_fireball
static void	free_fireball(t_fireball *last_one, t_fireball *ball, t_game *game)
{
	if (!last_one)
		game->fireballs = ball->next;
	else
		last_one->next = ball->next;
	free(ball->sprite.img);
	free(ball);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9300
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x140(%rax)
jmp 0x9310
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x61a0
movq -0x10(%rbp), %rdi
callq 0x61a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x220, -0x14(%rbp)     # imm = 0x220
movl $0x1a0, -0x10(%rbp)     # imm = 0x1A0
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x2ddf(%rip), %rsi      # 0xc138
callq 0x6e60
movq -0x8(%rbp), %rax
movl 0x148(%rax), %eax
shll $0x6, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x937e
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %eax
shll $0x6, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x939e
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa3c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
callq 0xa1c0
movq -0x30(%rbp), %rdi
callq 0x61a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0xff, -0x14(%rbp)
movl $0xff, -0x10(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq 0x2d3f(%rip), %rsi      # 0xc148
callq 0x6e60
movq -0x8(%rbp), %rax
movl 0x148(%rax), %eax
shll $0x6, %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x9436
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x14c(%rax), %eax
shll $0x6, %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x945e
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa3c0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %r8d
callq 0xa1c0
movq -0x30(%rbp), %rdi
callq 0x61a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/goto.c
// Function: main
int
main(int argc, char **argv)
{
	size_t siz;
	char label[LABELMAX];

	setmyerrexit(&ut_errexit);
	setmyname(argv[0]);
	setmypid(getpid());

	if (argc < 2 || *argv[1] == EOS || isatty(FD0) != 0)
		err(FC_ERR, FMT2S, getmyname(), ERR_GENERIC);
	if ((siz = strlen(argv[1]) + 1) > sizeof(label))
		err(FC_ERR, FMT3S, getmyname(), argv[1], ERR_LABTOOLONG);
	if (lseek(FD0, (off_t)0, SEEK_SET) == -1)
		err(FC_ERR, FMT2S, getmyname(), ERR_SEEK);

	while (getlabel(label, *argv[1] & 0377, siz))
		if (strcmp(label, argv[1]) == 0) {
#ifndef	CONFIG_SUNOS
			(void)lseek(FD0, offset, SEEK_SET);
#endif
			return SH_TRUE;
		}

	fd_print(FD2, FMT3S, getmyname(), argv[1], ERR_LABNOTFOUND);
	return SH_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x793(%rip), %rdi       # 0x19c0
callq 0x18d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x18f0
callq 0x1090
movl %eax, %edi
callq 0x19a0
cmpl $0x2, -0x8(%rbp)
jl 0x126c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x126c
xorl %edi, %edi
callq 0x1060
cmpl $0x0, %eax
je 0x128e
callq 0x1870
movq %rax, %rdx
movl $0x7c, %edi
leaq 0xe91(%rip), %rsi       # 0x2111
leaq 0xe80(%rip), %rcx       # 0x2107
movb $0x0, %al
callq 0x1570
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x41, %rax
jbe 0x12d3
callq 0x1870
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x7c, %edi
leaq 0xe48(%rip), %rsi       # 0x210d
leaq 0xe4d(%rip), %r8        # 0x2119
movb $0x0, %al
callq 0x1570
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %esi
movl %edx, %edi
callq 0x10d0
cmpq $-0x1, %rax
jne 0x1308
callq 0x1870
movq %rax, %rdx
movl $0x7c, %edi
leaq 0xe17(%rip), %rsi       # 0x2111
leaq 0xe27(%rip), %rcx       # 0x2128
movb $0x0, %al
callq 0x1570
jmp 0x130a
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %esi
andl $0xff, %esi
movq -0x18(%rbp), %rdx
callq 0x13a0
testb $0x1, %al
jne 0x132e
jmp 0x135f
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10e0
cmpl $0x0, %eax
jne 0x135d
movq 0x2d5d(%rip), %rsi      # 0x40a8
xorl %edx, %edx
movl %edx, %edi
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x1390
jmp 0x130a
callq 0x1870
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x2, %edi
leaq 0xd92(%rip), %rsi       # 0x210d
leaq 0xdb2(%rip), %r8        # 0x2134
movb $0x0, %al
callq 0x17c0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/goto.c
// Function: xgetc
static int
xgetc(void)
{
#ifndef	CONFIG_SUNOS
	int nc;

	offset++;
	nc = getchar();
	return (nc != EOF) ? nc & 0377 : EOF;
#else
	unsigned char nc;

	return (read(FD0, &nc, (size_t)1) == 1) ? nc : EOF;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2b79(%rip), %rax      # 0x40a8
addq $0x1, %rax
movq %rax, 0x2b6e(%rip)      # 0x40a8
callq 0x10f0
movl %eax, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
je 0x1555
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
jmp 0x155f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x8(%rbp)
jmp 0x155f
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x131c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x21b0
jmp 0x131e
callq 0x1350
cmpl $0x0, %eax
je 0x132a
jmp 0x133d
callq 0x1490
cmpl $0x0, %eax
je 0x1336
jmp 0x133d
xorl %edi, %edi
callq 0x1180
movl $0x1, %edi
callq 0x1180
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/pthread_create_blocking_np/main.c
// Function: check_basic
static int
check_basic(void)
{
	pthread_t thr;
	void * rc_join = NULL;
	void * rc_join_expected;
	int rc;

	/* Try to make a thread. */
	if ((rc = pthread_create_blocking_np(&thr, NULL, workfunc, NULL))) {
		warnp("pthread_create_blocking_np: %s", strerror(rc));
		goto err0;
	}

	/* If we succeeded in making a thread, wait for it to finish. */
	if ((rc = pthread_join(thr, &rc_join))) {
		warn0("pthread_join: %s", strerror(rc));
		goto err0;
	}

	/* Check the value returned from the workfunc. */
	rc_join_expected = MY_RUN_RETURN;
	if (rc_join != rc_join_expected) {
		warn0("pthread_join expected to get %p; instead, got %p",
		    rc_join, rc_join_expected);
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x101(%rip), %rdx       # 0x1470
movq %rcx, %rsi
callq 0x2700
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x13d1
jmp 0x1381
callq 0x1060
cmpl $0x0, (%rax)
je 0x13b1
movl -0x24(%rbp), %edi
callq 0x11b0
movq %rax, %rsi
leaq 0x1c67(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x2270
callq 0x1060
movl $0x0, (%rax)
jmp 0x13ca
movl -0x24(%rbp), %edi
callq 0x11b0
movq %rax, %rsi
leaq 0x1c41(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x24c0
jmp 0x13cc
jmp 0x1451
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1190
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x140e
jmp 0x13e8
movl -0x24(%rbp), %edi
callq 0x11b0
movq %rax, %rsi
leaq 0x1c29(%rip), %rdi      # 0x3023
movb $0x0, %al
callq 0x24c0
callq 0x1060
movl $0x0, (%rax)
jmp 0x1451
movq 0x3cfb(%rip), %rax      # 0x5110
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x1448
jmp 0x1425
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x1c00(%rip), %rdi      # 0x3034
movb $0x0, %al
callq 0x24c0
callq 0x1060
movl $0x0, (%rax)
jmp 0x1451
movl $0x0, -0x4(%rbp)
jmp 0x1458
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/pthread_create_blocking_np/timing.c
// Function: check_timing
int
check_timing(void)
{
	size_t i, j;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		for (j = 0; j < sizeof(tests) / sizeof(tests[0]); j++) {
			if (runner(tests[i].options, tests[j].options)) {
				warn0("failed test %zu", i);
				goto err0;
			}
		}
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
cmpq $0x4, -0x10(%rbp)
jae 0x151d
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x150d
movq -0x10(%rbp), %rcx
leaq 0x3c5f(%rip), %rax      # 0x5120
movl (%rax,%rcx,4), %edi
movq -0x18(%rbp), %rcx
leaq 0x3c51(%rip), %rax      # 0x5120
movl (%rax,%rcx,4), %esi
callq 0x1540
cmpl $0x0, %eax
je 0x14fd
jmp 0x14de
movq -0x10(%rbp), %rsi
leaq 0x1b87(%rip), %rdi      # 0x3070
movb $0x0, %al
callq 0x24c0
callq 0x1060
movl $0x0, (%rax)
jmp 0x1526
jmp 0x14ff
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x14af
jmp 0x150f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x14a0
movl $0x0, -0x4(%rbp)
jmp 0x152d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)