LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_cub3d.c
// Function: ft_cub3d
void	ft_cub3d(t_map *map)
{
	if ((map->mlx.mlx = mlx_init()) == NULL)
		return (ft_error5(48));
	if (init_texture(map) == 1 && ft_free(map->mlx.mlx) == NULL)
		return (ft_error5(49));
	mlx_get_screen_size(map->mlx.mlx, &map->screen_x, &map->screen_y);
	map->res_x = (map->res_x > map->screen_x) ? map->screen_x : map->res_x;
	map->res_y = (map->res_y > map->screen_y) ? map->screen_y : map->res_y;
	if (map->argc != 3)
		if ((map->mlx.win = mlx_new_window(map->mlx.mlx, map->res_x, map->res_y,
		"cub3d")) == NULL && ft_free(map->mlx.mlx) == NULL &&
		free_img_text(map) == 0)
			return (ft_error5(50));
	init_player(map);
	init_key(map);
	ft_cub3d2(map, -1, -1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0xb230
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x7d59
movq %rbx, %rdi
callq 0xaa60
cmpl $0x1, %eax
jne 0x7cb5
movq 0x80(%rbx), %rdi
callq 0xa39b
testq %rax, %rax
je 0x7d60
movq 0x80(%rbx), %rdi
leaq 0x180(%rbx), %rsi
leaq 0x184(%rbx), %rdx
callq 0xe680
movl 0x180(%rbx), %esi
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %ecx
cmpl %esi, %eax
cmovll %eax, %esi
movl %esi, 0x18(%rbx)
movl 0x184(%rbx), %edx
cmpl %edx, %ecx
cmovll %ecx, %edx
movl %edx, 0x1c(%rbx)
cmpl $0x3, 0x17c(%rbx)
je 0x7d36
movq 0x80(%rbx), %rdi
leaq 0x7340(%rip), %rcx      # 0xf048
callq 0xb540
movq %rax, 0x88(%rbx)
testq %rax, %rax
jne 0x7d36
movq 0x80(%rbx), %rdi
callq 0xa39b
testq %rax, %rax
jne 0x7d36
movq %rbx, %rdi
callq 0x75f4
testl %eax, %eax
je 0x7d6b
movq %rbx, %rdi
callq 0xa884
movq %rbx, %rdi
callq 0xa7f4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
popq %rbx
jmp 0x7b44
movl $0x30, %edi
jmp 0x7d65
movl $0x31, %edi
popq %rbx
jmp 0x8150
movl $0x32, %edi
jmp 0x7d65
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_draw_ceil_floor.c
// Function: ft_draw_ceil_floor
void	ft_draw_ceil_floor(t_map *map, int x)
{
	int	y;

	y = -1;
	while (++y < map->draw.draw_start)
		my_mlx_pixel_put(map->mlx.img, x, y, map->c_color);
	y = map->draw.draw_end - 1;
	while (++y <= map->res_y)
		my_mlx_pixel_put(map->mlx.img, x, y, map->f_color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x0, 0x138(%rdi)
jle 0x7e12
xorl %ebp, %ebp
movq 0x90(%r14), %rdi
movl 0x78(%r14), %ecx
movl %ebx, %esi
movl %ebp, %edx
callq 0xaf75
incl %ebp
cmpl 0x138(%r14), %ebp
jl 0x7df3
movl 0x13c(%r14), %r15d
cmpl 0x1c(%r14), %r15d
jg 0x7e41
movq 0x90(%r14), %rdi
movl 0x7c(%r14), %ecx
movl %ebx, %esi
movl %r15d, %edx
callq 0xaf75
leal 0x1(%r15), %eax
cmpl 0x1c(%r14), %r15d
movl %eax, %r15d
jl 0x7e1f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_draw_sprite.c
// Function: ft_draw_sprite
void	ft_draw_sprite(t_sprite *sprite, t_map *map)
{
	int	d;
	int	y;
	int	x;
	int	z;

	y = sprite->draw_start_y - 1;
	while (++y < sprite->draw_end_y)
	{
		d = (y) * 256 - map->res_y * 128 + sprite->sprite_height * 128;
		sprite->tex_y = ((d * 64) / sprite->sprite_height) / 256;
		x = sprite->draw_start_x;
		z = (sprite->tex_x * 4 + sprite->tex_y * map->size_line);
		if (z <= map->size_line * 63 && z >= 0 && (int)(map->data[z]))
		{
			map->mlx.img->data[(x * 4) + (map->mlx.img->size_line * y)] =
			map->data[z];
			map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 1] =
			map->data[z + 1];
			map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 2] =
			map->data[z + 2];
			map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 3] =
			map->data[z + 3];
		}
	}
}

// Assembly:
movl 0x48(%rdi), %ecx
movl 0x4c(%rdi), %r9d
cmpl %r9d, %ecx
jge 0x7f8d
pushq %rbx
movl %ecx, %r8d
shll $0xe, %r8d
movl 0x1c(%rsi), %edx
movl 0x44(%rdi), %r11d
movl 0x5c(%rdi), %r10d
movl %r11d, %eax
shll $0xd, %eax
shll $0xd, %edx
subl %edx, %eax
addl %r8d, %eax
cltd
idivl %r11d
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x8, %edx
movl %edx, 0x60(%rdi)
shll $0x2, %r10d
movl 0x168(%rsi), %eax
imull %eax, %edx
movl %eax, %r11d
shll $0x6, %r11d
subl %eax, %r11d
addl %r10d, %edx
sets %al
cmpl %r11d, %edx
setg %r10b
orb %al, %r10b
jne 0x7f7a
movq 0x160(%rsi), %r10
movl %edx, %eax
movb (%r10,%rax), %r10b
testb %r10b, %r10b
je 0x7f7a
movslq 0x54(%rdi), %rdx
movq 0x90(%rsi), %r9
movq 0x30(%r9), %r11
movslq 0x18(%r9), %rbx
movslq %ecx, %r9
imulq %r9, %rbx
leaq (%rbx,%rdx,4), %rbx
shlq $0x2, %rdx
movb %r10b, (%r11,%rbx)
movq 0x90(%rsi), %r10
movq 0x160(%rsi), %r11
movb 0x1(%r11,%rax), %r11b
movq 0x30(%r10), %rbx
movl 0x18(%r10), %r10d
imull %r9d, %r10d
addl %edx, %r10d
movslq %r10d, %r10
movb %r11b, 0x1(%rbx,%r10)
movq 0x90(%rsi), %r10
movq 0x160(%rsi), %r11
movb 0x2(%r11,%rax), %r11b
movq 0x30(%r10), %rbx
movl 0x18(%r10), %r10d
imull %r9d, %r10d
addl %edx, %r10d
movslq %r10d, %r10
movb %r11b, 0x2(%rbx,%r10)
movq 0x90(%rsi), %r10
movq 0x160(%rsi), %r11
movb 0x3(%r11,%rax), %al
movq 0x30(%r10), %r11
imull 0x18(%r10), %r9d
addl %edx, %r9d
movslq %r9d, %rdx
movb %al, 0x3(%r11,%rdx)
movl 0x4c(%rdi), %r9d
incl %ecx
addl $0x4000, %r8d           # imm = 0x4000
cmpl %r9d, %ecx
jl 0x7e64
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_draw_wall2.c
// Function: ft_draw_wall2
int	ft_draw_wall2(t_map *map, int x, int y, int z)
{
	map->mlx.img->data[(x * 4) + (map->mlx.img->size_line * y)] = map->data[z];
	map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 1] =
	map->data[z + 1];
	map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 2] =
	map->data[z + 2];
	map->mlx.img->data[((x * 4) + (map->mlx.img->size_line * y)) + 3] =
	map->data[z + 3];
	y++;
	return (y);
}

