LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/init_texture2.c
// Function: init_texture2
int	init_texture2(t_map *map)
{
	int	g;

	if ((map->img_e =
		mlx_xpm_file_to_image(map->mlx.mlx, map->east_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		mlx_destroy_image(map->mlx.mlx, map->img_w);
		return (1);
	}
	if ((map->img_sp =
		mlx_xpm_file_to_image(map->mlx.mlx, map->sprite_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		mlx_destroy_image(map->mlx.mlx, map->img_w);
		mlx_destroy_image(map->mlx.mlx, map->img_e);
		return (1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rsi
leaq -0x14(%rbp), %rcx
movq %rcx, %rdx
callq 0xf1c0
movq -0x10(%rbp), %rcx
movq %rax, 0x40(%rcx)
cmpq $0x0, %rax
jne 0xcf5d
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10c00
movl $0x1, -0x4(%rbp)
jmp 0xcffa
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rsi
leaq -0x14(%rbp), %rcx
movq %rcx, %rdx
callq 0xf1c0
movq -0x10(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0xcff3
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x10c00
movl $0x1, -0x4(%rbp)
jmp 0xcffa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/init_texture.c
// Function: init_texture
int	init_texture(t_map *map)
{
	int	g;

	if ((map->img_s =
		mlx_xpm_file_to_image(map->mlx.mlx, map->south_text, &g, &g)) == NULL)
		return (1);
	if ((map->img_n =
		mlx_xpm_file_to_image(map->mlx.mlx, map->north_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		return (1);
	}
	if ((map->img_w =
		mlx_xpm_file_to_image(map->mlx.mlx, map->west_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		return (1);
	}
	if (init_texture2(map) == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
leaq -0x14(%rbp), %rcx
movq %rcx, %rdx
callq 0xf1c0
movq -0x10(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0xd055
movl $0x1, -0x4(%rbp)
jmp 0xd12a
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rsi
leaq -0x14(%rbp), %rcx
movq %rcx, %rdx
callq 0xf1c0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0xd0a6
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10c00
movl $0x1, -0x4(%rbp)
jmp 0xd12a
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
leaq -0x14(%rbp), %rcx
movq %rcx, %rdx
callq 0xf1c0
movq -0x10(%rbp), %rcx
movq %rax, 0x38(%rcx)
cmpq $0x0, %rax
jne 0xd10c
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x10c00
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x10c00
movl $0x1, -0x4(%rbp)
jmp 0xd12a
movq -0x10(%rbp), %rdi
callq 0xced0
cmpl $0x1, %eax
jne 0xd123
movl $0x1, -0x4(%rbp)
jmp 0xd12a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/key_pressed.c
// Function: key_pressed
int	key_pressed(int keycode, t_map *map)
{
	if (keycode == 97)
		map->key.key_a = 1;
	if (keycode == 119)
		map->key.key_w = 1;
	if (keycode == 115)
		map->key.key_s = 1;
	if (keycode == 100)
		map->key.key_d = 1;
	if (keycode == 65361)
		map->key.key_left = 1;
	if (keycode == 65363)
		map->key.key_right = 1;
	if (keycode == 65307)
		ft_exit(map);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x61, -0x4(%rbp)
jne 0xd163
movq -0x10(%rbp), %rax
movl $0x1, 0x140(%rax)
cmpl $0x77, -0x4(%rbp)
jne 0xd177
movq -0x10(%rbp), %rax
movl $0x1, 0x144(%rax)
cmpl $0x73, -0x4(%rbp)
jne 0xd18b
movq -0x10(%rbp), %rax
movl $0x1, 0x148(%rax)
cmpl $0x64, -0x4(%rbp)
jne 0xd19f
movq -0x10(%rbp), %rax
movl $0x1, 0x14c(%rax)
cmpl $0xff51, -0x4(%rbp)     # imm = 0xFF51
jne 0xd1b6
movq -0x10(%rbp), %rax
movl $0x1, 0x154(%rax)
cmpl $0xff53, -0x4(%rbp)     # imm = 0xFF53
jne 0xd1cd
movq -0x10(%rbp), %rax
movl $0x1, 0x150(%rax)
cmpl $0xff1b, -0x4(%rbp)     # imm = 0xFF1B
jne 0xd1df
movq -0x10(%rbp), %rdi
callq 0x8f81
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/key_release.c
// Function: key_release
int	key_release(int keycode, t_map *map)
{
	if (keycode == 97)
		map->key.key_a = 0;
	if (keycode == 119)
		map->key.key_w = 0;
	if (keycode == 115)
		map->key.key_s = 0;
	if (keycode == 100)
		map->key.key_d = 0;
	if (keycode == 65361)
		map->key.key_left = 0;
	if (keycode == 65363)
		map->key.key_right = 0;
	if (keycode == 112)
		if (map->player.move_speed + 0.005 < 0.2)
			map->player.move_speed += 0.005;
	if (keycode == 109)
		if (map->player.move_speed - 0.005 > 0.001)
			map->player.move_speed -= 0.005;
	if (keycode == 111)
		if (map->player.rotate_speed + 0.005 < 0.2)
			map->player.rotate_speed += 0.005;
	if (keycode == 108)
		if (map->player.rotate_speed - 0.005 > 0.001)
			map->player.rotate_speed -= 0.005;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x61, -0x4(%rbp)
jne 0xd20f
movq -0x10(%rbp), %rax
movl $0x0, 0x140(%rax)
cmpl $0x77, -0x4(%rbp)
jne 0xd223
movq -0x10(%rbp), %rax
movl $0x0, 0x144(%rax)
cmpl $0x73, -0x4(%rbp)
jne 0xd237
movq -0x10(%rbp), %rax
movl $0x0, 0x148(%rax)
cmpl $0x64, -0x4(%rbp)
jne 0xd24b
movq -0x10(%rbp), %rax
movl $0x0, 0x14c(%rax)
cmpl $0xff51, -0x4(%rbp)     # imm = 0xFF51
jne 0xd262
movq -0x10(%rbp), %rax
movl $0x0, 0x154(%rax)
cmpl $0xff53, -0x4(%rbp)     # imm = 0xFF53
jne 0xd279
movq -0x10(%rbp), %rax
movl $0x0, 0x150(%rax)
cmpl $0x70, -0x4(%rbp)
jne 0xd2bf
movq -0x10(%rbp), %rax
movsd 0x4975(%rip), %xmm1     # 0x11c00
addsd 0xc8(%rax), %xmm1
movsd 0x495d(%rip), %xmm0     # 0x11bf8
ucomisd %xmm1, %xmm0
jbe 0xd2bd
movq -0x10(%rbp), %rax
movsd 0x4953(%rip), %xmm0     # 0x11c00
addsd 0xc8(%rax), %xmm0
movsd %xmm0, 0xc8(%rax)
jmp 0xd2bf
cmpl $0x6d, -0x4(%rbp)
jne 0xd30d
movq -0x10(%rbp), %rax
movsd 0xc8(%rax), %xmm0
movsd 0x4927(%rip), %xmm1     # 0x11c00
subsd %xmm1, %xmm0
movsd 0x4923(%rip), %xmm1     # 0x11c08
ucomisd %xmm1, %xmm0
jbe 0xd30b
movq -0x10(%rbp), %rax
movsd 0xc8(%rax), %xmm0
movsd 0x4901(%rip), %xmm1     # 0x11c00
subsd %xmm1, %xmm0
movsd %xmm0, 0xc8(%rax)
jmp 0xd30d
cmpl $0x6f, -0x4(%rbp)
jne 0xd353
movq -0x10(%rbp), %rax
movsd 0x48e1(%rip), %xmm1     # 0x11c00
addsd 0xd0(%rax), %xmm1
movsd 0x48c9(%rip), %xmm0     # 0x11bf8
ucomisd %xmm1, %xmm0
jbe 0xd351
movq -0x10(%rbp), %rax
movsd 0x48bf(%rip), %xmm0     # 0x11c00
addsd 0xd0(%rax), %xmm0
movsd %xmm0, 0xd0(%rax)
jmp 0xd353
cmpl $0x6c, -0x4(%rbp)
jne 0xd3a1
movq -0x10(%rbp), %rax
movsd 0xd0(%rax), %xmm0
movsd 0x4893(%rip), %xmm1     # 0x11c00
subsd %xmm1, %xmm0
movsd 0x488f(%rip), %xmm1     # 0x11c08
ucomisd %xmm1, %xmm0
jbe 0xd39f
movq -0x10(%rbp), %rax
movsd 0xd0(%rax), %xmm0
movsd 0x486d(%rip), %xmm1     # 0x11c00
subsd %xmm1, %xmm0
movsd %xmm0, 0xd0(%rax)
jmp 0xd3a1
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/main.c
// Function: main
int	main(int argc, char **argv)
{
	t_map	*map;
	int		i;

	i = -1;
	if ((argc < 2 || argc > 3) && ft_error(0) == 0)
		return (0);
	if (ft_control_file(argv[1], ".cub") == 1 && ft_error(1) == 0)
		return (0);
	if (argc > 2 && ft_strcmp(argv[2], "--save") != 0 && ft_error(2) == 0)
		return (0);
	if ((map = map_init()) == NULL && ft_error(3) == 0)
		return (0);
	if (ft_check_map_and_recup(map, argv[1]) == 1 && ft_check_malloc(map) == 0)
		return (0);
	map->argc = argc;
	ft_cub3d(map);
	ft_check_malloc(map);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
cmpl $0x2, -0x8(%rbp)
jl 0xd3d9
cmpl $0x3, -0x8(%rbp)
jle 0xd3f1
xorl %edi, %edi
callq 0x8e97
cmpl $0x0, %eax
jne 0xd3f1
movl $0x0, -0x4(%rbp)
jmp 0xd4d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4810(%rip), %rsi      # 0x11c10
callq 0x8136
cmpl $0x1, %eax
jne 0xd425
movl $0x1, %edi
callq 0x8e97
cmpl $0x0, %eax
jne 0xd425
movl $0x0, -0x4(%rbp)
jmp 0xd4d6
cmpl $0x2, -0x8(%rbp)
jle 0xd45c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x47db(%rip), %rsi      # 0x11c15
callq 0xc470
cmpl $0x0, %eax
je 0xd45c
movl $0x2, %edi
callq 0x8e97
cmpl $0x0, %eax
jne 0xd45c
movl $0x0, -0x4(%rbp)
jmp 0xd4d6
callq 0xd4e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xd483
movl $0x3, %edi
callq 0x8e97
cmpl $0x0, %eax
jne 0xd483
movl $0x0, -0x4(%rbp)
jmp 0xd4d6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7f42
cmpl $0x1, %eax
jne 0xd4b0
movq -0x18(%rbp), %rdi
callq 0x7c8a
cmpl $0x0, %eax
jne 0xd4b0
movl $0x0, -0x4(%rbp)
jmp 0xd4d6
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x17c(%rax)
movq -0x18(%rbp), %rdi
callq 0x83cb
movq -0x18(%rbp), %rdi
callq 0x7c8a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/map_init.c
// Function: map_init
t_map	*map_init(void)
{
	t_map	*map;

	if ((map = malloc(sizeof(t_map))) == NULL)
		return (NULL);
	map->map = NULL;
	map->first_map = NULL;
	map->orientation = '0';
	map->line_map = 0;
	map->res_x = 0;
	map->res_y = 0;
	map->north_text = NULL;
	map->south_text = NULL;
	map->west_text = NULL;
	map->east_text = NULL;
	map->sprite_text = NULL;
	map->c_color = -1;
	map->f_color = -1;
	return (map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x188, %edi            # imm = 0x188
callq 0x7100
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xd509
movq $0x0, -0x8(%rbp)
jmp 0xd5a3
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x30, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x78(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x7c(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/raphifou15[P]cub3d/src/next_frame.c
// Function: next_frame
int	next_frame(t_map *map)
{
	int	y;

	y = -1;
	if ((map->mlx.img = mlx_new_image(map->mlx.mlx, map->res_x, map->res_y))
		== NULL)
	{
		free_img_text(map);
		mlx_destroy_window(map->mlx.mlx, map->mlx.win);
		free(map->mlx.mlx);
		ft_check_malloc(map);
		ft_error5(51);
		exit(0);
	}
	ft_raycasting(map);
	ft_move(map);
	if (map->argc != 3)
	{
		mlx_put_image_to_window(map->mlx.mlx, map->mlx.win, map->mlx.img, 0, 0);
		mlx_destroy_image(map->mlx.mlx, map->mlx.img);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
callq 0xe300
movq -0x8(%rbp), %rcx
movq %rax, 0x90(%rcx)
cmpq $0x0, %rax
jne 0xd6a0
movq -0x8(%rbp), %rdi
callq 0x76e5
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x10650
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x7180
movq -0x8(%rbp), %rdi
callq 0x7c8a
movl $0x33, %edi
callq 0x8dff
xorl %edi, %edi
callq 0x70a0
movq -0x8(%rbp), %rdi
callq 0xa9f8
movq -0x8(%rbp), %rdi
callq 0x9c8d
movq -0x8(%rbp), %rax
cmpl $0x3, 0x17c(%rax)
je 0xd706
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0xe580
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x10c00
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/pim_listener.c
// Function: usage
void usage()
{
	printf("Usage: ./pim_linster -r rp -l length\n");
	printf(" -r rp      rp address\n");
	printf(" -l length  PIM packet size, the default packet size is 256 bytes\n");
	printf(" Version:   %s\n",version);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe19(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq 0xe31(%rip), %rdi       # 0x202a
movb $0x0, %al
callq 0x1040
leaq 0xe3b(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1040
leaq 0xe70(%rip), %rdi       # 0x2085
leaq 0xe79(%rip), %rsi       # 0x2095
movb $0x0, %al
callq 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/mkstatval.c
// Function: main
int main(void) {
	int cstatus, pstatus;
	pid_t pid;
	
	for (cstatus = 0; cstatus < 2; ++cstatus) {
		switch (pid = fork()) {
		case -1:
			perror("fork");
			return 1;
		case 0:
			_exit(cstatus);
		default:
			if (wait(&pstatus) != pid) {
				perror("wait");
				return 1;
			}
			printf("#define STATUS%d %d\n", cstatus, pstatus);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1221
callq 0x1070
movl %eax, -0x10(%rbp)
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $-0x1, %eax
je 0x11bd
jmp 0x11b4
movl -0x14(%rbp), %eax
testl %eax, %eax
je 0x11d2
jmp 0x11da
leaq 0xe40(%rip), %rdi       # 0x2004
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1228
movl -0x8(%rbp), %edi
callq 0x1030
leaq -0xc(%rbp), %rdi
callq 0x1060
cmpl -0x10(%rbp), %eax
je 0x11fd
leaq 0xe1a(%rip), %rdi       # 0x2009
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1228
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xe04(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1040
jmp 0x1213
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1196
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_03/flockr.c
// Function: main
int main(void)
{
	int fd;
	char buf[32];
	struct flock fl;
	int ret;

	/* Open the file */
	fd = open("file.locked", O_RDONLY);
	if (fd < 0) {
		perror("open");
		return -1;
	}
	printf("file opened\n");

	/* Establish a read lock */
	fl.l_type   = F_RDLCK;
	fl.l_whence = SEEK_SET;
	fl.l_start  = 0;        /* Offset from l_whence */
	fl.l_len    = 0;        /* length, 0 = to EOF   */
	fl.l_pid    = getpid(); /* our PID              */
	ret = fcntl(fd, F_SETLKW, &fl);
	if (ret < 0) {
		perror("fcntl(F_SETLKW)");
		return -1;
	}
	printf("read lock get\n");

	/* Do the read */
	ret = read(fd, buf, 32);
	if (ret < 0) {
		perror("read");
		return -1;
	}
	printf("read done\n");

	printf("sleeping 10s...\n");
	sleep(10);

	/* Unlock the region */
	fl.l_type   = F_UNLCK;
	fl.l_whence = SEEK_SET;
	fl.l_start  = 0;        /* Offset from l_whence */
	fl.l_len    = 0;        /* length, 0 = to EOF   */
	fl.l_pid    = getpid(); /* our PID              */
	ret = fcntl(fd, F_UNLCK, &fl);
	if (ret < 0) {
		perror("fcntl(F_SETLKW)");
		return -1;
	}
	printf("unlock done\n");

	close(fd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe3e(%rip), %rdi       # 0x2004
xorl %esi, %esi
movb $0x0, %al
callq 0x1080
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x11f0
leaq 0xe31(%rip), %rdi       # 0x2010
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132e
leaq 0xe1e(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1050
movw $0x0, -0x50(%rbp)
movw $0x0, -0x4e(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1040
movl %eax, -0x38(%rbp)
movl -0x8(%rbp), %edi
movl $0x7, %esi
leaq -0x50(%rbp), %rdx
movb $0x0, %al
callq 0x1030
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x1256
leaq 0xddd(%rip), %rdi       # 0x2022
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132e
leaq 0xdd5(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x1070
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x1296
leaq 0xdbc(%rip), %rdi       # 0x2041
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132e
leaq 0xda9(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1050
leaq 0xda6(%rip), %rdi       # 0x2051
movb $0x0, %al
callq 0x1050
movl $0xa, %edi
callq 0x10a0
movw $0x2, -0x50(%rbp)
movw $0x0, -0x4e(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1040
movl %eax, -0x38(%rbp)
movl -0x8(%rbp), %edi
movl $0x2, %esi
leaq -0x50(%rbp), %rdx
movb $0x0, %al
callq 0x1030
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x1311
leaq 0xd1f(%rip), %rdi       # 0x2022
callq 0x1090
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x132e
leaq 0xd4a(%rip), %rdi       # 0x2062
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %edi
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/gcx-decompile.c
// Function: gcx_iscommand
int gcx_iscommand(unsigned char *data) {
	unsigned int i;
	uint16_t cmd = bswap_16(*(uint16_t *)data);
	for(i = 0; i < sizeofarr(gcxcommands); i++) {
		if(gcxcommands[i].hash == cmd) return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
callq 0x1260
movw %ax, -0x16(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0xd, %rax
jae 0x124f
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x2e68(%rip), %rax      # 0x4090
imulq $0x22, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
movzwl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1242
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1256
jmp 0x1244
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1213
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/gcx-decompile.c
// Function: gcx_proc
uint16_t gcx_proc(gcxdef def, unsigned char *data, FILE *out) {
	uint16_t size = bswap_16(*(uint16_t *)(data + 1)), cur = 0;
	printf("gcx_proc == type %02x == size %04x\n", data[0], size);
	switch(data[0]) {
		case 0x40: {
			fprintf(out, "proc %04x {\n", def.name);
			cur = 3;
			while(data[cur]) cur += gcx_proc(def, data+cur, out);
			fprintf(out, "}\n");
			break;
		}
		case 0x60: {
			fprintf(out, "begin {\n");
			cur = 3;
			while(gcx_iscommand(data+cur) > -1) cur += gcx_cmd(data+cur, out);
			fprintf(out, "}\n");
			break;
		}
		case 0x70: {
			size >>= 8;
			fprintf(out, "call %04x\n", bswap_16(*(uint16_t *)(data+2)));
			break;
		}
		default: {
			printf("unknown type %02x size %04x\n", data[0], size);
			break;
		}
	}
	return (size+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x1260
movw %ax, -0x1a(%rbp)
movw $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
movzwl -0x1a(%rbp), %edx
leaq 0xc42(%rip), %rdi       # 0x20ce
xorl %eax, %eax
callq 0x1080
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x40, %eax
je 0x14bf
jmp 0x14a4
movl -0x20(%rbp), %eax
subl $0x60, %eax
je 0x1528
jmp 0x14ae
movl -0x20(%rbp), %eax
subl $0x70, %eax
je 0x1590
jmp 0x15c7
movq -0x18(%rbp), %rdi
movzwl -0x4(%rbp), %edx
leaq 0xc24(%rip), %rsi       # 0x20f2
movb $0x0, %al
callq 0x1090
movw $0x3, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzwl -0x1c(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x1511
movq -0x10(%rbp), %rsi
movzwl -0x1c(%rbp), %eax
cltq
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movl -0x4(%rbp), %edi
callq 0x1450
movzwl %ax, %ecx
movzwl -0x1c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1c(%rbp)
jmp 0x14db
movq -0x18(%rbp), %rdi
leaq 0xbe3(%rip), %rsi       # 0x20ff
movb $0x0, %al
callq 0x1090
jmp 0x15e0
movq -0x18(%rbp), %rdi
leaq 0xbcf(%rip), %rsi       # 0x2102
movb $0x0, %al
callq 0x1090
movw $0x3, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x1c(%rbp), %eax
cltq
addq %rax, %rdi
callq 0x11f0
cmpl $-0x1, %eax
jle 0x157c
movq -0x10(%rbp), %rdi
movzwl -0x1c(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x15f0
movzwl %ax, %ecx
movzwl -0x1c(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x1c(%rbp)
jmp 0x1540
movq -0x18(%rbp), %rdi
leaq 0xb78(%rip), %rsi       # 0x20ff
movb $0x0, %al
callq 0x1090
jmp 0x15e0
movzwl -0x1a(%rbp), %eax
sarl $0x8, %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x1260
movq -0x28(%rbp), %rdi
movzwl %ax, %edx
leaq 0xb4d(%rip), %rsi       # 0x210b
movb $0x0, %al
callq 0x1090
jmp 0x15e0
movq -0x10(%rbp), %rax
movzbl (%rax), %esi
movzwl -0x1a(%rbp), %edx
leaq 0xb3d(%rip), %rdi       # 0x2116
movb $0x0, %al
callq 0x1080
movzwl -0x1a(%rbp), %eax
addl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/gcx-decompile.c
// Function: gcx_cmd
uint16_t gcx_cmd(unsigned char *data, FILE *out) {
	int cmd = gcx_iscommand(data);
	uint16_t size = bswap_16(*(uint16_t *)(data+2)) >> 8, cur = 0;
	printf("gcx_cmd == cmd %s (%d) == size %04x\n", gcxcommands[cmd].name, cmd, size);
	fprintf(out, "%s(", gcxcommands[cmd].name);
	cur = 3;
	switch(cmd) {
		case 0: // eval
		case 3:
		case 1: { // if
			while(data[cur]) cur += gcx_param(data+cur, out);
			break;
		}
		case 2: { // load
			fprintf(out, "%02x \"%s\"\n", data[cur], (char *)(data+cur+2));
			cur += data[cur];
			while(data[cur]) cur += gcx_param(data+cur, out);
			break;
		}
		default: {
			printf("unknown cmd %02x size %04x\n", cmd, size);
			break;
		}
	}
	fprintf(out, ")\n");
	return size+2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11f0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x1260
movzwl %ax, %eax
shrl $0x8, %eax
movw %ax, -0x16(%rbp)
movw $0x0, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
movl %ecx, %edx
movq %rcx, %rax
shlq $0x5, %rax
leaq (%rax,%rcx,2), %rcx
leaq 0x2a4f(%rip), %rax      # 0x4090
movq %rax, -0x28(%rbp)
leaq 0x2(%rax,%rcx), %rsi
movzwl -0x16(%rbp), %ecx
leaq 0xa26(%rip), %rdi       # 0x207b
xorl %eax, %eax
movb %al, -0x1d(%rbp)
callq 0x1080
movq -0x28(%rbp), %rcx
movb -0x1d(%rbp), %al
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq %rsi, %rdx
shlq $0x5, %rdx
leaq (%rdx,%rsi,2), %rdx
leaq 0x2(%rcx,%rdx), %rdx
leaq 0xa1b(%rip), %rsi       # 0x20a0
callq 0x1090
movw $0x3, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
jb 0x16b5
jmp 0x169d
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x16ef
jmp 0x16a7
movl -0x1c(%rbp), %eax
subl $0x3, %eax
jne 0x1769
jmp 0x16b5
jmp 0x16b7
movq -0x8(%rbp), %rax
movzwl -0x18(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x16ea
movq -0x8(%rbp), %rdi
movzwl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1290
movzwl %ax, %ecx
movzwl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
jmp 0x16b7
jmp 0x177e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %edx
movq -0x8(%rbp), %rcx
movzwl -0x18(%rbp), %eax
cltq
addq %rax, %rcx
addq $0x2, %rcx
leaq 0x98d(%rip), %rsi       # 0x20a4
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movzwl -0x18(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movzwl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x18(%rbp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x1767
movq -0x8(%rbp), %rdi
movzwl -0x18(%rbp), %eax
cltq
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1290
movzwl %ax, %ecx
movzwl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
jmp 0x1734
jmp 0x177e
movl -0x14(%rbp), %esi
movzwl -0x16(%rbp), %edx
leaq 0x938(%rip), %rdi       # 0x20af
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
leaq 0x942(%rip), %rsi       # 0x20cb
movb $0x0, %al
callq 0x1090
movzwl -0x16(%rbp), %eax
addl $0x2, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/metablobs.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Metablobs";

    scg_app_t app;
    scg_app_init(&app, config);

    metablobs_t metablobs;
    metablobs_init(&metablobs, METABLOBS_CONST_A, METABLOBS_CONST_B);

    while (scg_app_process_events(&app)) {
        update(&metablobs, app.elapsed_time);

        draw(app.draw_target, &metablobs);

        scg_app_present(&app);
    }

    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49f0
leaq 0x1e93(%rip), %rax      # 0x85ac
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a40
leaq -0x108(%rbp), %rdi
movss 0x18e6(%rip), %xmm0     # 0x8038
movss 0x18e2(%rip), %xmm1     # 0x803c
callq 0x67c0
leaq -0xa0(%rbp), %rdi
callq 0x56c0
testb $0x1, %al
jne 0x6771
jmp 0x67a3
movss -0x98(%rbp), %xmm0
leaq -0x108(%rbp), %rdi
callq 0x6a30
movq -0x68(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x6ad0
leaq -0xa0(%rbp), %rdi
callq 0x5810
jmp 0x675f
leaq -0xa0(%rbp), %rdi
callq 0x5cc0
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/metablobs.c
// Function: update
static void update(metablobs_t *metablobs, float32_t t) {
    for (int i = 0; i < NUM_BLOBS; i++) {
        blob_t *blob = &metablobs->blobs[i];
        lissajous_get_point(blob->lissajous, &blob->x, &blob->y,
                            t * blob->speed_modifier);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x6ac0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rcx
mulss 0x1c(%rcx), %xmm0
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rsp)
callq 0x6fa0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6a48
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/main.c
// Function: callback_snc_response
static int
callback_snc_response(void * cookie, uint8_t * buf, size_t buflen, int sock)
{
	struct nc_cookie * C = cookie;

	/* Write buffer to the previously-opened file. */
	if (fwrite(buf, sizeof(uint8_t), buflen, C->out) != buflen) {
		warnp("fwrite");
		goto err0;
	}

	/* Echo to the client (if applicable). */
	if ((C->bps > 0) && (write_bps(sock, buf, buflen, C->bps)))
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2310
cmpq -0x20(%rbp), %rax
je 0x2a87
jmp 0x2a50
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2a75
leaq 0x7751(%rip), %rdi      # 0xa1b2
movb $0x0, %al
callq 0x7ba0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2a83
leaq 0x7736(%rip), %rdi      # 0xa1b2
movb $0x0, %al
callq 0x7df0
jmp 0x2a85
jmp 0x2aba
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x2ab1
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x2ad0
cmpl $0x0, %eax
je 0x2ab1
jmp 0x2aba
movl $0x0, -0x4(%rbp)
jmp 0x2ac1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/simple_server.c
// Function: doaccept
static int
doaccept(struct accept_state * A)
{
	int rc = 0;

	/* If we can, accept a new connection. */
	if ((A->nconn < A->nconn_max) && (A->accept_cookie == NULL) &&
	    !A->shutdown_requested) {
		if ((A->accept_cookie =
		    network_accept(A->s, callback_gotconn, A)) == NULL) {
			warnp("network_accept");
			rc = -1;
		}
	}

	/* Return success/fail status. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x300e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x300e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x300e
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rdx
leaq 0x165(%rip), %rsi       # 0x3120
callq 0x54d0
movq -0x8(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x300c
jmp 0x2fd0
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2ff5
leaq 0x7235(%rip), %rdi      # 0xa216
movb $0x0, %al
callq 0x7ba0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3003
leaq 0x721a(%rip), %rdi      # 0xa216
movb $0x0, %al
callq 0x7df0
jmp 0x3005
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0x300e
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/simple_server.c
// Function: simple_server_shutdown
static void
simple_server_shutdown(void * cookie)
{
	struct accept_state * A = cookie;
	struct conn_list_node * node_ptr;

	/* Cancel any further accepts. */
	if (A->accept_cookie != NULL)
		network_accept_cancel(A->accept_cookie);

	/*
	 * Shut down any open connections.  drop() will call
	 * conndied(), which removes the relevant conn_list_node
	 * from the list of conn_cookies.
	 */
	while ((node_ptr = LIST_FIRST(&A->conn_cookies)) != NULL) {
		/* Remove nodes from the list. */
		if (drop(LIST_FIRST(&A->conn_cookies)))
			warn0("drop");

		/*
		 * Force the clang static analyzer to realize that
		 * the A->conn_cookies pointer changed.
		 */
		assert(node_ptr != LIST_FIRST(&A->conn_cookies));
	}

	/* Close socket and free memory. */
	if (close(A->s) == -1)
		warnp("close");
	free(A);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x304c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x5600
jmp 0x304e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x30c0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x34a0
cmpl $0x0, %eax
je 0x308f
jmp 0x3074
leaq 0x71b7(%rip), %rdi      # 0xa232
movb $0x0, %al
callq 0x7df0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x308f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
je 0x309f
jmp 0x30be
leaq 0x7201(%rip), %rdi      # 0xa2a7
leaq 0x71c4(%rip), %rsi      # 0xa271
movl $0x100, %edx            # imm = 0x100
leaq 0x7217(%rip), %rcx      # 0xa2d0
callq 0x2190
jmp 0x304e
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x21b0
cmpl $-0x1, %eax
jne 0x3109
jmp 0x30d2
callq 0x20a0
cmpl $0x0, (%rax)
je 0x30f7
leaq 0x6fca(%rip), %rdi      # 0xa0ad
movb $0x0, %al
callq 0x7ba0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3105
leaq 0x6faf(%rip), %rdi      # 0xa0ad
movb $0x0, %al
callq 0x7df0
jmp 0x3107
jmp 0x3109
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/simple_server.c
// Function: callback_read
static int
callback_read(void * cookie, ssize_t lenread)
{
	struct conn_list_node * R = cookie;
	struct accept_state * A = R->A;
	int sock = R->sock_read;

	/* Cookie is no longer valid. */
	R->network_read_cookie = NULL;

	/* If we have a message. */
	if (lenread > 0) {
		/* Handle it with the parent code. */
		if (A->callback_nc_message(A->caller_cookie, R->buf,
		    (size_t)lenread, sock))
			goto err0;

		/* Try to read some more data. */
		if ((R->network_read_cookie = network_read(R->sock_read,
		    R->buf, BUFLEN, 1, callback_read, R)) == NULL) {
			warnp("network_read");
			goto err0;
		}
	} else if (lenread == 0) {
		if (drop(R)) {
			warn0("drop");
			goto err0;
		}
	} else {
		warn0("Failed to read from network");
		A->conndone = 1;
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x2020(%rax)
cmpq $0x0, -0x18(%rbp)
jle 0x3428
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x20(%rbp), %rsi
addq $0x1c, %rsi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq *%rax
cmpl $0x0, %eax
je 0x33b3
jmp 0x348f
movq -0x20(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x1c, %rsi
movq -0x20(%rbp), %r9
movl $0x2000, %edx           # imm = 0x2000
movl $0x1, %ecx
leaq -0x97(%rip), %r8        # 0x3340
callq 0x5640
movq -0x20(%rbp), %rcx
movq %rax, 0x2020(%rcx)
cmpq $0x0, %rax
jne 0x3426
jmp 0x33ef
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3414
leaq 0x6e25(%rip), %rdi      # 0xa225
movb $0x0, %al
callq 0x7ba0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3422
leaq 0x6e0a(%rip), %rdi      # 0xa225
movb $0x0, %al
callq 0x7df0
jmp 0x3424
jmp 0x348f
jmp 0x3486
cmpq $0x0, -0x18(%rbp)
jne 0x345c
movq -0x20(%rbp), %rdi
callq 0x34a0
cmpl $0x0, %eax
je 0x345a
jmp 0x343f
leaq 0x6dec(%rip), %rdi      # 0xa232
movb $0x0, %al
callq 0x7df0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x348f
jmp 0x3484
jmp 0x345e
leaq 0x6dd2(%rip), %rdi      # 0xa237
movb $0x0, %al
callq 0x7df0
callq 0x20a0
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x4(%rax)
jmp 0x348f
jmp 0x3486
movl $0x0, -0x4(%rbp)
jmp 0x3496
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/simple_server.c
// Function: drop
static int
drop(struct conn_list_node * node_ptr)
{

	/* If we still have an active read cookie, cancel it. */
	if (node_ptr->network_read_cookie != NULL)
		network_read_cancel(node_ptr->network_read_cookie);

	/* Close the incoming connection. */
	if (close(node_ptr->sock_read) == -1) {
		warnp("close");
		goto err0;
	}

	/* Clean up the node. */
	conndied(node_ptr);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2020(%rax)
je 0x34ca
movq -0x10(%rbp), %rax
movq 0x2020(%rax), %rdi
callq 0x5910
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x21b0
cmpl $-0x1, %eax
jne 0x3514
jmp 0x34dd
callq 0x20a0
cmpl $0x0, (%rax)
je 0x3502
leaq 0x6bbf(%rip), %rdi      # 0xa0ad
movb $0x0, %al
callq 0x7ba0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x3510
leaq 0x6ba4(%rip), %rdi      # 0xa0ad
movb $0x0, %al
callq 0x7df0
jmp 0x3512
jmp 0x3526
movq -0x10(%rbp), %rdi
callq 0x3540
movl $0x0, -0x4(%rbp)
jmp 0x352d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/nc-server/simple_server.c
// Function: conndied
static int
conndied(struct conn_list_node * node_ptr)
{
	struct accept_state * A = node_ptr->A;

	/* We should always have a non-empty list of conn_cookies. */
	assert(!LIST_EMPTY(&A->conn_cookies));

	/* We've lost a connection. */
	A->nconn -= 1;

	/* Adjust shutdown counter, if relevant. */
	if (A->shutdown_after > 0) {
		A->shutdown_current++;
		if (A->shutdown_current >= A->shutdown_after)
			A->shutdown_requested = 1;
	}

	/* Remove the closed connection from the list of conn_cookies. */
	LIST_REMOVE(node_ptr, entries);

	/* Clean up the now-unused node. */
	free(node_ptr);

	/* If requested to do so, indicate that all connections are closed. */
	if (A->shutdown_requested && (A->nconn == 0))
		A->conndone = 1;

	/* Maybe accept more connections. */
	return (doaccept(A));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3565
jmp 0x3584
leaq 0x6ce7(%rip), %rdi      # 0xa253
leaq 0x6cfe(%rip), %rsi      # 0xa271
movl $0x4c, %edx
leaq 0x6d02(%rip), %rcx      # 0xa281
callq 0x2190
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x35ce
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x35cc
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x35ce
jmp 0x35d0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x35ed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x3628
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3628
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x2f70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hfile.c
// Function: fail
void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) HTS_NORETURN
fail(const char *format, ...)
{
    int err = errno;
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    if (err != 0) fprintf(stderr, ": %s", strerror(err));
    fprintf(stderr, "\n");
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5ad8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xff4ac(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4650
leaq -0x30(%rbp), %rax
cmpl $0x0, -0xc(%rbp)
je 0x5b7f
movq 0xff48b(%rip), %rax     # 0x104fe0
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
movl -0xc(%rbp), %edi
callq 0x4120
movq -0xe8(%rbp), %rdi
movq %rax, %rdx
leaq 0xe6190(%rip), %rsi     # 0xebd08
movb $0x0, %al
callq 0x46c0
movq 0xff45a(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
leaq 0xe19fa(%rip), %rsi     # 0xe758a
movb $0x0, %al
callq 0x46c0
movl $0x1, %edi
callq 0x45b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hfile.c
// Function: check_offset
void check_offset(hFILE *f, off_t off, const char *message)
{
    off_t ret = htell(f);
    if (ret < 0) fail("htell(%s)", message);
    if (ret == off) return;

    fprintf(stderr, "%s offset incorrect: expected %ld but got %ld\n",
            message, (long)off, (long)ret);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x5bea
movq -0x18(%rbp), %rsi
leaq 0xe1421(%rip), %rdi     # 0xe7004
movb $0x0, %al
callq 0x5aa0
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x5bfa
addq $0x20, %rsp
popq %rbp
retq
movq 0xff3df(%rip), %rax     # 0x104fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0xe13f7(%rip), %rsi     # 0xe700e
movb $0x0, %al
callq 0x46c0
movl $0x1, %edi
callq 0x45b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hfile.c
// Function: slurp
char *slurp(const char *filename)
{
    char *text;
    struct stat sbuf;
    size_t filesize;
    FILE *f = fopen(filename, "rb");
    if (f == NULL) fail("fopen(\"%s\", \"rb\")", filename);
    if (fstat(fileno(f), &sbuf) != 0) fail("fstat(\"%s\")", filename);
    filesize = sbuf.st_size;

    text = (char *) malloc(filesize + 1);
    if (text == NULL) fail("malloc(text)");

    if (fread(text, 1, filesize, f) != filesize) fail("fread");
    fclose(f);

    text[filesize] = '\0';
    return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe13c3(%rip), %rsi     # 0xe703d
callq 0x4580
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x5ca2
movq -0x8(%rbp), %rsi
leaq 0xe13a5(%rip), %rdi     # 0xe7040
movb $0x0, %al
callq 0x5aa0
movq -0xb0(%rbp), %rdi
callq 0x44c0
movl %eax, %edi
leaq -0xa0(%rbp), %rsi
callq 0x4850
cmpl $0x0, %eax
je 0x5cd3
movq -0x8(%rbp), %rsi
leaq 0xe1386(%rip), %rdi     # 0xe7052
movb $0x0, %al
callq 0x5aa0
movq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
addq $0x1, %rdi
callq 0x4640
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5d07
leaq 0xe135e(%rip), %rdi     # 0xe705e
movb $0x0, %al
callq 0x5aa0
movq -0x10(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movl $0x1, %esi
callq 0x4760
cmpq -0xa8(%rbp), %rax
je 0x5d3a
leaq 0xe1338(%rip), %rdi     # 0xe706b
movb $0x0, %al
callq 0x5aa0
movq -0xb0(%rbp), %rdi
callq 0x4490
movq -0x10(%rbp), %rax
movq -0xa8(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/hfile.c
// Function: reopen
void reopen(const char *infname, const char *outfname)
{
    if (fin) { if (hclose(fin) != 0) fail("hclose(input)"); }
    if (fout) { if (hclose(fout) != 0) fail("hclose(output)"); }

    fin = hopen(infname, "r");
    if (fin == NULL) fail("hopen(\"%s\")", infname);

    fout = hopen(outfname, "w");
    if (fout == NULL) fail("hopen(\"%s\")", outfname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x103f20(%rip)    # 0x109ca8
je 0x5dab
movq 0x103f17(%rip), %rdi    # 0x109ca8
callq 0x8530
cmpl $0x0, %eax
je 0x5da9
leaq 0xe12cf(%rip), %rdi     # 0xe7071
movb $0x0, %al
callq 0x5aa0
jmp 0x5dab
cmpq $0x0, 0x103efd(%rip)    # 0x109cb0
je 0x5dd6
movq 0x103ef4(%rip), %rdi    # 0x109cb0
callq 0x8530
cmpl $0x0, %eax
je 0x5dd4
leaq 0xe12b2(%rip), %rdi     # 0xe707f
movb $0x0, %al
callq 0x5aa0
jmp 0x5dd6
movq -0x8(%rbp), %rdi
leaq 0xe50c1(%rip), %rsi     # 0xeaea2
movb $0x0, %al
callq 0x94c0
movq %rax, 0x103eb9(%rip)    # 0x109ca8
cmpq $0x0, 0x103eb1(%rip)    # 0x109ca8
jne 0x5e0b
movq -0x8(%rbp), %rsi
leaq 0xe128a(%rip), %rdi     # 0xe708e
movb $0x0, %al
callq 0x5aa0
movq -0x10(%rbp), %rdi
leaq 0xe42a6(%rip), %rsi     # 0xea0bc
movb $0x0, %al
callq 0x94c0
movq %rax, 0x103e8c(%rip)    # 0x109cb0
cmpq $0x0, 0x103e84(%rip)    # 0x109cb0
jne 0x5e40
movq -0x10(%rbp), %rsi
leaq 0xe1255(%rip), %rdi     # 0xe708e
movb $0x0, %al
callq 0x5aa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/group-function/request.c
// Function: usage
void usage(char **argv, char **av)
{
  if (av)
  {
    fprintf(stderr, "Unknown or invalid argument %s\n", av[0]);
  }
  fprintf(stderr, "Usage: %s <dest> <prio> <pgn> <interval> <field>=<value> ...\n\n", argv[0]);
  fprintf(stderr, "       <field> is a decimal value\n");
  fprintf(stderr, "       <value> is a hexadecimal value; the length of the value defines how many bytes are encoded\n");
  fprintf(stderr, "       Maximum # of fields: %d\n\n", MAX_FIELDS);
  fprintf(stderr, "This program uses PGN 126208 to request a device to start reporting a PGN at the given interval.\n");
  fprintf(stderr, "The use of this is thus completely dependent on what the device allows.\n\n" COPYRIGHT);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13b6
movq 0x5c5a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2c55(%rip), %rsi      # 0x4004
movb $0x0, %al
callq 0x1130
movq 0x5c3b(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x2c56(%rip), %rsi      # 0x4024
movb $0x0, %al
callq 0x1130
movq 0x5c1c(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2c7d(%rip), %rsi      # 0x4063
movb $0x0, %al
callq 0x1130
movq 0x5c04(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2c88(%rip), %rsi      # 0x4086
movb $0x0, %al
callq 0x1130
movq 0x5bec(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2cd3(%rip), %rsi      # 0x40e9
movl $0x14, %edx
movb $0x0, %al
callq 0x1130
movq 0x5bcf(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2cd7(%rip), %rsi      # 0x410a
movb $0x0, %al
callq 0x1130
movq 0x5bb7(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2d21(%rip), %rsi      # 0x416c
movb $0x0, %al
callq 0x1130
movl $0x1, %edi
callq 0x11f0
nopl (%rax)