LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
movl $0x98, %esi
callq 0x65a0
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 0x2d19(%rip), %rsi      # 0xa0db
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6994
leaq 0x2d18(%rip), %rsi      # 0xa0ec
movq %r15, %rdi
movq %rbx, %rdx
callq 0x6994
leaq 0x2d18(%rip), %rsi      # 0xa0fe
movq %r12, %rdi
movq %rbx, %rdx
callq 0x6994
movq 0x138(%rbx), %rcx
addq $0x138, %rbx            # imm = 0x138
testq %rcx, %rcx
je 0x741c
movq %rcx, %rax
movq 0x90(%rcx), %rcx
testq %rcx, %rcx
jne 0x73ff
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_O2/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
movq %rdi, %rbx
movl 0x128(%rdi), %r15d
movl 0x12c(%rdi), %ebp
xorl %r12d, %r12d
subl $0x1, %ebp
jb 0x7487
movl %r15d, %r14d
subl $0x1, %r14d
jb 0x7446
cmpl $0xa, %r12d
setl %r13b
movl %ebp, %edi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x7338
testl %eax, %eax
setne %al
andb %r13b, %al
cmpb $0x1, %al
jne 0x744e
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x735c
incl %r12d
jmp 0x744e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x65a0
movq %rax, %r14
movl %r15d, 0x28(%rax)
movl %ebp, 0x2c(%rax)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x1c(%r14)
leaq 0x2c3f(%rip), %rsi      # 0xa110
movq %r14, %rdi
movq %rbx, %rdx
callq 0x6994
movq 0x140(%rbx), %rcx
addq $0x140, %rbx            # imm = 0x140
testq %rcx, %rcx
je 0x7502
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x74ea
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_O2/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 %r15
pushq %r14
pushq %rbx
movslq 0x14c(%rdi), %rcx
movslq 0x12c(%rdi), %rdx
subq %rcx, %rdx
xorl %eax, %eax
cmpq %rax, %rcx
movq %rax, %rsi
cmovgq %rcx, %rsi
cmpq %rdx, %rax
jg 0x75b1
movslq 0x148(%rdi), %r9
movslq 0x128(%rdi), %r10
subq %r9, %r10
xorl %r8d, %r8d
cmpq %r8, %r9
movq %r8, %r11
cmovgq %r9, %r11
cmpq %r10, %r8
jg 0x758f
movq %rax, %rbx
cmpq %rsi, %rbx
je 0x7587
movq %r8, %r14
cmpq %r14, %r11
je 0x7582
movq 0xc8(%rdi), %r15
movq (%r15,%rbx,8), %r15
cmpb $0x50, (%r15,%r14)
leaq 0x1(%r14), %r14
jne 0x7565
jmp 0x7597
incq %rbx
jmp 0x755d
incq %r8
incq %r9
jmp 0x754b
incq %rax
incq %rcx
jmp 0x7528
movl %r8d, 0x120(%rdi)
movl %eax, 0x124(%rdi)
subl %r8d, 0xb4(%rdi)
subl %eax, 0xb8(%rdi)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 $0x61, %edi
je 0x75e8
cmpl $0x64, %edi
je 0x75d8
cmpl $0x73, %edi
je 0x75e0
cmpl $0x77, %edi
jne 0x75f0
movq %rsi, %rdi
jmp 0x7940
movq %rsi, %rdi
jmp 0x7a49
movq %rsi, %rdi
jmp 0x7993
movq %rsi, %rdi
jmp 0x79f3
retq
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x28, %rcx, %rcx
leaq (%rdi,%rcx), %rbx
addq $0x10, %rbx
leaq 0xf8(%rdi), %r14
movl 0xc0(%rdi), %edx
movl 0xc4(%rdi), %ecx
movl %eax, %edi
callq 0x6961
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x68d9
// File: /workspace/github_c_makefile_star2_O2/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 0x45(%rip), %rsi        # 0x76c7
movq %rbx, %rdx
callq 0x84b0
movq 0x8(%rbx), %rdi
leaq 0x108(%rip), %rcx       # 0x779d
pushq $0x11
popq %rsi
movl $0x20000, %edx          # imm = 0x20000
movq %rbx, %r8
callq 0x9ee0
movq 0x8(%rbx), %rdi
leaq 0x104(%rip), %rcx       # 0x77b4
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %r8
callq 0x9ee0
movq (%rbx), %rdi
popq %rbx
jmp 0x8340
// File: /workspace/github_c_makefile_star2_O2/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 0x76ea
cmpb $0x0, 0x1234a(%rip)     # 0x19a28
jne 0x7704
movq %rbx, %rdi
callq 0x7d40
jmp 0x7704
cmpl $0x0, 0x158(%rbx)
je 0x7716
cmpb $0x0, 0x1232e(%rip)     # 0x19a28
jne 0x7704
movq %rbx, %rdi
callq 0x7dcd
movb $0x1, 0x1231d(%rip)     # 0x19a28
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x6fb0
movq %rbx, %rdi
callq 0x75f1
movq %rbx, %rdi
callq 0x7ade
movq %rbx, %rdi
callq 0x77f0
movq %rbx, %rdi
callq 0x7c58
movq %rbx, %rdi
callq 0x6cc8
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq 0xf8(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8b80
movl 0xbc(%rbx), %edi
callq 0x6a14
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movl 0x148(%rbx), %edx
shll $0x6, %edx
addl $-0x14, %edx
pushq $0x14
popq %rcx
movl $0xf35c00, %r8d         # imm = 0xF35C00
movq %rax, %r9
callq 0x8690
movq %r14, %rdi
callq 0x6190
jmp 0x770b
// File: /workspace/github_c_makefile_star2_O2/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 0x77de
movq %rsi, %rbx
cmpl $0x0, 0x158(%rsi)
jne 0x77de
movl %edi, %ebp
movq %rbx, %rsi
callq 0x75bc
cmpl $0xff1b, %ebp           # imm = 0xFF1B
je 0x77e8
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x779d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x130(%rdi), %r12
leaq 0xf8(%rdi), %r14
xorl %r13d, %r13d
pushq $0x40
popq %rbp
movq %r12, %rax
movq (%rax), %r15
testq %r15, %r15
je 0x7930
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7aac
testl %eax, %eax
je 0x7924
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 0x78a2
movl 0xb8(%rbx), %esi
addl %edx, %esi
cmpl %eax, %esi
jne 0x78a2
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 0x7927
movq (%r12), %r13
testq %r13, %r13
jne 0x7927
jmp 0x7930
subl %edx, %eax
shll $0x6, %eax
subl %ecx, %edi
shll $0x6, %edi
cvtsi2ss %eax, %xmm0
addss 0x30(%r15), %xmm0
cvttss2si %xmm0, %esi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x6961
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x68d9
cmpl $0x0, 0x34(%r15)
movss 0x30(%r15), %xmm0
je 0x78f4
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7907
cvtss2sd %xmm0, %xmm0
addsd 0x2836(%rip), %xmm0     # 0xa128
jmp 0x791a
ucomiss 0x283d(%rip), %xmm0     # 0xa138
jbe 0x790e
movl $0x1, 0x34(%r15)
jmp 0x7924
andl $0x0, 0x34(%r15)
jmp 0x7924
cvtss2sd %xmm0, %xmm0
addsd 0x2816(%rip), %xmm0     # 0xa130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%r15)
movq %r15, %r13
leaq 0x38(%r13), %rax
jmp 0x7815
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x6c94
testl %eax, %eax
je 0x798a
movl 0xb8(%rbx), %ecx
movl 0x124(%rbx), %esi
testl %esi, %esi
jle 0x797c
movl 0x14c(%rbx), %eax
pushq $0x2
popq %rdi
cltd
idivl %edi
cmpl %eax, %ecx
jge 0x797c
decl %esi
movl %esi, 0x124(%rbx)
jmp 0x7984
decl %ecx
movl %ecx, 0xb8(%rbx)
incl 0xbc(%rbx)
andl $0x0, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x6c94
testl %eax, %eax
je 0x79e7
movl 0xb8(%rbx), %ecx
movl 0x124(%rbx), %esi
movl 0x12c(%rbx), %edi
movl 0x14c(%rbx), %eax
subl %eax, %edi
pushq $0x2
popq %r8
cltd
idivl %r8d
cmpl %edi, %esi
jge 0x79d9
cmpl %eax, %ecx
jle 0x79d9
incl %esi
movl %esi, 0x124(%rbx)
jmp 0x79e1
incl %ecx
movl %ecx, 0xb8(%rbx)
incl 0xbc(%rbx)
movl $0x2, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x6c94
testl %eax, %eax
je 0x7a3d
movl 0xb4(%rbx), %ecx
movl 0x120(%rbx), %esi
testl %esi, %esi
jle 0x7a2f
movl 0x148(%rbx), %eax
pushq $0x2
popq %rdi
cltd
idivl %edi
cmpl %eax, %ecx
jge 0x7a2f
decl %esi
movl %esi, 0x120(%rbx)
jmp 0x7a37
decl %ecx
movl %ecx, 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x3, 0xb0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x6c94
testl %eax, %eax
je 0x7a9d
movl 0xb4(%rbx), %ecx
movl 0x120(%rbx), %esi
movl 0x128(%rbx), %edi
movl 0x148(%rbx), %eax
subl %eax, %edi
pushq $0x2
popq %r8
cltd
idivl %r8d
cmpl %edi, %esi
jge 0x7a8f
cmpl %eax, %ecx
jle 0x7a8f
incl %esi
movl %esi, 0x120(%rbx)
jmp 0x7a97
incl %ecx
movl %ecx, 0xb4(%rbx)
incl 0xbc(%rbx)
movl $0x1, 0xb0(%rbx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x120(%rdx), %eax
cmpl %edi, %eax
jg 0x7ac5
addl 0x148(%rdx), %eax
cmpl %edi, %eax
jle 0x7ac5
pushq $0x1
popq %rax
jmp 0x7ac7
xorl %eax, %eax
movl 0x124(%rdx), %ecx
cmpl %esi, %ecx
jg 0x7adb
addl 0x14c(%rdx), %ecx
cmpl %esi, %ecx
jg 0x7add
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x138(%rdi), %r13
leaq 0xf8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0x7c46
movl 0x80(%r13), %r15d
movl 0x84(%r13), %ebp
movl %r15d, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x7aac
testl %eax, %eax
je 0x7bb2
movslq 0x7c(%r13), %r12
movl 0x120(%rbx), %r14d
movq %rbx, %rdx
movl 0x124(%rbx), %ebx
movss 0x78(%r13), %xmm0
movss %xmm0, 0x4(%rsp)
leal 0x1(%r15), %edi
movl %ebp, %esi
callq 0x7aac
pushq $0x40
popq %rdx
testl %eax, %eax
je 0x7b6e
imulq $0x28, %r12, %rax
movl 0x1c(%r13,%rax), %edx
subl %ebx, %ebp
shll $0x6, %ebp
cvtsi2ss %ebp, %xmm0
subss 0x4(%rsp), %xmm0
cvttss2si %xmm0, %esi
subl %r14d, %r15d
shll $0x6, %r15d
imulq $0x28, %r12, %rax
leaq (%rax,%r13), %r12
movl 0x20(%r13,%rax), %ecx
movl %r15d, %edi
callq 0x6961
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x68d9
movq 0x10(%rsp), %rbx
cmpl $0x0, 0x88(%r13)
movss 0x78(%r13), %xmm0
je 0x7bd8
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x7bee
cvtss2sd %xmm0, %xmm0
addsd 0x2552(%rip), %xmm0     # 0xa128
jmp 0x7c30
ucomiss 0x2559(%rip), %xmm0     # 0xa138
jbe 0x7c24
movl $0x1, 0x88(%r13)
jmp 0x7c3a
movl 0x7c(%r13), %eax
movl 0x80(%r13), %esi
leal 0x1(%rax), %ecx
cmpl $0x2, %eax
movl $0x0, %eax
cmovgel %eax, %ecx
movl %ecx, 0x7c(%r13)
movl 0x84(%r13), %edx
movq %rbx, %rdi
callq 0x7498
andl $0x0, 0x88(%r13)
jmp 0x7c3a
cvtss2sd %xmm0, %xmm0
addsd 0x2500(%rip), %xmm0     # 0xa130
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x78(%r13)
addq $0x90, %r13
jmp 0x7b07
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x140(%rdi), %r12
leaq 0xf8(%rdi), %r14
xorl %r13d, %r13d
pushq $0x40
popq %rbp
movq %r12, %rax
movq (%rax), %r15
testq %r15, %r15
je 0x7d2f
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7aac
testl %eax, %eax
je 0x7cde
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
subl 0x120(%rbx), %edi
shll $0x6, %edi
subl 0x124(%rbx), %esi
shll $0x6, %esi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x6961
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x68d9
movl 0x28(%r15), %edi
movl 0x2c(%r15), %esi
movq %rbx, %rdx
callq 0x7649
movl 0x30(%r15), %eax
cmpl $0x8, %eax
jne 0x7d19
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 0x7d26
movq (%r12), %r13
testq %r13, %r13
jne 0x7d26
jmp 0x7d2f
incl 0x28(%r15)
incl %eax
movl %eax, 0x30(%r15)
movq %r15, %r13
leaq 0x38(%r13), %rax
jmp 0x7c7d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x23db(%rip), %rsi      # 0xa140
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6994
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 0x8d80
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x8b80
movq (%rbx), %rdi
callq 0x6190
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x235e(%rip), %rsi      # 0xa150
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6994
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 0x8d80
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rbx), %rdx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x8b80
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_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x4b8(%rip), %rdi       # 0x16de
callq 0x166e
movq (%rbx), %rdi
callq 0x167b
callq 0x1090
movl %eax, %edi
callq 0x16cd
cmpl $0x2, %ebp
jl 0x1258
movq 0x8(%rbx), %rax
cmpb $0x0, (%rax)
je 0x1258
xorl %edi, %edi
callq 0x1060
testl %eax, %eax
je 0x1278
callq 0x1649
leaq 0xead(%rip), %rsi       # 0x2111
leaq 0xe9c(%rip), %rcx       # 0x2107
pushq $0x7c
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x140c
movq 0x8(%rbx), %rdi
callq 0x10a0
movq %rax, %r14
leaq 0x1(%rax), %r15
cmpq $0x42, %r15
jb 0x12b2
callq 0x1649
movq 0x8(%rbx), %rcx
leaq 0xe6f(%rip), %rsi       # 0x210d
leaq 0xe74(%rip), %r8        # 0x2119
pushq $0x7c
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x140c
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
cmpq $-0x1, %rax
jne 0x12e3
callq 0x1649
leaq 0xe42(%rip), %rsi       # 0x2111
leaq 0xe52(%rip), %rcx       # 0x2128
pushq $0x7c
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x140c
leaq (%rsp,%r15), %r13
movq 0x8(%rbx), %r12
movabsq $0x200000c01, %rbp      # imm = 0x200000C01
movzbl (%r12), %r12d
callq 0x13f4
cmpl $-0x1, %eax
je 0x13b8
cmpl $0x9, %eax
je 0x1312
cmpl $0x20, %eax
jne 0x1319
callq 0x13f4
jmp 0x1308
cmpl $0x3a, %eax
jne 0x1358
callq 0x13f4
cmpl $0x9, %eax
je 0x131e
cmpl $0x20, %eax
je 0x131e
cmpl %r12d, %eax
jne 0x12fa
movl %r12d, %eax
movq %rsp, %r15
leal 0x1(%rax), %ecx
cmpl $0x21, %ecx
ja 0x1346
btq %rcx, %rbp
jb 0x1369
movb %al, (%r15)
callq 0x13f4
incq %r15
cmpq %r13, %r15
jb 0x1338
jmp 0x136d
cmpl $-0x1, %eax
je 0x12fa
cmpl $0xa, %eax
je 0x12fa
callq 0x13f4
jmp 0x1358
movb $0x0, (%r15)
cmpl $-0x1, %eax
je 0x13b8
cmpl $0xa, %eax
je 0x137e
callq 0x13f4
jmp 0x136d
movq %rsp, %rax
subq %rax, %r15
cmpq %r14, %r15
jne 0x12fa
movq 0x8(%rbx), %r12
movq %rsp, %rdi
movq %r12, %rsi
callq 0x10e0
testl %eax, %eax
jne 0x12f5
movq 0x2cfd(%rip), %rsi      # 0x40a8
xorl %ebx, %ebx
xorl %edi, %edi
xorl %edx, %edx
callq 0x10d0
jmp 0x13e3
movb $0x0, (%rsp)
callq 0x1649
movq 0x8(%rbx), %rcx
leaq 0xd41(%rip), %rsi       # 0x210d
leaq 0xd61(%rip), %r8        # 0x2134
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x15bc
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1331
callq 0x1c44
andq $0x0, (%rsp)
leaq 0xb8(%rip), %rdx        # 0x13f5
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1fd4
testl %eax, %eax
jne 0x1380
movq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x11c0
testl %eax, %eax
jne 0x13ac
movq (%rsp), %rsi
leaq 0x3dc1(%rip), %rax      # 0x512c
cmpq %rax, %rsi
jne 0x13d0
callq 0x1400
testl %eax, %eax
jne 0x13ed
xorl %edi, %edi
callq 0x11a0
movl %eax, %ebp
callq 0x1060
movq %rax, %rbx
movl (%rax), %r14d
movl %ebp, %edi
callq 0x11e0
leaq 0x1c69(%rip), %rdi      # 0x3004
movq %rax, %rsi
xorl %eax, %eax
testl %r14d, %r14d
jne 0x13c6
callq 0x1e50
jmp 0x13ed
movl %eax, %edi
callq 0x11e0
leaq 0x1c69(%rip), %rdi      # 0x3023
movq %rax, %rsi
xorl %eax, %eax
callq 0x1e50
jmp 0x13e5
callq 0x1cc1
andl $0x0, (%rbx)
jmp 0x13ed
leaq 0x1c5d(%rip), %rdi      # 0x3034
leaq 0x3d4e(%rip), %rdx      # 0x512c
xorl %eax, %eax
callq 0x1e50
callq 0x1060
andl $0x0, (%rax)
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x1a48
testl %eax, %eax
je 0x19d4
callq 0x1060
cmpl $0x0, (%rax)
je 0x19c6
movq %rax, %r14
leaq 0x16d7(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1cc1
andl $0x0, (%r14)
jmp 0x19d4
leaq 0x16c3(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1e50
testb $0x1, (%rbx)
je 0x19de
callq 0x1a26
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x1a48
testl %eax, %eax
je 0x1a1c
callq 0x1060
cmpl $0x0, (%rax)
je 0x1a0e
movq %rax, %rbx
leaq 0x168e(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1cc1
andl $0x0, (%rbx)
jmp 0x1a1c
leaq 0x167b(%rip), %rdi      # 0x3090
xorl %eax, %eax
callq 0x1e50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/../cram/../htslib/sam.h
// Function: sam_itr_next
static inline int sam_itr_next(htsFile *htsfp, hts_itr_t *itr, bam1_t *r) {
    if (!htsfp->is_bgzf && !htsfp->is_cram) {
        hts_log_error("%s not BGZF compressed", htsfp->fn ? htsfp->fn : "File");
        return -2;
    }
    if (!itr) {
        hts_log_error("Null iterator");
        return -2;
    }

    if (itr->multi)
        return hts_itr_multi_next(htsfp, itr, r);
    else
        return hts_itr_next(htsfp->is_bgzf ? htsfp->fp.bgzf : NULL, itr, r, htsfp);
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movl (%rdi), %eax
testb $0x18, %al
je 0x5ff9
testq %rsi, %rsi
je 0x6025
testb $0x10, (%rsi)
jne 0x6042
testb $0x10, %al
jne 0x604b
xorl %edi, %edi
jmp 0x604f
movq 0x28(%rcx), %rax
testq %rax, %rax
leaq 0x7c881(%rip), %rcx     # 0x82888
cmovneq %rax, %rcx
leaq 0x7c852(%rip), %rsi     # 0x82864
leaq 0x7c858(%rip), %rdx     # 0x82871
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x8d46
jmp 0x603d
leaq 0x7c838(%rip), %rsi     # 0x82864
leaq 0x7c85a(%rip), %rdx     # 0x8288d
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x8d46
pushq $-0x2
popq %rax
popq %rcx
retq
movq %rcx, %rdi
popq %rax
jmp 0xe64e
movq 0x38(%rcx), %rdi
popq %rax
jmp 0xe429
// File: /workspace/github_c_makefile_star2_O2/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 0xbdc(%rip), %rdi       # 0x2128
callq 0x1050
movabsq $0x6060002050100, %rax  # imm = 0x6060002050100
movq %rax, 0x6(%rsp)
movabsq $0x100020503000505, %rax # imm = 0x100020503000505
movq %rax, (%rsp)
callq 0x12c4
testq %rax, %rax
je 0x166a
movq %rax, %rbx
movq %rsp, %rsi
pushq $0xf
popq %rdx
movq %rax, %rdi
callq 0x14d9
testl %eax, %eax
je 0x1675
movq %rbx, %rdi
callq 0x14fd
cmpw $0x14, %ax
jne 0x162b
leaq 0xba0(%rip), %rdi       # 0x214e
callq 0x1050
movq %rbx, %rdi
callq 0x1318
movaps 0xafe(%rip), %xmm0      # 0x20c0
movaps %xmm0, (%rsp)
movl $0x60606, 0xf(%rsp)     # imm = 0x60606
callq 0x12c4
testq %rax, %rax
je 0x166a
movq %rax, %rbx
movq %rsp, %rsi
pushq $0x13
popq %rdx
movq %rax, %rdi
callq 0x14d9
testl %eax, %eax
je 0x1675
movq %rbx, %rdi
callq 0x14fd
cmpw $0x8, %ax
jne 0x164c
leaq 0xb52(%rip), %rdi       # 0x215c
callq 0x1050
movq %rbx, %rdi
callq 0x1318
leaq 0xb1d(%rip), %rdi       # 0x213b
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq 0x29c6(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xad9(%rip), %rdi       # 0x2115
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
jmp 0x15b3
movq 0x29a5(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xab8(%rip), %rdi       # 0x2115
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
jmp 0x160f
leaq 0xa62(%rip), %rsi       # 0x20d3
pushq $0x47
jmp 0x167e
leaq 0xa79(%rip), %rsi       # 0x20f5
pushq $0x46
popq %rdi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/aligrudi[P]gpss/datcnf.c
// Function: main
int main(int argc, char *argv[])
{
	int id = atoi(argv[1]);
	if (id == 0)
		test2();
	if (id == 1)
		test3();
	if (id == 2)
		test4();
	if (id == 3)
		test5();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rsi), %rdi
callq 0x1060
cmpl $0x3, %eax
ja 0x1336
leaq 0xed8(%rip), %r15       # 0x206b
movl %eax, %eax
leaq 0xe68(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe73(%rip), %rdi       # 0x201f
callq 0x1040
leaq 0xe6b(%rip), %rax       # 0x2023
movq %rax, 0x10(%rsp)
leaq 0xe8b(%rip), %rax       # 0x204f
movq %rax, 0x8(%rsp)
leaq 0xe77(%rip), %r12       # 0x2047
leaq 0xe68(%rip), %r13       # 0x203f
leaq 0xe59(%rip), %r14       # 0x2037
leaq 0xe4a(%rip), %r15       # 0x202f
leaq 0xe7f(%rip), %rdi       # 0x206b
jmp 0x12d9
leaq 0xea3(%rip), %rbp       # 0x209b
leaq 0xe94(%rip), %rbx       # 0x2093
leaq 0xe85(%rip), %r14       # 0x208b
leaq 0xe76(%rip), %rax       # 0x2083
movq %rax, 0x8(%rsp)
leaq 0xe62(%rip), %r12       # 0x207b
leaq 0xe53(%rip), %r13       # 0x2073
leaq 0xe40(%rip), %rdi       # 0x2067
jmp 0x12f7
leaq 0xde1(%rip), %rdi       # 0x2014
movl $0x3e8, %r13d           # imm = 0x3E8
movl $0x3e8, %esi            # imm = 0x3E8
movl $0x1f4, %edx            # imm = 0x1F4
xorl %eax, %eax
callq 0x1050
pushq $0x3
popq %r14
leaq 0xdc6(%rip), %r15       # 0x201b
xorl %ebx, %ebx
cmpl $0x3e7, %ebx            # imm = 0x3E7
ja 0x1336
leaq 0xdb2(%rip), %rdi       # 0x201c
movl %r14d, %esi
xorl %eax, %eax
callq 0x1050
movl %r14d, %ebp
movl %ebx, %r12d
movl %r12d, %eax
xorl %edx, %edx
divl %r13d
subl $0x1, %ebp
jb 0x1298
movq %r15, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x1050
incl %r12d
jmp 0x127a
pushq $0xa
popq %rdi
callq 0x1030
addl $0x2, %ebx
jmp 0x1257
leaq 0xda3(%rip), %rax       # 0x204f
movq %rax, 0x10(%rsp)
leaq 0xd8f(%rip), %rax       # 0x2047
movq %rax, 0x8(%rsp)
leaq 0xd7b(%rip), %r12       # 0x203f
leaq 0xd6c(%rip), %r13       # 0x2037
leaq 0xd5d(%rip), %r14       # 0x202f
leaq 0xd52(%rip), %rdi       # 0x202b
callq 0x1040
leaq 0xd7a(%rip), %rbp       # 0x205f
leaq 0xd6b(%rip), %rbx       # 0x2057
movq %r15, %rdi
movq %r14, %r15
movq 0x10(%rsp), %r14
callq 0x1040
movq %r15, %rdi
callq 0x1040
movq %r13, %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1040
movq 0x8(%rsp), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1040
movq %rbp, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed_opml_import.c
// Function: main
int
main(void)
{
	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	parser.xmlattr = xml_handler_attr;
	parser.xmlattrentity = xml_handler_attrentity;
	parser.xmltagend = xml_handler_end_element;

	fputs(
	    "#sfeedpath=\"$HOME/.sfeed/feeds\"\n"
	    "\n"
	    "# list of feeds to fetch:\n"
	    "feeds() {\n"
	    "	# feed <name> <feedurl> [basesiteurl] [encoding]\n", stdout);
	/* NOTE: getnext is defined in xml.h for inline optimization */
	xml_parse(&parser);
	fputs("}\n", stdout);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x61(%rip), %rax        # 0x1238
movq %rax, 0x3eb2(%rip)      # 0x5090
leaq 0x3eab(%rip), %rbx      # 0x5090
leaq 0xdc(%rip), %rax        # 0x12c8
movq %rax, 0x3eb5(%rip)      # 0x50a8
leaq 0x11b(%rip), %rax       # 0x1315
movq %rax, 0x3eff(%rip)      # 0x5100
movq 0x3dd8(%rip), %r14      # 0x4fe0
movq (%r14), %rsi
leaq 0x1df2(%rip), %rdi      # 0x3004
callq 0x1080
movq %rbx, %rdi
callq 0x15b7
movq (%r14), %rsi
leaq 0x1e53(%rip), %rdi      # 0x307c
callq 0x1080
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed_opml_import.c
// Function: xml_handler_attrentity
static void
xml_handler_attrentity(XMLParser *p, const char *tag, size_t taglen,
	const char *name, size_t namelen, const char *value, size_t valuelen)
{
	char buf[16];
	ssize_t len;

	if ((len = xml_entitytostr(value, buf, sizeof(buf))) < 0)
		return;
	if (len > 0)
		xml_handler_attr(p, tag, taglen, name, namelen, buf, len);
	else
		xml_handler_attr(p, tag, taglen, name, namelen, value, valuelen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %r14
movq %rcx, %rbx
movq %rsi, %r15
leaq 0x10(%rsp), %rsi
pushq $0x10
popq %rdx
movq %r9, %rdi
callq 0x1438
testl %eax, %eax
js 0x130b
je 0x12fd
leaq 0x10(%rsp), %r9
movq %r15, %rsi
movq %rbx, %rcx
jmp 0x1306
movq %r15, %rsi
movq %rbx, %rcx
movq %r14, %r9
callq 0x1238
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed_opml_import.c
// Function: xml_handler_end_element
static void
xml_handler_end_element(XMLParser *p, const char *tag, size_t taglen,
	int isshort)
{
	if (strcasecmp(tag, "outline"))
		return;

	if (url[0]) {
		fputs("\tfeed '", stdout);
		if (title[0])
			printsafe(title);
		else if (text[0])
			printsafe(text);
		else
			fputs("unnamed", stdout);
		fputs("' '", stdout);
		printsafe(url);
		fputs("'\n", stdout);
	}
	url[0] = text[0] = title[0] = '\0';
}

// Assembly:
pushq %rbx
movq %rsi, %rdi
leaq 0x1d5f(%rip), %rsi      # 0x307f
callq 0x1040
testl %eax, %eax
jne 0x13b1
cmpb $0x0, 0x67fc(%rip)      # 0x7b30
je 0x139d
movq 0x3ca3(%rip), %rbx      # 0x4fe0
movq (%rbx), %rsi
leaq 0x1d52(%rip), %rdi      # 0x3099
callq 0x1080
cmpb $0x0, 0x65dd(%rip)      # 0x7930
je 0x135e
leaq 0x65d4(%rip), %rdi      # 0x7930
jmp 0x136e
cmpb $0x0, 0x66cb(%rip)      # 0x7a30
je 0x13b3
leaq 0x66c2(%rip), %rdi      # 0x7a30
callq 0x13c4
movq (%rbx), %rsi
leaq 0x1d2c(%rip), %rdi      # 0x30a9
callq 0x1080
leaq 0x67a7(%rip), %rdi      # 0x7b30
callq 0x13c4
movq (%rbx), %rsi
leaq 0x1d15(%rip), %rdi      # 0x30ad
callq 0x1080
xorl %eax, %eax
movb %al, 0x658b(%rip)       # 0x7930
movb %al, 0x6685(%rip)       # 0x7a30
movb %al, 0x677f(%rip)       # 0x7b30
popq %rbx
retq
movq (%rbx), %rsi
leaq 0x1ce4(%rip), %rdi      # 0x30a1
callq 0x1080
jmp 0x1373
// File: /workspace/github_c_makefile_star2_O2/dxwc[P]sfeed/sfeed_opml_import.c
// Function: printsafe
static void
printsafe(const char *s)
{
	for (; *s; s++) {
		if (iscntrl((unsigned char)*s))
			continue;
		else if (*s == '\\')
			fputs("\\\\", stdout);
		else if (*s == '\'')
			fputs("'\\''", stdout);
		else
			putchar(*s);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x3c09(%rip), %r12      # 0x4fe0
leaq 0x1cd5(%rip), %r14      # 0x30b3
leaq 0x1ccb(%rip), %r15      # 0x30b0
movzbl (%rbx), %r13d
testq %r13, %r13
je 0x142e
callq 0x10c0
movq (%rax), %rax
testb $0x2, (%rax,%r13,2)
jne 0x1429
cmpq $0x27, %r13
je 0x1412
cmpl $0x5c, %r13d
jne 0x1420
movq (%r12), %rsi
movq %r15, %rdi
jmp 0x1419
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1080
jmp 0x1429
movsbl %r13b, %edi
callq 0x1030
incq %rbx
jmp 0x13e5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.11/socket-client.c
// Function: main
int main (int argc, char* const argv[])
{
  const char* const socket_name = argv[1];
  const char* const message = argv[2];
  int socket_fd;
  struct sockaddr_un name;

  /* Create the socket. */
  socket_fd = socket (PF_LOCAL, SOCK_STREAM, 0);
  /* Store the server’s name in the socket address. */
  name.sun_family = AF_LOCAL;
  strcpy (name.sun_path, socket_name);
  /* Connect the socket. */
  connect (socket_fd, (const struct sockaddr *)&name, SUN_LEN (&name));
  /* Write the text on the command line to the socket. */
  write_text (socket_fd, message);
  close (socket_fd);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rbx
pushq $0x1
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x1080
movl %eax, %r14d
leaq -0x8c(%rbp), %r12
movw $0x1, -0x2(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1030
movq %r12, %rdi
callq 0x1050
leal 0x2(%rax), %edx
leaq -0x8e(%rbp), %rsi
movl %r14d, %edi
callq 0x1070
movl %r14d, %edi
movq %rbx, %rsi
callq 0x118c
movl %r14d, %edi
callq 0x1060
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x737e
cmpl $-0x1, %eax
je 0x73fc
addq $0x20, %rsp
jmp 0x73fa
movl 0x13778(%rip), %ecx     # 0x1aafc
leaq 0x849f(%rip), %rdx      # 0xf82a
movq %rsp, %rbx
pushq $0x20
popq %rsi
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 0x82b8(%rip), %r10      # 0xf670
leaq 0x82ae(%rip), %r11      # 0xf66d
leaq 0x8280(%rip), %rdi      # 0xf646
leaq 0x8277(%rip), %rsi      # 0xf644
leaq 0x8275(%rip), %rdx      # 0xf649
leaq 0x8271(%rip), %rcx      # 0xf64c
leaq 0x8276(%rip), %r8       # 0xf658
leaq 0x8272(%rip), %r9       # 0xf65b
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 0x81c9(%rip), %rdi      # 0xf5d8
movq %rax, %rsi
xorl %eax, %eax
callq 0x5b16
// File: /workspace/github_c_makefile_star2_O2/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 0xd28c
pushq %rax
shlq $0x7, %rax
leaq 0x9305(%rip), %rcx      # 0x16570
addq %rax, %rcx
movq %rcx, 0xfdeb(%rip)      # 0x1d060
callq 0x9dc7
movl 0xfdf8(%rip), %edi      # 0x1d078
movl 0xfdf6(%rip), %esi      # 0x1d07c
popq %rax
jmp 0xc82b
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1332
cmpl $0x0, 0xc(%r15)
jne 0x1340
leaq 0x4ce7(%rip), %rdi      # 0x6020
xorl %eax, %eax
callq 0x5b50
testl %ebx, %ebx
jne 0x1352
leaq 0x4d02(%rip), %rdi      # 0x604d
xorl %eax, %eax
callq 0x5b50
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x5c38
movq %rax, %r14
movq %r15, (%rax)
movl 0x40(%r15), %eax
testl %eax, %eax
jne 0x136f
movl 0xc(%r15), %eax
movl %eax, %edi
pushq $0x4
popq %rsi
callq 0x5c38
movq %rax, 0x28(%r14)
movl %ebx, 0x8(%r14)
movl %ebx, %ebx
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x5c10
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x5c10
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x5c10
movq %rax, 0x20(%r14)
movl $0x400, %edi            # imm = 0x400
callq 0x4e20
movq %rax, 0x40(%r14)
pushq $0x4
popq %rsi
movl $0x400, %edi            # imm = 0x400
callq 0x53dc
movq %rax, 0x48(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x1040
movq 0x30(%rbx), %rdi
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 0x4e82
movq 0x48(%rbx), %rdi
callq 0x551c
movq %rbx, %rdi
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/richarddurbin[P]hash10x/moshmap.c
// Function: referencePack
void referencePack (Reference *ref)
{
  resize (ref->depth, ref->ms->size, ref->ms->max+1, U32) ;
  resize (ref->index, ref->size, ref->max, U32) ;
  resize (ref->offset, ref->size, ref->max, U32) ;
  resize (ref->id, ref->size, ref->max, U32) ;
  ref->size = ref->max ;
  
  ref->rev = new (ref->size, U32) ;			/* now build rev and loc */
  ref->loc = new (ref->ms->max + 1, U32) ; ref->loc[0] = 0 ;
  int i ;
  for (i = 1 ; i <= ref->ms->max ; ++i)
    { ref->loc[i] = ref->loc[i-1] + ref->depth[i-1] ; }
  memset (ref->depth, 0, ref->ms->size*sizeof(U32)) ; /* build this up again in loop below */
  U32 *ri = ref->index ;
  for (i = 0 ; i < ref->max ; ++i, ++ri)
    ref->rev[ref->loc[*ri] + ref->depth[*ri]++] = i ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x40(%rax), %edi
incl %edi
shlq $0x2, %rdi
callq 0x5c10
movq %rax, %r14
movq (%rbx), %rax
movq 0x28(%rbx), %rsi
movl 0xc(%rax), %ecx
movl 0x40(%rax), %edx
incl %edx
cmpl %edx, %ecx
cmovbl %ecx, %edx
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x1140
movq 0x28(%rbx), %rdi
callq 0x1040
movq %r14, 0x28(%rbx)
movl 0xc(%rbx), %edi
shlq $0x2, %rdi
callq 0x5c10
movq %rax, %r14
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x10(%rbx), %rsi
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x1140
movq 0x10(%rbx), %rdi
callq 0x1040
movq %r14, 0x10(%rbx)
movl 0xc(%rbx), %edi
shlq $0x2, %rdi
callq 0x5c10
movq %rax, %r14
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x18(%rbx), %rsi
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x1140
movq 0x18(%rbx), %rdi
callq 0x1040
movq %r14, 0x18(%rbx)
movl 0xc(%rbx), %edi
shlq $0x2, %rdi
callq 0x5c10
movq %rax, %r14
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %edx
cmpl %edx, %eax
cmovbl %eax, %edx
movq 0x20(%rbx), %rsi
shlq $0x2, %rdx
movq %r14, %rdi
callq 0x1140
movq 0x20(%rbx), %rdi
callq 0x1040
movq %r14, 0x20(%rbx)
movl 0xc(%rbx), %edi
movl %edi, 0x8(%rbx)
shlq $0x2, %rdi
callq 0x5c10
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movl 0x40(%rax), %edi
incl %edi
shlq $0x2, %rdi
callq 0x5c10
movq %rax, 0x38(%rbx)
andl $0x0, (%rax)
movq (%rbx), %rcx
movq 0x28(%rbx), %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
movl 0x40(%rcx), %r8d
cmpq %r8, %rdx
ja 0x1561
addl -0x4(%rdi,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x154c
movl 0xc(%rcx), %edx
shlq $0x2, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x10d0
movq 0x10(%rbx), %rax
cmpl 0xc(%rbx), %r14d
jae 0x15a3
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movl (%rax,%r14,4), %esi
movl (%rcx,%rsi,4), %edi
leal 0x1(%rdi), %r8d
addl (%rdx,%rsi,4), %edi
movq 0x30(%rbx), %rdx
movl %r8d, (%rcx,%rsi,4)
movl %r14d, (%rdx,%rdi,4)
incq %r14
jmp 0x1576
addq $0x8, %rsp
popq %rbx
popq %r14
retq