// Assembly:
movq 0x90(%rdi), %r8
movq 0x160(%rdi), %r9
movslq %ecx, %rax
movb (%r9,%rax), %cl
movq 0x30(%r8), %r9
movl 0x18(%r8), %r8d
imull %edx, %r8d
leal (%r8,%rsi,4), %r8d
movslq %r8d, %r8
movb %cl, (%r9,%r8)
movq 0x90(%rdi), %rcx
movq 0x160(%rdi), %r8
movb 0x1(%r8,%rax), %r8b
movq 0x30(%rcx), %r9
movl 0x18(%rcx), %ecx
imull %edx, %ecx
leal (%rcx,%rsi,4), %ecx
movslq %ecx, %rcx
movb %r8b, 0x1(%r9,%rcx)
movq 0x90(%rdi), %rcx
movq 0x160(%rdi), %r8
movb 0x2(%r8,%rax), %r8b
movq 0x30(%rcx), %r9
movl 0x18(%rcx), %ecx
imull %edx, %ecx
leal (%rcx,%rsi,4), %ecx
movslq %ecx, %rcx
movb %r8b, 0x2(%r9,%rcx)
movq 0x90(%rdi), %rcx
movq 0x160(%rdi), %rdi
movb 0x3(%rdi,%rax), %al
movq 0x30(%rcx), %rdi
movl 0x18(%rcx), %ecx
imull %edx, %ecx
leal (%rcx,%rsi,4), %ecx
movslq %ecx, %rcx
movb %al, 0x3(%rdi,%rcx)
leal 0x1(%rdx), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_draw_wall.c
// Function: ft_draw_wall
void	ft_draw_wall(t_map *map, int x, int div, int mod)
{
	int	y;
	int	y2;
	int	size_draw;
	int	line;
	int	z;

	y = map->draw.draw_start;
	y2 = map->draw.draw_end;
	size_draw = y2 - y;
	div = size_draw / map->text_height;
	mod = size_draw % map->text_height;
	z = map->point.tex_x * 4;
	line = (div == 0) ? -2 : -1;
	while (y <= y2)
	{
		while (++line < div)
			y = ft_draw_wall2(map, x, y, z);
		z += map->size_line;
		line = (--mod >= 0) ? -2 : -1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x138(%rdi), %ecx
movl 0x13c(%rdi), %r13d
movl %r13d, %eax
subl %ecx, %eax
cltd
idivl 0x24(%rdi)
movl %eax, (%rsp)
cmpl %ecx, %r13d
jl 0x80c8
movq %rdi, %rbx
movl %edx, %r15d
movl %esi, %r14d
movl (%rsp), %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
sbbl $0x0, %eax
movl 0x130(%rdi), %r12d
shll $0x2, %r12d
leal 0x1(%rax), %edx
cmpl (%rsp), %edx
jge 0x80ab
movl 0x4(%rsp), %ebp
subl %eax, %ebp
movq %rbx, %rdi
movl %r14d, %esi
movl %ecx, %edx
movl %r12d, %ecx
callq 0x7f90
movl %eax, %ecx
decl %ebp
jne 0x8095
addl 0x168(%rbx), %r12d
xorl %eax, %eax
testl %r15d, %r15d
leal -0x1(%r15), %edx
setg %al
notl %eax
movl %edx, %r15d
cmpl %r13d, %ecx
jle 0x8087
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_error5.c
// Function: ft_error5
void	ft_error5(int err)
{
	if (err == 48)
		ft_putstr("Error\nmlx_init n'a pas fonctionné fichier ft_cub3d\n");
	if (err == 49)
		ft_putstr("Error\nL'init d'une image a échoué fichier init_texture\n");
	if (err == 50)
		ft_putstr("Error\nmlx_new_window a échoué fichier ft_cub3d.h\n");
	if (err == 51)
	{
		ft_putstr("Error\nl'init de l'image de la fenêtre a échoué ");
		ft_putstr("fichier next_frame\n");
	}
	if (err == 52)
		ft_putstr("Error\n malloc de ft_list_push_front a échoué\n");
	if (err == 53)
		ft_putstr("Error\n le fichier n'a pas pus etre créé\n");
	if (err == 54)
		ft_putstr("Error\n le fichier n'a pas était bien fermé\n");
}

// Assembly:
addl $-0x30, %edi
cmpl $0x6, %edi
ja 0x81a9
leaq 0x7649(%rip), %rax      # 0xf7a8
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x7655(%rip), %rdi      # 0xf7c4
jmp 0x8eb8
leaq 0x7733(%rip), %rdi      # 0xf8ae
jmp 0x8eb8
leaq 0x76ac(%rip), %rdi      # 0xf833
jmp 0x8eb8
pushq %rax
leaq 0x76d3(%rip), %rdi      # 0xf867
callq 0x8eb8
leaq 0x76fa(%rip), %rdi      # 0xf89a
addq $0x8, %rsp
jmp 0x8eb8
retq
leaq 0x7648(%rip), %rdi      # 0xf7f9
jmp 0x8eb8
leaq 0x7721(%rip), %rdi      # 0xf8de
jmp 0x8eb8
leaq 0x7740(%rip), %rdi      # 0xf909
jmp 0x8eb8
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_exit.c
// Function: ft_exit
int	ft_exit(t_map *map)
{
	free_img_text(map);
	ft_sprite_clear(map->sprite);
	if (map->argc != 3)
		mlx_destroy_window(map->mlx.mlx, map->mlx.win);
	mlx_destroy_display(map->mlx.mlx);
	free(map->mlx.mlx);
	ft_check_malloc(map);
	exit(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x75f4
movq 0x158(%rbx), %rdi
callq 0x9f74
cmpl $0x3, 0x17c(%rbx)
je 0x8225
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
callq 0xe040
movq 0x80(%rbx), %rdi
callq 0xe6e0
movq 0x80(%rbx), %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x78a4
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_finnish_check_split.c
// Function: ft_finnish_check_split
int	ft_finnish_check_split(t_map *map)
{
	if (map->first_map == NULL || map->orientation == '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 (ft_error4(45) + 1);
	if ((map->map = ft_split2(map, '\n')) == NULL)
		return (ft_error4(46) + 1);
	if (ft_check_map2(map->map) == 1)
		return (ft_error4(47) + 1);
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2d, %edi
cmpq $0x0, 0x8(%rbx)
je 0x82cf
cmpb $0x30, 0x10(%rbx)
je 0x82cf
cmpl $0x0, 0x18(%rbx)
je 0x82cf
cmpl $0x0, 0x1c(%rbx)
je 0x82cf
cmpq $0x0, 0x50(%rbx)
je 0x82cf
cmpq $0x0, 0x58(%rbx)
je 0x82cf
cmpq $0x0, 0x60(%rbx)
je 0x82cf
cmpq $0x0, 0x68(%rbx)
je 0x82cf
cmpq $0x0, 0x70(%rbx)
je 0x82cf
cmpl $-0x1, 0x78(%rbx)
je 0x82cf
cmpl $-0x1, 0x7c(%rbx)
je 0x82cf
movq %rbx, %rdi
movl $0xa, %esi
callq 0x9dec
movq %rax, (%rbx)
testq %rax, %rax
je 0x82ca
movq %rax, %rdi
callq 0x7918
movl %eax, %ecx
xorl %eax, %eax
movl $0x2f, %edi
cmpl $0x1, %ecx
je 0x82cf
jmp 0x82d6
movl $0x2e, %edi
callq 0x8128
incl %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_free2.c
// Function: ft_free2
char	*ft_free2(char **tab, int max)
{
	int	i;

	i = -1;
	while (tab != NULL && tab[++i] != NULL && i < max)
	{
		if (tab[i] != NULL)
		{
			free(tab[i]);
			tab[i] = NULL;
		}
	}
	free(tab);
	tab = NULL;
	return (NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x831f
movq (%rbx), %rdi
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x831f
movslq %esi, %r14
movl $0x1, %r15d
callq 0x7180
movq $0x0, -0x8(%rbx,%r15,8)
cmpq %r14, %r15
jge 0x831f
movq (%rbx,%r15,8), %rdi
incq %r15
testq %rdi, %rdi
jne 0x8300
movq %rbx, %rdi
callq 0x7180
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_global_save.c
// Function: ft_global_save
void	ft_global_save(t_map *map)
{
	next_frame(map);
	ft_save(map);
	free_img_text(map);
	ft_sprite_clear(map->sprite);
	mlx_destroy_image(map->mlx.mlx, map->mlx.img);
	mlx_destroy_display(map->mlx.mlx);
	free(map->mlx.mlx);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xafc8
movq %rbx, %rdi
callq 0x9d10
movq %rbx, %rdi
callq 0x75f4
movq 0x158(%rbx), %rdi
callq 0x9f74
movq 0x80(%rbx), %rdi
movq 0x90(%rbx), %rsi
callq 0xe5f0
movq 0x80(%rbx), %rdi
callq 0xe6e0
movq 0x80(%rbx), %rdi
popq %rbx
jmp 0x7180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_init_ptr.c
// Function: ft_init_ptr
void	ft_init_ptr(int (**ptr)(t_map *map, char *line, int i))
{
	ptr[0] = ft_recup_resolution;
	ptr[1] = ft_recup_text_north;
	ptr[2] = ft_recup_text_south;
	ptr[3] = ft_recup_text_west;
	ptr[4] = ft_recup_text_east;
	ptr[5] = ft_recup_text_sprite;
	ptr[6] = ft_recup_f_color;
	ptr[7] = ft_recup_c_color;
	ptr[8] = ft_recup_line_map;
}

// Assembly:
leaq 0x1211(%rip), %rax      # 0x95b0
movq %rax, (%rdi)
leaq 0x1437(%rip), %rax      # 0x97e0
movq %rax, 0x8(%rdi)
leaq 0x1534(%rip), %rax      # 0x98e8
movq %rax, 0x10(%rdi)
leaq 0x1731(%rip), %rax      # 0x9af0
movq %rax, 0x18(%rdi)
leaq 0x1312(%rip), %rax      # 0x96dc
movq %rax, 0x20(%rdi)
leaq 0x1617(%rip), %rax      # 0x99ec
movq %rax, 0x28(%rdi)
leaq 0xf48(%rip), %rax       # 0x9328
movq %rax, 0x30(%rdi)
leaq 0xc9d(%rip), %rax       # 0x9088
movq %rax, 0x38(%rdi)
leaq 0x10e2(%rip), %rax      # 0x94d8
movq %rax, 0x40(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_list_push_front.c
// Function: ft_list_push_front
int	ft_list_push_front(t_sprite **sprite, int x, int y)
{
	t_sprite	*new_elem;

	new_elem = NULL;
	new_elem = ft_create_elem(x, y);
	if (new_elem == NULL)
		return (-1);
	new_elem->next = *sprite;
	*sprite = new_elem;
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, %edi
movl %edx, %esi
callq 0x7b08
testq %rax, %rax
je 0x841c
movq (%rbx), %rcx
movq %rcx, 0x68(%rax)
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x8421
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_modif_atoi.c
// Function: ft_modif_atoi
int	ft_modif_atoi(char *str)
{
	int	i;
	int	num;

	num = 0;
	i = -1;
	while (str[++i] == ' ')
		;
	--i;
	while (str[++i] > 47 && str[i] < 58)
	{
		num *= 10;
		num += (str[i] - 48);
		if (num * 10 > 2147483647)
			return (num);
	}
	return (num);
}

// Assembly:
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rdx      # imm = 0x100000000
movq %rdi, %rcx
addq %rdx, %rax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0x843b
sarq $0x20, %rax
movb (%rdi,%rax), %dl
leal -0x30(%rdx), %esi
xorl %eax, %eax
cmpb $0x9, %sil
ja 0x8475
xorl %eax, %eax
leal (%rax,%rax,4), %eax
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rax,2), %eax
movb (%rcx), %dl
leal -0x30(%rdx), %esi
incq %rcx
cmpb $0xa, %sil
jb 0x845b
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_modif_strcpy.c
// Function: ft_modif_strcpy
char	*ft_modif_strcpy(char *str)
{
	int		i;
	char	*str2;

	i = -1;
	while (str[++i] && str[i] != ' ')
		;
	if ((str2 = malloc(sizeof(char) * (i + 1))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i] && str[i] != ' ')
		str2[i] = str[i];
	str2[i] = '\0';
	return (str2);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rbx, %rcx
addq %rax, %rdi
movzbl (%rcx), %edx
incq %rcx
testb $-0x21, %dl
jne 0x848b
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x84be
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %edx
testb $-0x21, %dl
je 0x84ba
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x84a9
movb $0x0, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_modif_strdup.c
// Function: ft_modif_strdup
char	*ft_modif_strdup(char *str)
{
	char	*str2;
	int		i;

	i = -1;
	str2 = NULL;
	while (str[++i])
		;
	if ((str2 = malloc(sizeof(char) * (i + 2))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i])
		str2[i] = (str[i] == ' ') ? 49 : str[i];
	str2[i] = '\n';
	str2[++i] = '\0';
	return (str2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %rdi, %rax
movq %r14, %rdi
addq %r14, %rdi
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x84d7
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x8528
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
xorl %edx, %edx
movzbl (%rbx,%rdx), %esi
movb $0x31, %dil
cmpl $0x20, %esi
je 0x850f
testl %esi, %esi
je 0x851b
movl %esi, %edi
movb %dil, (%rax,%rdx)
addq %r14, %rcx
incq %rdx
jmp 0x84fd
movb $0xa, (%rax,%rdx)
sarq $0x20, %rcx
movb $0x0, 0x2(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_move2.c
// Function: ft_move2
void	ft_move2(t_map *map)
{
	if (map->key.key_s == 1)
	{
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x -
		map->player.dir_y * map->player.move_speed)] == '0')
			map->player.pos_x -= map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y + map->player.dir_x *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y += map->player.dir_x * map->player.move_speed;
	}
	if (map->key.key_d == 1)
	{
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x +
		map->player.dir_y * map->player.move_speed)] == '0')
			map->player.pos_x += map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y - map->player.dir_x *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y -= map->player.dir_x * map->player.move_speed;
	}
	ft_move3(map);
}

// Assembly:
cmpl $0x1, 0x148(%rdi)
jne 0x85b6
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm4
mulsd %xmm0, %xmm4
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
cvttsd2si %xmm3, %edx
movq (%rax,%rcx,8), %rsi
movslq %edx, %rcx
cmpb $0x30, (%rsi,%rcx)
jne 0x858a
movsd %xmm3, 0x98(%rdi)
jmp 0x8591
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0xa8(%rdi), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
cmpb $0x30, (%rax,%rcx)
jne 0x85b6
movsd %xmm0, 0xa0(%rdi)
cmpl $0x1, 0x14c(%rdi)
jne 0x8648
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm0
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm1
movsd 0xb0(%rdi), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
cvttsd2si %xmm3, %edx
movq (%rax,%rcx,8), %rsi
movslq %edx, %rcx
cmpb $0x30, (%rsi,%rcx)
jne 0x8610
movsd %xmm3, 0x98(%rdi)
jmp 0x8617
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0xa8(%rdi), %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
cmpb $0x30, (%rax,%rcx)
jne 0x8648
movsd %xmm0, 0xa0(%rdi)
jmp 0x8648
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_move3.c
// Function: ft_move3
void	ft_move3(t_map *map)
{
	double	old_dir_x;
	double	old_plane_x;

	if (map->key.key_right == 1)
	{
		old_dir_x = map->player.dir_x;
		map->player.dir_x = map->player.dir_x * cos(-map->player.rotate_speed) -
		map->player.dir_y * sin(-map->player.rotate_speed);
		map->player.dir_y = old_dir_x * sin(-map->player.rotate_speed) +
		map->player.dir_y * cos(-map->player.rotate_speed);
		old_plane_x = map->player.plane_x;
		map->player.plane_x = map->player.plane_x *
		cos(-map->player.rotate_speed) - map->player.plane_y *
		sin(-map->player.rotate_speed);
		map->player.plane_y = old_plane_x * sin(-map->player.rotate_speed) +
		map->player.plane_y * cos(-map->player.rotate_speed);
	}
	ft_move4(map);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x150(%rdi)
jne 0x87a9
movsd 0xa8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xa8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xb0(%rbx)
movsd 0xb8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xb8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xc0(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x87b8
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_move4.c
// Function: ft_move4
void	ft_move4(t_map *map)
{
	double	old_dir_x;
	double	old_plane_x;

	if (map->key.key_left == 1)
	{
		old_dir_x = map->player.dir_x;
		map->player.dir_x = map->player.dir_x * cos(map->player.rotate_speed) -
		map->player.dir_y * sin(map->player.rotate_speed);
		map->player.dir_y = old_dir_x * sin(map->player.rotate_speed) +
		map->player.dir_y * cos(map->player.rotate_speed);
		old_plane_x = map->player.plane_x;
		map->player.plane_x = map->player.plane_x *
		cos(map->player.rotate_speed) - map->player.plane_y *
		sin(map->player.rotate_speed);
		map->player.plane_y = old_plane_x * sin(map->player.rotate_speed) +
		map->player.plane_y * cos(map->player.rotate_speed);
	}
}

// Assembly:
cmpl $0x1, 0x154(%rdi)
jne 0x891e
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0xa8(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rdi), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0xa8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xb0(%rbx)
movsd 0xb8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0xb8(%rbx)
movsd 0xd0(%rbx), %xmm0
callq 0x7420
movsd %xmm0, 0x10(%rsp)
movsd 0xc0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd0(%rbx), %xmm0
callq 0x7130
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xc0(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_move.c
// Function: ft_move
void	ft_move(t_map *map)
{
	if (map->key.key_a == 1)
	{
		if (map->map[(int)(map->player.pos_y + (map->player.dir_y *
		map->player.move_speed) * 6)][(int)(map->player.pos_x)] == '0')
			map->player.pos_y += map->player.dir_y * map->player.move_speed;
		if (map->map[(int)(map->player.pos_y)][(int)(map->player.pos_x +
		(map->player.dir_x * map->player.move_speed) * 6)] == '0')
			map->player.pos_x += map->player.dir_x * map->player.move_speed;
	}
	if (map->key.key_w == 1)
	{
		if (map->map[(int)(map->player.pos_y - map->player.dir_y *
		map->player.move_speed)][(int)map->player.pos_x] == '0')
			map->player.pos_y -= map->player.dir_y * map->player.move_speed;
		if (map->map[(int)map->player.pos_y][(int)(map->player.pos_x -
		map->player.dir_x * map->player.move_speed)] == '0')
			map->player.pos_x -= map->player.dir_x * map->player.move_speed;
	}
	ft_move2(map);
}

// Assembly:
cmpl $0x1, 0x140(%rdi)
jne 0x89c4
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm3
mulsd %xmm0, %xmm3
movsd 0x725c(%rip), %xmm1     # 0xfbb0
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x8988
addsd %xmm3, %xmm2
movsd %xmm2, 0xa0(%rdi)
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0xa8(%rdi), %xmm0
movsd 0x7211(%rip), %xmm2     # 0xfbb0
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x89c4
addsd %xmm1, %xmm0
movsd %xmm0, 0x98(%rdi)
cmpl $0x1, 0x144(%rdi)
jne 0x8530
movq (%rdi), %rax
movsd 0xa0(%rdi), %xmm2
movsd 0xc8(%rdi), %xmm0
movsd 0xb0(%rdi), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
cvttsd2si %xmm3, %ecx
movslq %ecx, %rcx
movsd 0x98(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rsi
movslq %edx, %rdx
cmpb $0x30, (%rsi,%rdx)
jne 0x8a22
movsd %xmm3, 0xa0(%rdi)
jmp 0x8a29
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0xa8(%rdi), %xmm0
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x8530
movsd %xmm1, 0x98(%rdi)
jmp 0x8530
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_point2.c
// Function: ft_point2
void	ft_point2(t_map *map)
{
	if (map->ray.ray_dir_x < 0)
	{
		map->point.step_x = -1;
		map->point.side_dist_x = (map->player.pos_x - map->point.map_x) *
		map->point.delta_dist_x;
	}
	else
	{
		map->point.step_x = 1;
		map->point.side_dist_x = (map->point.map_x + 1.0 - map->player.pos_x) *
		map->point.delta_dist_x;
	}
	if (map->ray.ray_dir_y < 0)
	{
		map->point.step_y = -1;
		map->point.side_dist_y = (map->player.pos_y - map->point.map_y) *
		map->point.delta_dist_y;
	}
	else
	{
		map->point.step_y = 1;
		map->point.side_dist_y = (map->point.map_y + 1.0 - map->player.pos_y) *
		map->point.delta_dist_y;
	}
}

// Assembly:
xorpd %xmm0, %xmm0
ucomisd 0xe0(%rdi), %xmm0
jbe 0x8a81
movsd 0x98(%rdi), %xmm0
cvtsi2sdl 0xf0(%rdi), %xmm1
subsd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8aa1
xorps %xmm0, %xmm0
cvtsi2sdl 0xf0(%rdi), %xmm0
addsd 0x7124(%rip), %xmm0     # 0xfbb8
subsd 0x98(%rdi), %xmm0
movl $0x1, %eax
mulsd 0x108(%rdi), %xmm0
movl %eax, 0x120(%rdi)
movsd %xmm0, 0xf8(%rdi)
xorpd %xmm0, %xmm0
ucomisd 0xe8(%rdi), %xmm0
jbe 0x8ae3
movsd 0xa0(%rdi), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0xf4(%rdi), %xmm1
subsd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x8b03
xorps %xmm0, %xmm0
cvtsi2sdl 0xf4(%rdi), %xmm0
addsd 0x70c2(%rip), %xmm0     # 0xfbb8
subsd 0xa0(%rdi), %xmm0
movl $0x1, %eax
mulsd 0x110(%rdi), %xmm0
movl %eax, 0x124(%rdi)
movsd %xmm0, 0x100(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_point.c
// Function: ft_point
void	ft_point(t_map *map, int x)
{
	map->ray.camera_x = (2 * x) / (double)map->res_y - 1;
	map->ray.ray_dir_x = map->player.dir_x + map->player.plane_x *
	map->ray.camera_x;
	map->ray.ray_dir_y = map->player.dir_y + map->player.plane_y *
	map->ray.camera_x;
	map->point.map_x = (int)map->player.pos_x;
	map->point.map_y = (int)map->player.pos_y;
	if (map->ray.ray_dir_y == 0)
		map->point.delta_dist_x = 0;
	else
		map->point.delta_dist_x = (map->ray.ray_dir_x == 0) ? 1 : sqrt(1 +
		(map->ray.ray_dir_y * map->ray.ray_dir_y) / (map->ray.ray_dir_x *
		map->ray.ray_dir_x));
	if (map->ray.ray_dir_x == 0)
		map->point.delta_dist_y = 0;
	else
		map->point.delta_dist_y = (map->ray.ray_dir_y == 0) ? 1 : sqrt(1 +
		(map->ray.ray_dir_x * map->ray.ray_dir_x) / (map->ray.ray_dir_y *
		map->ray.ray_dir_y));
	map->point.hit = 0;
	ft_point2(map);
}

// Assembly:
addl %esi, %esi
cvtsi2sd %esi, %xmm0
cvtsi2sdl 0x1c(%rdi), %xmm1
divsd %xmm1, %xmm0
addsd 0x708d(%rip), %xmm0     # 0xfbc0
movsd %xmm0, 0xd8(%rdi)
movupd 0x98(%rdi), %xmm1
movupd 0xa8(%rdi), %xmm2
movupd 0xb8(%rdi), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, 0xe0(%rdi)
cvttpd2dq %xmm1, %xmm1
movlpd %xmm1, 0xf0(%rdi)
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x8ba4
jp 0x8ba4
movq $0x0, 0x108(%rdi)
ucomisd %xmm1, %xmm0
jne 0x8b9a
jnp 0x8c0c
movsd 0x7016(%rip), %xmm1     # 0xfbb8
jmp 0x8c0c
ucomisd %xmm1, %xmm0
jne 0x8bb6
jp 0x8bb6
movsd 0x7004(%rip), %xmm1     # 0xfbb8
jmp 0x8bd9
movapd %xmm0, %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
divsd %xmm1, %xmm2
addsd 0x6fe6(%rip), %xmm2     # 0xfbb8
xorps %xmm1, %xmm1
sqrtsd %xmm2, %xmm1
movsd %xmm1, 0x108(%rdi)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8bed
jnp 0x8c0c
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
divsd %xmm1, %xmm0
addsd 0x6fb3(%rip), %xmm0     # 0xfbb8
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
movsd %xmm1, 0x110(%rdi)
movl $0x0, 0x128(%rdi)
jmp 0x8a58
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_point_sprite.c
// Function: ft_point_sprite
void	ft_point_sprite(t_sprite *sprite, t_map *map)
{
	sprite->sprite_x = sprite->pos_x - map->player.pos_x;
	sprite->sprite_y = sprite->pos_y - map->player.pos_y;
	sprite->inv_det = 1.0 / (map->player.plane_x * map->player.dir_y -
	map->player.dir_x * map->player.plane_y);
	sprite->transform_x = sprite->inv_det * (map->player.dir_y *
	sprite->sprite_x - map->player.dir_x * sprite->sprite_y);
	sprite->transform_y = sprite->inv_det * (-map->player.plane_y *
	sprite->sprite_x + map->player.plane_x * sprite->sprite_y);
	sprite->sprite_screen_x = (int)((map->res_y / 2) * (1 + sprite->transform_x
	/ sprite->transform_y));
	sprite->sprite_height = (map->res_x >= map->res_y) ? (int)(map->res_x /
	(sprite->transform_y)) : (int)(map->res_y / (sprite->transform_y));
	sprite->sprite_height *= (sprite->sprite_height < 0) ? -1 : 1;
	sprite->draw_start_y = -sprite->sprite_height / 2 + map->res_y / 2;
	sprite->draw_start_y *= (sprite->draw_start_y < 0) ? 0 : 1;
	sprite->draw_end_y = sprite->sprite_height / 2 + map->res_y / 2;
	if (sprite->draw_end_y >= map->res_y)
		sprite->draw_end_y = map->res_y - 1;
	ft_point_sprite2(sprite, map);
}

// Assembly:
movupd 0x8(%rdi), %xmm0
movupd 0x98(%rsi), %xmm1
subpd %xmm1, %xmm0
movupd %xmm0, 0x18(%rdi)
movsd 0xb8(%rsi), %xmm3
movsd 0xa8(%rsi), %xmm4
movsd 0xb0(%rsi), %xmm5
movsd 0xc0(%rsi), %xmm6
movapd 0x6f2e(%rip), %xmm7     # 0xfbd0
movapd %xmm6, %xmm1
mulsd %xmm4, %xmm1
xorpd %xmm7, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulsd %xmm5, %xmm3
subsd %xmm1, %xmm3
movsd 0x6ef6(%rip), %xmm2     # 0xfbb8
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x28(%rdi)
xorpd %xmm7, %xmm6
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
mulpd %xmm4, %xmm3
unpcklpd %xmm6, %xmm5            # xmm5 = xmm5[0],xmm6[0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm5, %xmm0
addpd %xmm3, %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
movupd %xmm1, 0x30(%rdi)
movl 0x1c(%rsi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
divsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movl %edx, 0x40(%rdi)
movl 0x18(%rsi), %edx
cmpl %eax, %edx
cmovlel %eax, %edx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
divsd %xmm3, %xmm0
cvttsd2si %xmm0, %edx
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movl %r8d, 0x44(%rdi)
shrl %r8d
movl %ecx, %edx
subl %r8d, %edx
xorl %r9d, %r9d
testl %edx, %edx
cmovgl %edx, %r9d
addl %ecx, %r8d
leal -0x1(%rax), %ecx
cmpl %eax, %r8d
cmovll %r8d, %ecx
movl %r9d, 0x48(%rdi)
movl %ecx, 0x4c(%rdi)
jmp 0x8c24
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_point_wall2.c
// Function: ft_point_wall2
void	ft_point_wall2(t_map *map)
{
	double	wall_x;
	int		tex_x;

	if (map->point.side == 0)
		wall_x = map->player.pos_y + map->point.perp_wall_dist *
		map->ray.ray_dir_y;
	else
		wall_x = map->player.pos_x + map->point.perp_wall_dist *
		map->ray.ray_dir_x;
	wall_x -= floor((wall_x));
	tex_x = (int)(wall_x * (double)(map->text_width));
	if (map->point.side == 0 && map->ray.ray_dir_x > 0)
		tex_x = map->text_width - tex_x - 1;
	if (map->point.side == 1 && map->ray.ray_dir_y < 0)
		tex_x = map->text_width - tex_x - 1;
	map->point.tex_x = tex_x;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x12c(%rdi), %ebp
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movsd 0x118(%rdi), %xmm0
mulsd 0xe0(%rdi,%rax,8), %xmm0
addsd 0x98(%rdi,%rax,8), %xmm0
movsd %xmm0, (%rsp)
callq 0x7380
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movl 0x20(%rbx), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
testl %ebp, %ebp
je 0x8de7
cmpl $0x1, %ebp
jne 0x8dfd
xorpd %xmm0, %xmm0
ucomisd 0xe8(%rbx), %xmm0
ja 0x8df9
jmp 0x8dfd
movsd 0xe0(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8dfd
notl %eax
addl %ecx, %eax
movl %eax, 0x130(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_put_in_tab.c
// Function: ft_put_in_tab
char	*ft_put_in_tab(char *str, char c)
{
	int		i;
	int		max;
	char	*str2;

	i = -1;
	while (str[++i] != c)
		;
	max = i;
	if ((str2 = malloc(sizeof(char) * (max + 1))) == NULL)
		return (NULL);
	i = -1;
	while (str[++i] != c)
		str2[i] = str[i];
	str2[i] = '\0';
	return (str2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %r14, %rcx
addq %rax, %rdi
leaq 0x1(%rcx), %rdx
cmpb %bl, (%rcx)
movq %rdx, %rcx
jne 0x8e78
sarq $0x20, %rdi
callq 0x7100
testq %rax, %rax
je 0x8eae
movb (%r14), %dl
xorl %ecx, %ecx
cmpb %bl, %dl
je 0x8eaa
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
jmp 0x8e99
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_putstr.c
// Function: ft_putstr
void	ft_putstr(char *str)
{
	int	i;

	i = -1;
	if (str == NULL)
		return ;
	while (str[++i])
		write(1, &str[i], 1);
}

// Assembly:
testq %rdi, %rdi
je 0x8ee3
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x8ee2
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x73d0
cmpb $0x0, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
jne 0x8ec6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_raycasting.c
// Function: ft_raycasting
void	ft_raycasting(t_map *map)
{
	int		x;
	double	z_buffer[map->res_x];

	x = -1;
	while (++x < map->res_x)
	{
		ft_point(map, x);
		ft_wall_hit(map);
		ft_distance(map);
		ft_point_wall(map);
		ft_point_wall2(map);
		ft_stock_data(map);
		ft_draw_wall(map, x, 0, 0);
		ft_draw_ceil_floor(map, x);
		z_buffer[x] = map->point.perp_wall_dist;
	}
	if (map->nbr_sprites > 0)
		ft_sprite(map, z_buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
movq %rsp, %r14
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
testl %eax, %eax
jle 0x8f77
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8b1c
movq %rbx, %rdi
callq 0xa0dc
movq %rbx, %rdi
callq 0x7d74
movq %rbx, %rdi
callq 0x8e0c
movq %rbx, %rdi
callq 0x8d7c
movq %rbx, %rdi
callq 0xa024
movq %rbx, %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8038
movq %rbx, %rdi
movl %r15d, %esi
callq 0x7ddc
movsd 0x118(%rbx), %xmm0
movsd %xmm0, (%r14,%r15,8)
incq %r15
movslq 0x18(%rbx), %rax
cmpq %rax, %r15
jl 0x8f10
cmpl $0x0, 0x178(%rbx)
jle 0x8f8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9e8c
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_recup_c_color2.c
// Function: ft_recup_c_color2
int	ft_recup_c_color2(t_map *map, t_color color, char *line, int i)
{
	if (line[i] != '\0' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	if ((color.t != 0 || color.r > 255 || color.g > 255 || color.b > 255) &&
		ft_free(line) == NULL)
		return (ft_error4(36) + 1);
	if ((color.t != 0 || color.r < 0 || color.g < 0 || color.b < 0) &&
		ft_free(line) == NULL)
		return (ft_error4(37) + 1);
	map->c_color = (color.t << 24 | color.r << 16 | color.g << 8 | color.b);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq %r8d, %rax
cmpb $0x0, (%rcx,%rax)
je 0x8fc9
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x905a
movq %r15, %r13
shrq $0x20, %r13
movq %rbx, %rbp
shrq $0x20, %rbp
testl %r15d, %r15d
setne %al
movl $0x100, %ecx            # imm = 0x100
cmpl %ecx, %r13d
setge %dl
cmpl %ecx, %ebx
setge %sil
orb %dl, %sil
cmpl %ecx, %ebp
setge %cl
orb %al, %cl
orb %sil, %cl
cmpb $0x1, %cl
jne 0x900d
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x9066
testl %r15d, %r15d
setne %al
testq %r15, %r15
sets %cl
movabsq $-0x7fffffff80000000, %rdx # imm = 0x8000000080000000
testq %rdx, %rbx
setne %dl
orb %al, %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x903f
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x906d
shll $0x18, %r15d
shll $0x10, %r13d
shll $0x8, %ebx
orl %r15d, %ebx
orl %r13d, %ebx
orl %ebp, %ebx
movl %ebx, 0x78(%r14)
xorl %eax, %eax
jmp 0x9079
movl $0x23, %edi
callq 0x8100
jmp 0x9077
movl $0x24, %edi
jmp 0x9072
movl $0x25, %edi
callq 0x8128
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_recup_c_color.c
// Function: ft_recup_c_color
int	ft_recup_c_color(t_map *map, char *line, int i)
{
	t_color	color;

	color = ft_init_color();
	if (map->c_color != -1 && ft_free(line) == NULL)
		return (ft_error4(38) + 1);
	while (line[++i] && line[i] == ' ')
		;
	while (line[++i] && line[i] == ' ')
		;
	color.r = ft_modif_atoi(line + i);
	while (line[i] > 47 && line[i] < 58)
		i++;
	if (line[i++] != ',' && ft_free(line) == NULL)
		return (ft_error4(39) + 1);
	color.g = ft_modif_atoi(line + i);
	while (line[i] > 47 && line[i] < 58)
		i++;
	if (line[i++] != ',' && ft_free(line) == NULL)
		return (ft_error4(39) + 1);
	color.b = (line[i] > 47 && line[i] < 58) ? ft_modif_atoi(line + i) : -1;
	while (line[i] > 47 && line[i] < 58)
		i++;
	while (line[i] && line[i] == ' ')
		i++;
	return (ft_recup_c_color2(map, color, line, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8384
movq %rax, %r13
cmpl $-0x1, 0x78(%r15)
je 0x90bb
movq %r14, %rdi
callq 0xa39b
testq %rax, %rax
je 0x921c
movq %r15, (%rsp)
movslq %ebx, %rax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%r14), %rdi
decq %rdi
addq %r14, %rax
incq %rax
incq %rdi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x90d5
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r12      # imm = 0x100000000
leal 0x1(%rbx), %eax
movslq %eax, %rbp
leaq (%r14,%rbp), %r15
decq %r15
shlq $0x20, %rbp
addq %rcx, %rbp
incq %r15
addq %r12, %rbp
incl %ebx
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x910b
callq 0x8424
movl %eax, %edx
movl %r13d, %r13d
movb (%r15), %al
leal -0x30(%rax), %ecx
incl %ebx
addq %r12, %rbp
incq %r15
cmpb $0xa, %cl
jb 0x9127
cmpb $0x2c, %al
je 0x9155
movq %r14, %rdi
movq %rdx, %r15
callq 0xa39b
movq %r15, %rdx
testq %rax, %rax
je 0x9215
shlq $0x20, %rdx
orq %r13, %rdx
movq %rdx, %r13
sarq $0x20, %rbp
addq %r14, %rbp
movq %rbp, %rdi
callq 0x8424
movl %eax, %ebp
movslq %ebx, %r15
leaq (%r14,%r15), %rax
shlq $0x20, %r15
movb (%rax), %cl
leal -0x30(%rcx), %edx
incl %ebx
addq %r12, %r15
incq %rax
cmpb $0xa, %dl
jb 0x917b
cmpb $0x2c, %cl
je 0x919f
movq %r14, %rdi
callq 0xa39b
testq %rax, %rax
je 0x9215
movl %ebp, %r12d
sarq $0x20, %r15
movb (%r14,%r15), %al
addb $-0x30, %al
cmpb $0x9, %al
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
ja 0x91cb
addq %r14, %r15
movq %r15, %rdi
callq 0x8424
movl %eax, %edx
shlq $0x20, %rdx
movslq %ebx, %rax
addl $-0x2, %ebx
addq %r14, %rax
decq %rax
movb 0x1(%rax), %cl
incq %rax
addb $-0x30, %cl
incl %ebx
cmpb $0xa, %cl
jb 0x91d7
movq (%rsp), %rdi
movq %r13, %rsi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x91ee
orq %r12, %rdx
movq %r14, %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8f98
movl $0x27, %edi
jmp 0x9221
movl $0x26, %edi
callq 0x8128
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_recup_f_color2.c
// Function: ft_recup_f_color2
int	ft_recup_f_color2(t_map *map, t_color color, char *line, int i)
{
	if (line[i] != '\0' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	if ((color.t != 0 || color.r > 255 || color.g > 255 || color.b > 255) &&
		ft_free(line) == NULL)
		return (ft_error4(36) + 1);
	if ((color.t != 0 || color.r < 0 || color.g < 0 || color.b < 0) &&
		ft_free(line) == NULL)
		return (ft_error4(37) + 1);
	map->f_color = (color.t << 24 | color.r << 16 | color.g << 8 | color.b);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq %r8d, %rax
cmpb $0x0, (%rcx,%rax)
je 0x9269
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x92fa
movq %r15, %r13
shrq $0x20, %r13
movq %rbx, %rbp
shrq $0x20, %rbp
testl %r15d, %r15d
setne %al
movl $0x100, %ecx            # imm = 0x100
cmpl %ecx, %r13d
setge %dl
cmpl %ecx, %ebx
setge %sil
orb %dl, %sil
cmpl %ecx, %ebp
setge %cl
orb %al, %cl
orb %sil, %cl
cmpb $0x1, %cl
jne 0x92ad
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x9306
testl %r15d, %r15d
setne %al
testq %r15, %r15
sets %cl
movabsq $-0x7fffffff80000000, %rdx # imm = 0x8000000080000000
testq %rdx, %rbx
setne %dl
orb %al, %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x92df
movq %r12, %rdi
callq 0xa39b
testq %rax, %rax
je 0x930d
shll $0x18, %r15d
shll $0x10, %r13d
shll $0x8, %ebx
orl %r15d, %ebx
orl %r13d, %ebx
orl %ebp, %ebx
movl %ebx, 0x7c(%r14)
xorl %eax, %eax
jmp 0x9319
movl $0x23, %edi
callq 0x8100
jmp 0x9317
movl $0x24, %edi
jmp 0x9312
movl $0x25, %edi
callq 0x8128
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_recup_f_color.c
// Function: ft_recup_f_color
int	ft_recup_f_color(t_map *map, char *line, int i)
{
	t_color	color;

	color = ft_init_color();
	if (map->f_color != -1 && ft_free(line) == NULL)
		return (ft_error3(34) + 1);
	while (line[++i] && line[i] == ' ')
		;
	while (line[++i] && line[i] == ' ')
		;
	color.r = ft_modif_atoi(line + i);
	while (line[i] > 47 && line[i] < 58)
		i++;
	if (line[i++] != ',' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	color.g = ft_modif_atoi(line + i);
	while (line[i] > 47 && line[i] < 58)
		i++;
	if (line[i++] != ',' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	color.b = (line[i] > 47 && line[i] < 58) ? ft_modif_atoi(line + i) : -1;
	while (line[i] > 47 && line[i] < 58)
		i++;
	while (line[i] && line[i] == ' ')
		i++;
	return (ft_recup_f_color2(map, color, line, i));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8384
movq %rax, %r13
cmpl $-0x1, 0x7c(%r15)
je 0x935b
movq %r14, %rdi
callq 0xa39b
testq %rax, %rax
je 0x94bc
movq %r15, (%rsp)
movslq %ebx, %rax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%r14), %rdi
decq %rdi
addq %r14, %rax
incq %rax
incq %rdi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x9375
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r12      # imm = 0x100000000
leal 0x1(%rbx), %eax
movslq %eax, %rbp
leaq (%r14,%rbp), %r15
decq %r15
shlq $0x20, %rbp
addq %rcx, %rbp
incq %r15
addq %r12, %rbp
incl %ebx
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x93ab
callq 0x8424
movl %eax, %edx
movl %r13d, %r13d
movb (%r15), %al
leal -0x30(%rax), %ecx
incl %ebx
addq %r12, %rbp
incq %r15
cmpb $0xa, %cl
jb 0x93c7
cmpb $0x2c, %al
je 0x93f5
movq %r14, %rdi
movq %rdx, %r15
callq 0xa39b
movq %r15, %rdx
testq %rax, %rax
je 0x94b5
shlq $0x20, %rdx
orq %r13, %rdx
movq %rdx, %r13
sarq $0x20, %rbp
addq %r14, %rbp
movq %rbp, %rdi
callq 0x8424
movl %eax, %ebp
movslq %ebx, %r15
leaq (%r14,%r15), %rax
shlq $0x20, %r15
movb (%rax), %cl
leal -0x30(%rcx), %edx
incl %ebx
addq %r12, %r15
incq %rax
cmpb $0xa, %dl
jb 0x941b
cmpb $0x2c, %cl
je 0x943f
movq %r14, %rdi
callq 0xa39b
testq %rax, %rax
je 0x94b5
movl %ebp, %r12d
sarq $0x20, %r15
movb (%r14,%r15), %al
addb $-0x30, %al
cmpb $0x9, %al
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
ja 0x946b
addq %r14, %r15
movq %r15, %rdi
callq 0x8424
movl %eax, %edx
shlq $0x20, %rdx
movslq %ebx, %rax
addl $-0x2, %ebx
addq %r14, %rax
decq %rax
movb 0x1(%rax), %cl
incq %rax
addb $-0x30, %cl
incl %ebx
cmpb $0xa, %cl
jb 0x9477
movq (%rsp), %rdi
movq %r13, %rsi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x948e
orq %r12, %rdx
movq %r14, %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9238
movl $0x23, %edi
jmp 0x94c1
movl $0x22, %edi
callq 0x8100
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/raphifou15[P]cub3d/src/ft_recup_line_map.c
// Function: ft_recup_line_map
int	ft_recup_line_map(t_map *map, char *line, int i)
{
	char	*line2;

	line2 = NULL;
	line2 = ft_modif_strdup(line);
	while (line2[++i])
		;
	if (line2[i - 2] != '1' && ft_free(line2) == NULL && ft_free(line) == NULL)
		return (ft_error4(41) + 1);
	if (ft_check_line_map1(line2, map) == 1 && ft_free(line) == NULL)
		return (1);
	if (map->first_map == NULL)
		map->first_map = line2;
	else
	{
		map->first_map = ft_strjoin(map->first_map, line2);
		ft_free(line2);
	}
	map->line_map++;
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x84c0
movq %rax, %r14
movslq %ebp, %rdx
leaq (%rdx,%rax), %rcx
incq %rcx
shlq $0x20, %rdx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rdx, %rax
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rdx, %rax
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x9517
sarq $0x20, %rax
cmpb $0x31, -0x1(%r14,%rax)
je 0x9549
movq %r14, %rdi
callq 0xa39b
testq %rax, %rax
jne 0x9549
movq %r15, %rdi
callq 0xa39b
testq %rax, %rax
je 0x95a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x77a4
cmpl $0x1, %eax
jne 0x9566
movq %r15, %rdi
callq 0xa39b
testq %rax, %rax
je 0x9599
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9585
movq %r14, %rsi
callq 0xa67c
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xa39b
jmp 0x9589
movq %r14, 0x8(%rbx)
incl 0x14(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x958e
movl $0x29, %edi
callq 0x8128
incl %eax
jmp 0x958e
nop