LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_south
int			check_twice_south(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_south != -1)
	{
		put_color(RED, "\nError\n south's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x44(%rdi)
jne 0x6ab9
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x6e82
pushq %rax
leaq 0x754b(%rip), %rdi      # 0xe00c
leaq 0x771d(%rip), %rsi      # 0xe1e5
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_east
int			check_twice_east(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_east != -1)
	{
		put_color(RED, "\nError\n east's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x4c(%rdi)
jne 0x6ae9
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x6e82
pushq %rax
leaq 0x751b(%rip), %rdi      # 0xe00c
leaq 0x7712(%rip), %rsi      # 0xe20a
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_west
int			check_twice_west(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_west != -1)
	{
		put_color(RED, "\nError\n west's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x48(%rdi)
jne 0x6b19
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x6e82
pushq %rax
leaq 0x74eb(%rip), %rdi      # 0xe00c
leaq 0x7706(%rip), %rsi      # 0xe22e
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice.c
// Function: check_twice_sprite
int			check_twice_sprite(t_args *args, char *line, int e)
{
	int		i;

	if (args->error_sprite != -1)
	{
		put_color(RED, "\nError\n sprite's texture has two path");
		exit(0);
	}
	i = find_i(line, e, 2);
	return (i);
}

// Assembly:
cmpl $-0x1, 0x50(%rdi)
jne 0x6b49
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
jmp 0x6e82
pushq %rax
leaq 0x74bb(%rip), %rdi      # 0xe00c
leaq 0x76fa(%rip), %rsi      # 0xe252
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice_color.c
// Function: check_twice_color_f
void		check_twice_color_f(t_args *args)
{
	if (args->color_floor_r != -1 || args->color_floor_b != -1 ||
	args->color_floor_g != -1)
	{
		put_color(RED, "\nError\n floor's color is filled twice");
		exit(0);
	}
}

// Assembly:
cmpl $-0x1, 0x54(%rdi)
jne 0x6b77
cmpl $-0x1, 0x5c(%rdi)
jne 0x6b77
cmpl $-0x1, 0x58(%rdi)
jne 0x6b77
retq
pushq %rax
leaq 0x748d(%rip), %rdi      # 0xe00c
leaq 0x76f2(%rip), %rsi      # 0xe278
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/check_twice_color.c
// Function: check_twice_color_c
void		check_twice_color_c(t_args *args)
{
	if (args->color_ceiling_r != -1 || args->color_ceiling_b != -1 ||
	args->color_ceiling_g != -1)
	{
		put_color(RED, "\nError\n ceiling's color is filled twice");
		exit(0);
	}
}

// Assembly:
cmpl $-0x1, 0x60(%rdi)
jne 0x6ba5
cmpl $-0x1, 0x68(%rdi)
jne 0x6ba5
cmpl $-0x1, 0x64(%rdi)
jne 0x6ba5
retq
pushq %rax
leaq 0x745f(%rip), %rdi      # 0xe00c
leaq 0x76ea(%rip), %rsi      # 0xe29e
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_file_header
void		create_file_header(t_img_coord *co, int fd)
{
	int		w;
	int		h;
	int		file_size;
	int		data_start;

	w = co->argi.reso_x;
	h = co->argi.reso_y;
	file_size = w * h * 4 + 54;
	data_start = 14 + 40;
	write(fd, "BM", 2);
	write(fd, &file_size, 4);
	write(fd, "\0\0\0\0", 4);
	write(fd, &data_start, 4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl 0x140(%rdi), %eax
imull 0x144(%rdi), %eax
leal 0x36(,%rax,4), %eax
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
movq %rsp, %r15
movl $0x36, (%r15)
leaq 0x76cf(%rip), %rsi      # 0xe2c6
pushq $0x2
popq %rdx
movl %ebx, %edi
callq 0x63b0
pushq $0x4
popq %r12
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x63b0
leaq 0x76ea(%rip), %rsi      # 0xe303
movl %ebx, %edi
movq %r12, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x63b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_header_1
void		create_info_header_1(t_img_coord *co, int fd)
{
	int		size_header;
	int		w;
	int		h;
	short	plane;
	short	bpp;

	plane = 1;
	w = co->argi.reso_x;
	h = co->argi.reso_y;
	size_header = 40;
	bpp = co->img->bits_per_pixel;
	write(fd, &size_header, 4);
	write(fd, &w, 4);
	write(fd, &h, 4);
	write(fd, &plane, 2);
	write(fd, &bpp, 2);
	write(fd, "\0\0\0\0", 4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
leaq 0xa(%rsp), %r14
movw $0x1, (%r14)
movl 0x140(%rdi), %eax
leaq 0x10(%rsp), %r12
movl %eax, (%r12)
movl 0x144(%rdi), %eax
leaq 0xc(%rsp), %r13
movl %eax, (%r13)
leaq 0x14(%rsp), %rsi
movl $0x28, (%rsi)
movq 0x130(%rdi), %rax
movzwl 0x10(%rax), %eax
leaq 0x8(%rsp), %rbp
movw %ax, (%rbp)
pushq $0x4
popq %r15
movl %ebx, %edi
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x63b0
pushq $0x2
popq %r12
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x63b0
movl %ebx, %edi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x63b0
leaq 0x7622(%rip), %rsi      # 0xe303
movl %ebx, %edi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63b0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_header_2
void		create_info_header_2(int fd, t_img_coord *co)
{
	int		img_size;
	int		color;
	int		w;
	int		h;

	h = co->argi.reso_y - 1;
	w = co->argi.reso_x;
	img_size = w * h * 4;
	color = 0;
	write(fd, &img_size, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
	write(fd, &color, 4);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl 0x144(%rsi), %eax
leal -0x4(,%rax,4), %eax
imull 0x140(%rsi), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x8(%rsp), %r14
andl $0x0, (%r14)
pushq $0x4
popq %r15
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63b0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x63b0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_info_image
void		create_info_image(t_img_coord *co, int fd)
{
	int		w;
	int		h;
	int		y;
	int		r;
	int		x;

	w = co->argi.reso_x;
	h = co->argi.reso_y;
	y = h - 1;
	r = 0x00ffffff;
	while (y >= 0)
	{
		x = 0;
		while (x < w)
		{
			r = (*(int*)(co->img->addr + (y * co->img->line_length + (x * 4))));
			write(fd, &r, 4);
			x++;
		}
		y--;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl 0x140(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, 0x8(%rsp)
movl 0x144(%rdi), %eax
leal -0x1(%rax), %ebp
pushq $0x4
popq %r12
testl %eax, %eax
jle 0x6df7
decl %eax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movl 0x8(%rsp), %r15d
subl $0x1, %r15d
jb 0x6dee
movq 0x130(%r14), %rax
movq 0x8(%rax), %rcx
movl 0x14(%rax), %eax
imull %ebp, %eax
addl %r13d, %eax
cltq
movl (%rcx,%rax), %eax
movl %eax, 0xc(%rsp)
movl %ebx, %edi
leaq 0xc(%rsp), %rsi
movq %r12, %rdx
callq 0x63b0
addl $0x4, %r13d
jmp 0x6db6
decl %ebp
movq 0x10(%rsp), %rax
jmp 0x6da3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/create_bitmap.c
// Function: create_bmp
void		create_bmp(t_img_coord *co)
{
	char	*titre;
	int		fd;

	titre = "first_image.bmp";
	put_color("\033[038;5:212m", "\nSAVE under first_image.bmp\n");
	fd = open(titre, O_CREAT | O_WRONLY, 00700);
	create_file_header(co, fd);
	create_info_header_1(co, fd);
	create_info_header_2(fd, co);
	create_info_image(co, fd);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x74c6(%rip), %rdi      # 0xe2d9
leaq 0x74cc(%rip), %rsi      # 0xe2e6
callq 0xa7d4
leaq 0x74a3(%rip), %rdi      # 0xe2c9
pushq $0x41
popq %rsi
movl $0x1c0, %edx            # imm = 0x1C0
xorl %eax, %eax
callq 0x63f0
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x6bc0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6c3c
movl %ebp, %edi
movq %rbx, %rsi
callq 0x6cf9
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6d72
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/general.c
// Function: ft_check
int			ft_check(t_args *args)
{
	if (args->reso_x == -1 || args->reso_y == -1 || args->text_sprite == NULL ||
	args->color_floor_r == -1 || args->color_floor_b == -1 ||
	args->color_floor_g == -1 || args->color_ceiling_r == -1 ||
	args->color_ceiling_b == -1 || args->color_ceiling_g == -1)
	{
		return (1);
	}
	else
	{
		return (0);
	}
	return (0);
}

// Assembly:
pushq $0x1
popq %rax
cmpl $-0x1, 0x8(%rdi)
je 0x6f65
cmpl $-0x1, 0xc(%rdi)
je 0x6f65
cmpq $0x0, 0x38(%rdi)
je 0x6f65
cmpl $-0x1, 0x54(%rdi)
je 0x6f65
cmpl $-0x1, 0x5c(%rdi)
je 0x6f65
cmpl $-0x1, 0x58(%rdi)
je 0x6f65
cmpl $-0x1, 0x60(%rdi)
je 0x6f65
cmpl $-0x1, 0x68(%rdi)
je 0x6f65
xorl %eax, %eax
cmpl $-0x1, 0x64(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/general.c
// Function: verif_args
void		verif_args(t_args *args)
{
	if (args->reso_y == -1 || args->reso_x == -1)
	{
		put_color(RED, "\nError\n wrong format for resolution or missing");
		exit(0);
	}
	if (args->text_sprite == NULL)
	{
		put_color(RED, "\nError\n missing path for sprite");
		exit(0);
	}
	if (args->color_ceiling_r == -1 || args->color_ceiling_b == -1 ||
	args->color_ceiling_g == -1)
	{
		put_color(RED, "\nError\n wrong format for color or missing");
		exit(0);
	}
	if (args->color_floor_r == -1 || args->color_floor_b == -1 ||
	args->color_floor_g == -1)
	{
		put_color(RED, "\nError\n wrong format for color or missing");
		exit(0);
	}
	verif_texture(args);
}

// Assembly:
pushq %rax
cmpl $-0x1, 0xc(%rdi)
je 0x6fb4
cmpl $-0x1, 0x8(%rdi)
je 0x6fb4
cmpq $0x0, 0x38(%rdi)
je 0x6fc4
cmpl $-0x1, 0x60(%rdi)
je 0x6fa4
cmpl $-0x1, 0x68(%rdi)
je 0x6fa4
cmpl $-0x1, 0x64(%rdi)
je 0x6fa4
cmpl $-0x1, 0x54(%rdi)
je 0x6fa4
cmpl $-0x1, 0x5c(%rdi)
je 0x6fa4
cmpl $-0x1, 0x58(%rdi)
je 0x6fa4
popq %rax
jmp 0x6eb5
leaq 0x7061(%rip), %rdi      # 0xe00c
leaq 0x73e7(%rip), %rsi      # 0xe399
jmp 0x6fd2
leaq 0x7051(%rip), %rdi      # 0xe00c
leaq 0x7388(%rip), %rsi      # 0xe34a
jmp 0x6fd2
leaq 0x7041(%rip), %rdi      # 0xe00c
leaq 0x73a7(%rip), %rsi      # 0xe379
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/general.c
// Function: empty
t_args		empty(t_args args, int fd, char *line)
{
	int i;

	verif_args(&args);
	if (ft_empty_line(line) == 1)
	{
		put_color(RED, "\nError\n something is wrong ");
		free(line);
		exit(0);
	}
	free(line);
	while ((i = get_next_line(fd, &line)) == 1 && ft_empty_line(line) == 0)
	{
		args.ready_count++;
		free(line);
		line = NULL;
	}
	free(line);
	return (args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %rdx, (%rsp)
movq %r14, %rdi
callq 0x6f66
movq %r15, %rdi
callq 0xa25c
cmpl $0x1, %eax
je 0x706d
movq %r15, %rdi
callq 0x6170
movq %rsp, %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0xa4cd
cmpl $0x1, %eax
jne 0x7046
movq (%rsp), %rdi
callq 0xa25c
testl %eax, %eax
jne 0x7046
incl 0x7c(%r14)
movq (%rsp), %rdi
callq 0x6170
andq $0x0, (%rsp)
jmp 0x7016
movq (%rsp), %rdi
callq 0x6170
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f98(%rip), %rdi      # 0xe00c
leaq 0x7348(%rip), %rsi      # 0xe3c3
callq 0xa7d4
movq %r15, %rdi
callq 0x6170
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/general.c
// Function: parse_cub
t_args		parse_cub(t_args args)
{
	int		fd;
	char	*line;
	int		i;

	args = create_t_args(args);
	i = 1;
	fd = valid_file(args);
	while ((i = get_next_line(fd, &line)) == 1 && ft_check(&args) == 1)
	{
		args = ft_parse_arg(line, args);
		args.ready_count++;
		free(line);
	}
	args = empty(args, fd, line);
	while ((i = get_next_line(fd, &line)) > 0 && ft_check(&args) == 0)
	{
		args.ready_s = ft_compare(ft_strlen(line), args.ready_s);
		args.ready_j++;
		free(line);
	}
	free(line);
	args.ready_j += 2;
	close(fd);
	return (args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x150(%rsp), %r14
pushq $0x11
popq %r15
movq %r15, %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x8943
movl $0x88, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x63e0
movq %r15, %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x688b
movl %eax, %ebp
leaq 0x88(%rsp), %r13
movl %ebp, %edi
movq %r13, %rsi
callq 0xa4cd
cmpl $0x1, %eax
jne 0x7153
movq %r14, %rdi
callq 0x6f28
testl %eax, %eax
je 0x7153
movq 0x88(%rsp), %rax
movq %r15, %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movq %rax, %rsi
callq 0x8aa0
movl $0x88, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x63e0
incl 0x7c(%r14)
movq 0x88(%rsp), %rdi
callq 0x6170
jmp 0x70f6
leaq 0x88(%rsp), %r15
movq (%r15), %rdx
pushq $0x11
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0x6fde
movl $0x88, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x63e0
movl %ebp, %edi
movq %r15, %rsi
callq 0xa4cd
testl %eax, %eax
jle 0x71d5
movq %r14, %rdi
callq 0x6f28
testl %eax, %eax
jne 0x71d5
movq 0x88(%rsp), %rdi
callq 0xa588
movl 0x78(%r14), %esi
movl %eax, %edi
callq 0xa254
movl %eax, 0x78(%r14)
incl 0x74(%r14)
movq 0x88(%rsp), %rdi
callq 0x6170
jmp 0x718c
movq 0x88(%rsp), %rdi
callq 0x6170
addl $0x2, 0x74(%r14)
movl %ebp, %edi
callq 0x6040
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e0
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/general.c
// Function: main
int			main(int argc, char **argv)
{
	t_map	mapy;
	t_args	argy;

	argy.save = 0;
	if (argc > 0)
		put_color("\033[36m", "\nHello\n");
	if (argc == 1)
	{
		put_color(RED, "\nError\n too few arguments");
		exit(0);
	}
	argy = check_args(argy, argc, argv);
	argy = parse_cub(argy);
	if (ft_check(&argy) == 0 && argy.ready_j > 0)
		mapy = ft_parse_map(argy.ready_j, argy.ready_s, argy.ready_count,
		argy.cub_file);
	if (ft_check(&argy) == 0 && argy.ready_j > 0)
		ft_graph(argy, mapy);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %r14
movl %edi, %ebp
andl $0x0, 0x11c(%rsp)
testl %edi, %edi
jle 0x724f
leaq 0x71a5(%rip), %rdi      # 0xe3df
leaq 0x71a4(%rip), %rsi      # 0xe3e5
callq 0xa7d4
cmpl $0x1, %ebp
je 0x736e
pushq $0x11
popq %r15
leaq 0xb0(%rsp), %rbx
movq %r15, %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x138(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x67ef
movl $0x88, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x63e0
movq %r15, %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x138(%rsp), %r14
movq %r14, %rdi
callq 0x708f
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63e0
movq %rbx, %rdi
callq 0x6f28
testl %eax, %eax
sete %al
movl 0x74(%rbx), %ebx
testl %ebx, %ebx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7300
movl 0x128(%rsp), %edx
movl 0x12c(%rsp), %ecx
movq 0xc0(%rsp), %r8
leaq 0x138(%rsp), %rdi
movl %ebx, %esi
callq 0x8fcf
movl 0x124(%rsp), %ebx
leaq 0xb0(%rsp), %rdi
callq 0x6f28
testl %eax, %eax
jne 0x735b
testl %ebx, %ebx
jle 0x735b
pushq $0x11
popq %rcx
leaq 0xb0(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq 0x158(%rsp), %rax
movq %rax, 0xa8(%rsp)
movups 0x138(%rsp), %xmm0
movups 0x148(%rsp), %xmm1
movups %xmm1, 0x98(%rsp)
movups %xmm0, 0x88(%rsp)
callq 0x74ad
pushq $0x1
popq %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6c97(%rip), %rdi      # 0xe00c
leaq 0x7071(%rip), %rsi      # 0xe3ed
callq 0xa7d4
xorl %edi, %edi
callq 0x60a0
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/graph.c
// Function: my_loop
int				my_loop(t_img_coord *co)
{
	if (co->key->w)
		move_forward(co);
	if (co->key->s)
		move_backward(co);
	if (co->key->a)
		move_left(co);
	if (co->key->d)
		move_right(co);
	if (co->key->ro_left)
		rotate_left(co);
	if (co->key->ro_right)
		rotate_right(co);
	manage_3d(co);
	mlx_do_sync(co->mlx.mlx);
	return (0);
}

// Assembly:
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %rbx
movq 0xd8(%rdi), %rax
cmpl $0x0, (%rax)
je 0x73db
movq %rbx, %rdi
callq 0x86b8
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x4(%rax)
je 0x73f0
movq %rbx, %rdi
callq 0x8750
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x7405
movq %rbx, %rdi
callq 0x887a
movq 0xd8(%rbx), %rax
cmpl $0x0, 0xc(%rax)
je 0x741a
movq %rbx, %rdi
callq 0x87e5
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x14(%rax)
je 0x742f
movq %rbx, %rdi
callq 0x9a32
movq 0xd8(%rbx), %rax
cmpl $0x0, 0x10(%rax)
je 0x743d
movq %rbx, %rdi
callq 0x99d4
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9ad8
movq 0x110(%rbx), %rdi
callq 0xce90
xorl %eax, %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/graph.c
// Function: init_img
t_img			*init_img(t_mlx_coord xco, t_args argy)
{
	t_img		*img;

	if (!(img = malloc(sizeof(t_img))))
		return (NULL);
	img->img = mlx_new_image(xco.mlx, argy.reso_x, argy.reso_y);
	img->addr = mlx_get_data_addr(img->img, &img->bits_per_pixel,
	&img->line_length, &img->endian);
	return (img);
}

// Assembly:
pushq %rbx
pushq $0x28
popq %rdi
callq 0x6100
movq %rax, %rbx
testq %rax, %rax
je 0x74a8
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
callq 0xb3c0
movq %rax, (%rbx)
leaq 0x10(%rbx), %rsi
leaq 0x14(%rbx), %rdx
movq %rbx, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xb640
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: free_texture
void	free_texture(t_img_coord *co)
{
	int i;

	i = 0;
	while (i < 4)
	{
		if (co->text[i]->error == 1)
		{
			mlx_destroy_image(co->text[i]->mlx, co->text[i]->img);
			free(co->text[i]);
		}
		i++;
	}
	free(co->argi.cub_file);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x7780
movq 0xf0(%rbx,%r14,8), %rax
cmpl $0x1, 0x50(%rax)
jne 0x777b
movq (%rax), %rdi
movq 0x28(%rax), %rsi
callq 0xcea0
movq 0xf0(%rbx,%r14,8), %rdi
callq 0x6170
incq %r14
jmp 0x774e
movq 0x148(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6170
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: handle_exit
void	handle_exit(t_img_coord *co)
{
	int i;

	i = 0;
	mlx_destroy_image(co->text_sp->mlx, co->text_sp->img);
	free(co->text_sp);
	free(co->calc);
	free(co->buf_sprit);
	free(co->key);
	free_texture(co);
	while (i < co->mapi.height_map + 1)
	{
		free(co->mapi.mapp[i]);
		i++;
	}
	free(co->mapi.mapp);
	free(co->argi.text_sprite);
	free(co->mapi.sprite);
	free(co->argi.text_west);
	free(co->argi.text_north);
	free(co->argi.text_east);
	free(co->argi.text_south);
	mlx_destroy_image(co->mlx.mlx, co->img->img);
	if (co->argi.save == 0)
		mlx_destroy_window(co->mlx.mlx, co->mlx.mlx_win);
	free(co->img);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
movq (%rax), %rdi
movq 0x28(%rax), %rsi
callq 0xcea0
movq 0xe0(%rbx), %rdi
callq 0x6170
movq 0xe8(%rbx), %rdi
callq 0x6170
movq 0xc0(%rbx), %rdi
callq 0x6170
movq 0xd8(%rbx), %rdi
callq 0x6170
movq %rbx, %rdi
callq 0x7744
xorl %r14d, %r14d
movslq 0x1cc(%rbx), %rax
movq 0x1c0(%rbx), %rdi
cmpq %rax, %r14
jg 0x7809
movq (%rdi,%r14,8), %rdi
callq 0x6170
incq %r14
jmp 0x77e8
callq 0x6170
movq 0x170(%rbx), %rdi
callq 0x6170
movq 0x1e0(%rbx), %rdi
callq 0x6170
movq 0x160(%rbx), %rdi
callq 0x6170
movq 0x150(%rbx), %rdi
callq 0x6170
movq 0x168(%rbx), %rdi
callq 0x6170
movq 0x158(%rbx), %rdi
callq 0x6170
movq 0x110(%rbx), %rdi
movq 0x130(%rbx), %rax
movq (%rax), %rsi
callq 0xcea0
cmpl $0x0, 0x1a4(%rbx)
jne 0x7888
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
callq 0xc8f0
movq 0x130(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6170
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: key_pressed
int		key_pressed(int keycode, t_img_coord *co)
{
	if (keycode == 'w')
		co->key->w = 1;
	if (keycode == 's')
		co->key->s = 1;
	if (keycode == 'd')
		co->key->a = 1;
	if (keycode == 'a')
		co->key->d = 1;
	if (keycode == 65363)
		co->key->ro_left = 1;
	if (keycode == 65361)
		co->key->ro_right = 1;
	if (keycode == 65307)
	{
		stop_all(co);
	}
	return (1);
}

// Assembly:
cmpl $0x61, %edi
je 0x792d
cmpl $0x64, %edi
je 0x7920
cmpl $0x73, %edi
je 0x78f0
cmpl $0x77, %edi
je 0x78fd
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x7906
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x7913
cmpl $0xff1b, %edi           # imm = 0xFF1B
jne 0x793e
pushq %rax
movq %rsi, %rdi
callq 0x789b
movq 0xd8(%rsi), %rax
addq $0x4, %rax
jmp 0x7938
movq 0xd8(%rsi), %rax
jmp 0x7938
movq 0xd8(%rsi), %rax
addq $0x10, %rax
jmp 0x7938
movq 0xd8(%rsi), %rax
addq $0x14, %rax
jmp 0x7938
movq 0xd8(%rsi), %rax
addq $0x8, %rax
jmp 0x7938
movq 0xd8(%rsi), %rax
addq $0xc, %rax
movl $0x1, (%rax)
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/handle_key.c
// Function: key_released
int		key_released(int keycode, t_img_coord *co)
{
	if (keycode == 'w')
		co->key->w = 0;
	if (keycode == 's')
		co->key->s = 0;
	if (keycode == 'd')
		co->key->a = 0;
	if (keycode == 'a')
		co->key->d = 0;
	if (keycode == 65363)
		co->key->ro_left = 0;
	if (keycode == 65361)
		co->key->ro_right = 0;
	return (1);
}

// Assembly:
cmpl $0x61, %edi
je 0x79a3
cmpl $0x64, %edi
je 0x7996
cmpl $0x73, %edi
je 0x796f
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x7989
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x797c
cmpl $0x77, %edi
jne 0x79b1
movq 0xd8(%rsi), %rax
jmp 0x79ae
movq 0xd8(%rsi), %rax
addq $0x4, %rax
jmp 0x79ae
movq 0xd8(%rsi), %rax
addq $0x10, %rax
jmp 0x79ae
movq 0xd8(%rsi), %rax
addq $0x14, %rax
jmp 0x79ae
movq 0xd8(%rsi), %rax
addq $0x8, %rax
jmp 0x79ae
movq 0xd8(%rsi), %rax
addq $0xc, %rax
andl $0x0, (%rax)
pushq $0x1
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/init_position.c
// Function: init_position
t_img_coord		init_position(t_img_coord co)
{
	if (co.mapi.position_direction == 'N')
		co = position_north(co);
	if (co.mapi.position_direction == 'S')
		co = position_south(co);
	if (co.mapi.position_direction == 'W')
		co = position_west(co);
	if (co.mapi.position_direction == 'E')
		co = position_east(co);
	return (co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
movb 0x1d8(%rsi), %al
cmpb $0x4e, %al
jne 0x7b85
xorps %xmm0, %xmm0
movhps 0x68b9(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x10(%rsi)
movsd 0x68b5(%rip), %xmm0     # 0xe430
movups %xmm0, 0x20(%rsi)
movb 0x1d8(%rsi), %al
cmpb $0x53, %al
jne 0x7ba9
xorps %xmm0, %xmm0
movhps 0x6885(%rip), %xmm0     # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x10(%rsi)
movsd 0x6881(%rip), %xmm0     # 0xe420
movups %xmm0, 0x20(%rsi)
movb 0x1d8(%rsi), %al
movabsq $0x3fe51eb851eb851f, %rcx # imm = 0x3FE51EB851EB851F
cmpb $0x57, %al
jne 0x7bd6
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x10(%rsi)
movq %rcx, 0x28(%rsi)
movb 0x1d8(%rsi), %al
cmpb $0x45, %al
jne 0x7bf3
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsi)
movq %rcx, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x63e0
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite.c
// Function: sprite_cast_1
void			sprite_cast_1(t_img_coord *co)
{
	t_sprite	sprite;
	int			i;

	i = 0;
	if (!(co->sprite_order = malloc(sizeof(int) * co->mapi.number_sprite)))
		return ;
	if (!(co->spr_dist = malloc(sizeof(double) * co->mapi.number_sprite)))
		return ;
	while (i < co->mapi.number_sprite)
	{
		sprite = co->mapi.sprite[i];
		co->sprite_order[i] = i;
		co->spr_dist[i] = ((co->posx - sprite.x) * (co->posx - sprite.x) +
		(co->posy - sprite.y) * (co->posy - sprite.y));
		i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x1dc(%rdi), %r15
leaq (,%r15,4), %rdi
callq 0x6100
movq %rax, 0xc8(%rbx)
testq %rax, %rax
je 0x7c97
movq %rax, %r14
leaq (,%r15,8), %rdi
callq 0x6100
movq %rax, 0xd0(%rbx)
testq %rax, %rax
je 0x7c97
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
cmpq %rcx, %r15
je 0x7c97
movq 0x1e0(%rbx), %rdx
cvtsi2sdl (%rdx,%rcx,8), %xmm0
cvtsi2sdl 0x4(%rdx,%rcx,8), %xmm1
movl %ecx, (%r14,%rcx,4)
movsd (%rbx), %xmm2
subsd %xmm0, %xmm2
movsd 0x8(%rbx), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rax,%rcx,8)
incq %rcx
jmp 0x7c55
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite.c
// Function: tri_sprite
void			tri_sprite(t_img_coord *co)
{
	int			i;
	int			j;
	int			t;
	double		p;

	i = 0;
	while (i < (co->mapi.number_sprite))
	{
		j = i + 1;
		while (j < co->mapi.number_sprite)
		{
			if (co->spr_dist[i] < co->spr_dist[j])
			{
				p = co->spr_dist[i];
				co->spr_dist[i] = co->spr_dist[j];
				co->spr_dist[j] = p;
				t = co->sprite_order[i];
				co->sprite_order[i] = co->sprite_order[j];
				co->sprite_order[j] = t;
			}
			j++;
		}
		i++;
	}
	i = 0;
}

// Assembly:
movl 0x1dc(%rdi), %edx
pushq $0x1
popq %rax
xorl %ecx, %ecx
movslq %edx, %rsi
cmpq %rsi, %rcx
jge 0x7d06
movq %rax, %rsi
cmpl %esi, %edx
jle 0x7cfe
movq 0xd0(%rdi), %r8
movsd (%r8,%rcx,8), %xmm0
movsd (%r8,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7cf9
movsd %xmm1, (%r8,%rcx,8)
movsd %xmm0, (%r8,%rsi,8)
movq 0xc8(%rdi), %rdx
movl (%rdx,%rcx,4), %r8d
movl (%rdx,%rsi,4), %r9d
movl %r9d, (%rdx,%rcx,4)
movl %r8d, (%rdx,%rsi,4)
movl 0x1dc(%rdi), %edx
incq %rsi
jmp 0x7cb3
incq %rcx
incq %rax
jmp 0x7ca8
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite.c
// Function: sprite_cast_2
void			sprite_cast_2(t_img_coord *co, int i)
{
	co->calc->sprite_x = co->mapi.sprite[co->sprite_order[i]].x -
	co->posx + 0.5;
	co->calc->sprite_y = co->mapi.sprite[co->sprite_order[i]].y -
	co->posy + 0.5;
	co->calc->invdet = 1.0 / (co->planex * co->diry - co->dirx * co->planey);
	co->calc->transformx = co->calc->invdet * (co->diry *
	co->calc->sprite_x - co->dirx * co->calc->sprite_y);
	co->calc->transformy = co->calc->invdet * (-co->planey *
	co->calc->sprite_x + co->planex * co->calc->sprite_y);
	co->calc->scren_x = (int)((co->argi.reso_x / 2) *
	(1 + co->calc->transformx / co->calc->transformy));
}

// Assembly:
movq 0x1e0(%rdi), %rax
movq 0xc8(%rdi), %rcx
movslq %esi, %rdx
movslq (%rcx,%rdx,4), %rcx
cvtdq2pd (%rax,%rcx,8), %xmm0
movupd (%rdi), %xmm1
subpd %xmm1, %xmm0
addpd 0x670f(%rip), %xmm0     # 0xe440
movq 0xe8(%rdi), %rcx
movupd %xmm0, (%rcx)
movsd 0x20(%rdi), %xmm3
movsd 0x10(%rdi), %xmm4
movsd 0x18(%rdi), %xmm5
movsd 0x28(%rdi), %xmm6
movapd 0x66f8(%rip), %xmm7     # 0xe450
movapd %xmm6, %xmm1
mulsd %xmm4, %xmm1
xorpd %xmm7, %xmm4
unpcklpd %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0]
mulsd %xmm5, %xmm3
subsd %xmm1, %xmm3
movsd 0x66a0(%rip), %xmm2     # 0xe418
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd %xmm1, 0x10(%rcx)
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, 0x18(%rcx)
movl 0x140(%rdi), %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
cvtsi2sd %eax, %xmm0
movapd %xmm1, %xmm3
unpckhpd %xmm1, %xmm3            # xmm3 = xmm3[1],xmm1[1]
divsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x28(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite.c
// Function: sprite_cast_3
void			sprite_cast_3(t_img_coord *co)
{
	co->calc->height = abs((int)(co->argi.reso_y / (co->calc->transformy))) / 1;
	co->calc->drawstarty = -co->calc->height / 2 + co->argi.reso_y / 2;
	if (co->calc->drawstarty < 0)
		co->calc->drawstarty = 0;
	co->calc->drawendy = co->calc->height / 2 + co->argi.reso_y / 2;
	if (co->calc->drawendy >= co->argi.reso_y)
		co->calc->drawendy = co->argi.reso_y - 1;
}

// Assembly:
movl 0x144(%rdi), %ecx
cvtsi2sd %ecx, %xmm0
movq 0xe8(%rdi), %rsi
divsd 0x20(%rsi), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
movl %edi, 0x2c(%rsi)
shrl %edi
pushq $0x2
popq %r8
movl %ecx, %eax
cltd
idivl %r8d
movl %eax, %edx
subl %edi, %edx
xorl %r8d, %r8d
testl %edx, %edx
cmovgl %edx, %r8d
movl %r8d, 0x34(%rsi)
addl %eax, %edi
leal -0x1(%rcx), %eax
cmpl %ecx, %edi
cmovll %edi, %eax
movl %eax, 0x38(%rsi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite_two.c
// Function: draw
void	draw(t_img_coord *co, int texx, int stripe, int texy)
{
	int y;
	int color;
	int d;
	int movescreen;

	d = 0;
	color = 0;
	movescreen = 0.0 / co->calc->transformy;
	y = co->calc->drawstarty;
	while (y < co->calc->drawendy)
	{
		d = (y - movescreen) * 256 - co->argi.reso_y * 128 +
		co->calc->height * 128;
		texy = ((d * co->text_sp->height) / co->calc->height) / 256;
		if (texy >= 0)
		{
			color = color_sprite(co, texx, texy);
			if ((color & 0X00FFFFFF) != 0)
				my_mlx_pixel_put(co->img, stripe, y, color);
		}
		y++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0xe8(%rdi), %rdi
xorpd %xmm0, %xmm0
divsd 0x20(%rdi), %xmm0
cvttsd2si %xmm0, %eax
movl 0x34(%rdi), %ebp
movslq %esi, %r15
shlq $0x2, %r15
movl %ebp, %r12d
shll $0x8, %r12d
shll $0x8, %eax
subl %eax, %r12d
movl $0x100, %r13d           # imm = 0x100
cmpl 0x38(%rdi), %ebp
jge 0x7f52
movl 0x144(%r14), %ecx
shll $0x7, %ecx
movl 0x2c(%rdi), %esi
movl %esi, %eax
shll $0x7, %eax
subl %ecx, %eax
addl %r12d, %eax
movq 0xe0(%r14), %rcx
imull 0x34(%rcx), %eax
cltd
idivl %esi
cmpl $0xffffff01, %eax       # imm = 0xFFFFFF01
jl 0x7f47
cltd
idivl %r13d
movq 0x20(%rcx), %rdx
addq %r15, %rdx
movslq 0x14(%rcx), %rcx
cltq
imulq %rcx, %rax
movl (%rax,%rdx), %ecx
testl $0xffffff, %ecx         # imm = 0xFFFFFF
je 0x7f47
movq 0x130(%r14), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x7388
movq 0xe8(%r14), %rdi
incl %ebp
addl $0x100, %r12d           # imm = 0x100
jmp 0x7edf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite_two.c
// Function: draw_sprite
void	draw_sprite(t_img_coord *co, int i)
{
	int stripe;
	int texx;
	int texy;
	int movescreen;

	texy = 0;
	texy = 0;
	movescreen = 0.0 / co->calc->transformy;
	i = 5;
	stripe = co->calc->drawstartx;
	while (stripe < co->calc->drawendx)
	{
		texx = (int)(256 * (stripe - (-co->calc->width / 2 +
		co->calc->scren_x)) * co->text_sp->width / co->calc->width) / 256;
		if (co->calc->transformy > 0 && stripe > 0 &&
		stripe < co->argi.reso_x &&
		co->calc->transformy < (co->buf_sprit[stripe]))
		{
			draw(co, texx, stripe, texy);
		}
		stripe++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8(%rdi), %rsi
movl 0x3c(%rsi), %ebp
pushq $0x2
popq %r14
movl $0x100, %r15d           # imm = 0x100
xorpd %xmm2, %xmm2
cmpl 0x40(%rsi), %ebp
jge 0x7ff1
movl 0x30(%rsi), %ecx
movl %ecx, %eax
cltd
idivl %r14d
subl 0x28(%rsi), %eax
addl %ebp, %eax
movq 0xe0(%rbx), %rdx
imull 0x30(%rdx), %eax
shll $0x8, %eax
cltd
idivl %ecx
cltd
idivl %r15d
testl %ebp, %ebp
jle 0x7fed
movsd 0x20(%rsi), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x7fed
cmpl 0x140(%rbx), %ebp
jge 0x7fed
movq 0xc0(%rbx), %rcx
movl %ebp, %edx
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7fed
movq %rbx, %rdi
movl %eax, %esi
movl %ebp, %edx
callq 0x7e9e
xorpd %xmm2, %xmm2
movq 0xe8(%rbx), %rsi
incl %ebp
jmp 0x7f83
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_sprite_two.c
// Function: sprite_cast
void	sprite_cast(t_img_coord *co)
{
	int i;

	i = 0;
	sprite_cast_1(co);
	tri_sprite(co);
	while (i < co->mapi.number_sprite)
	{
		sprite_cast_2(co, i);
		sprite_cast_3(co);
		sprite_cast_4(co);
		draw_sprite(co, i);
		i++;
	}
	free(co->sprite_order);
	free(co->spr_dist);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7c08
movq %rbx, %rdi
callq 0x7c9d
xorl %ebp, %ebp
cmpl 0x1dc(%rbx), %ebp
jge 0x803f
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7d07
movq %rbx, %rdi
callq 0x7dde
movq %rbx, %rdi
callq 0x7e30
movq %rbx, %rdi
callq 0x7f61
incl %ebp
jmp 0x8011
movq 0xc8(%rbx), %rdi
callq 0x6170
movq 0xd0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_texture.c
// Function: load_textures
t_img_coord	*load_textures(t_img_coord *co)
{
	char	*path;
	t_text	*text;

	while (co->count < 4)
	{
		text = malloc(sizeof(t_text));
		if (texture_valid(co, co->count) == 1)
		{
			path = which_texture(co->count, co);
			text->mlx = co->mlx.mlx;
			text->error = 1;
			if (!(text->img = mlx_xpm_file_to_image(text->mlx, path,
			&text->width, &text->height)))
				text->error = 0;
			if (text->error == 1 && !(text->addr = mlx_get_data_addr(text->img,
			&text->bpp, &text->line_length, &text->endian)))
				text->error = 0;
		}
		else
			text->error = 0;
		error_check(text->error);
		co->text[co->count] = text;
		co->count++;
	}
	return (co);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xb8(%rdi), %ebp
pushq $0x58
popq %r14
cmpl $0x3, %ebp
jg 0x8142
movq %r14, %rdi
callq 0x6100
movq %rax, %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9a90
cmpl $0x1, %eax
jne 0x8119
movl 0xb8(%rbx), %edi
movq %rbx, %rsi
callq 0x8060
movq 0x110(%rbx), %rdi
movq %rdi, (%r15)
movl $0x1, 0x50(%r15)
leaq 0x30(%r15), %rdx
leaq 0x34(%r15), %rcx
movq %rax, %rsi
callq 0xc540
movq %rax, 0x28(%r15)
testq %rax, %rax
je 0x8119
movl 0x50(%r15), %edi
cmpl $0x1, %edi
jne 0x8120
leaq 0x10(%r15), %rsi
leaq 0x14(%r15), %rdx
movq %r15, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xb640
movq %rax, 0x20(%r15)
testq %rax, %rax
je 0x8119
movl 0x50(%r15), %edi
jmp 0x8120
andl $0x0, 0x50(%r15)
xorl %edi, %edi
callq 0x6f06
movslq 0xb8(%rbx), %rax
movq %r15, 0xf0(%rbx,%rax,8)
leal 0x1(%rax), %ebp
movl %ebp, 0xb8(%rbx)
jmp 0x808e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_texture.c
// Function: which_color
int			which_color(t_img_coord *co)
{
	if (co->hori_verti == 0)
	{
		if (co->raydirx > 0)
			return (0x00FAB8DE);
		else
			return (0x006AD9FF);
	}
	if (co->hori_verti == 1)
	{
		if (co->raydiry < 0)
			return (0x00BAB3FA);
		else
			return (0x00F0DA99);
	}
	return (0x0054145E);
}

// Assembly:
movl 0x94(%rdi), %ecx
cmpl $0x1, %ecx
je 0x81b5
movl $0x54145e, %eax         # imm = 0x54145E
testl %ecx, %ecx
jne 0x81cb
movsd 0x40(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0xfab8de, %ecx         # imm = 0xFAB8DE
movl $0x6ad9ff, %eax         # imm = 0x6AD9FF
jmp 0x81c8
xorpd %xmm0, %xmm0
ucomisd 0x48(%rdi), %xmm0
movl $0xbab3fa, %ecx         # imm = 0xBAB3FA
movl $0xf0da99, %eax         # imm = 0xF0DA99
cmoval %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_texture.c
// Function: draw_texture
void		draw_texture(t_img_coord *co)
{
	int		texy;
	int		i;
	int		color;

	i = which_wall(co);
	if (co->text[i]->error == 1)
	{
		texy = (int)co->text[i]->tex_pos & (co->text[i]->height - 1);
		co->text[i]->tex_pos += co->text[i]->step;
		color = (*(int*)(co->text[i]->addr +
		(4 * co->text[i]->texx) + (4 * co->text[i]->width * texy)));
	}
	else
		color = which_color(co);
	my_mlx_pixel_put(co->img, co->x, co->i, color);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8150
movl %eax, %eax
movq 0xf0(%rbx,%rax,8), %rax
cmpl $0x1, 0x50(%rax)
jne 0x821a
movsd 0x48(%rax), %xmm0
cvttsd2si %xmm0, %ecx
movl 0x34(%rax), %edx
decl %edx
addsd 0x40(%rax), %xmm0
andl %ecx, %edx
movsd %xmm0, 0x48(%rax)
movslq 0x38(%rax), %rcx
shlq $0x2, %rcx
addq 0x20(%rax), %rcx
imull 0x30(%rax), %edx
shll $0x2, %edx
movslq %edx, %rax
movl (%rax,%rcx), %ecx
jmp 0x8224
movq %rbx, %rdi
callq 0x8188
movl %eax, %ecx
movq 0x130(%rbx), %rdi
movl 0xa0(%rbx), %edx
movl 0xa4(%rbx), %esi
popq %rbx
jmp 0x7388
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_texture_sprite.c
// Function: texture_calc
void				texture_calc(t_img_coord *co)
{
	int				i;

	i = 0;
	while (i < 4)
	{
		if (co->text[i]->error == 1)
		{
			if (co->hori_verti == 0)
				co->wallx = co->posy + co->longueur_mur * co->raydiry;
			else
				co->wallx = co->posx + co->longueur_mur * co->raydirx;
			co->wallx -= floor((co->wallx));
			co->text[i]->texx = (int)(co->wallx * (co->text[i]->width));
			if (co->hori_verti == 0 && co->raydirx > 0)
				co->text[i]->texx = co->text[i]->width - co->text[i]->texx - 1;
			if (co->hori_verti == 1 && co->raydiry < 0)
				co->text[i]->texx = co->text[i]->width - co->text[i]->texx - 1;
		}
		i++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x4, %r14
je 0x82e7
movq 0xf0(%rbx,%r14,8), %r15
cmpl $0x1, 0x50(%r15)
jne 0x82df
movl 0x94(%rbx), %ebp
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movsd 0x78(%rbx), %xmm0
mulsd 0x40(%rbx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rsp)
callq 0x6360
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x80(%rbx)
movl 0x30(%r15), %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x38(%r15)
testl %ebp, %ebp
je 0x82c8
cmpl $0x1, %ebp
jne 0x82df
xorpd %xmm0, %xmm0
ucomisd 0x48(%rbx), %xmm0
ja 0x82d7
jmp 0x82df
movsd 0x40(%rbx), %xmm0
ucomisd 0x61ab(%rip), %xmm0     # 0xe480
jbe 0x82df
notl %ecx
addl %ecx, %eax
movl %eax, 0x38(%r15)
incq %r14
jmp 0x824d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/manage_texture_sprite.c
// Function: load_sprite
t_text_sprite		*load_sprite(t_img_coord *co)
{
	char			*path;
	t_text_sprite	*text_sp;

	if (!(text_sp = malloc(sizeof(t_text_sprite))))
		return (NULL);
	if (co->argi.error_sprite == 1)
	{
		path = co->argi.text_sprite;
		text_sp->mlx = co->mlx.mlx;
		text_sp->error = 1;
		if (!(text_sp->img = mlx_xpm_file_to_image(text_sp->mlx, path,
		&text_sp->width, &text_sp->height)))
			text_sp->error = 0;
		if (text_sp->error == 1 && !(text_sp->addr = mlx_get_data_addr(
			text_sp->img, &text_sp->bpp, &text_sp->line_length,
			&text_sp->endian)))
			text_sp->error = 0;
	}
	else
		text_sp->error = 0;
	if (text_sp->error == 0)
		print_error();
	return (text_sp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x58
popq %rdi
callq 0x6100
movq %rax, %rbx
testq %rax, %rax
je 0x838f
cmpl $0x1, 0x188(%r14)
jne 0x839a
movq 0x110(%r14), %rdi
movq 0x170(%r14), %rsi
movq %rdi, (%rbx)
leaq 0x50(%rbx), %r14
movl $0x1, 0x50(%rbx)
leaq 0x30(%rbx), %rdx
leaq 0x34(%rbx), %rcx
callq 0xc540
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x83a1
movl (%r14), %ecx
cmpl $0x1, %ecx
jne 0x838b
leaq 0x10(%rbx), %rsi
leaq 0x14(%rbx), %rdx
movq %rbx, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xb640
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x83a1
movl (%r14), %ecx
testl %ecx, %ecx
je 0x83a5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x50, %rbx
movq %rbx, %r14
andl $0x0, (%r14)
callq 0x82f2
nop
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/mini2d.c
// Function: draw_position
void		draw_position(t_img_coord *co)
{
	double	i;
	double	j;
	int		e;

	i = (co->argi.reso_x / 5) / co->mapi.width_map;
	j = (co->argi.reso_y / 5) / (co->mapi.height_map);
	e = 0;
	if (co->argi.reso_x > 15 && co->argi.reso_y > 15)
	{
		while (e < 5)
		{
			my_mlx_pixel_put(co->img, ((co->posx * i) + e),
			((co->posy * j)), 0x00FF0000);
			my_mlx_pixel_put(co->img, ((co->posx * i) - e),
			((co->posy * j)), 0x00FF0000);
			my_mlx_pixel_put(co->img, (co->posx * i),
			(co->posy * j - e), 0x00FF0000);
			my_mlx_pixel_put(co->img, (co->posx * i),
			(co->posy * j + e), 0x00FF0000);
			e++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %esi
movl 0x144(%rdi), %edi
pushq $0x5
popq %rbp
movl %esi, %eax
cltd
idivl %ebp
cltd
idivl 0x1c8(%rbx)
movl %eax, %ecx
movl %edi, %eax
cltd
idivl %ebp
cltd
idivl 0x1cc(%rbx)
cmpl $0x10, %esi
setge %dl
cmpl $0x10, %edi
setge %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x84f5
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
movq 0x130(%rbx), %rdi
movsd (%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
movsd 0x8(%rbx), %xmm0
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl $0xff0000, %ecx         # imm = 0xFF0000
callq 0x7388
movq 0x130(%rbx), %rdi
movsd (%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movsd 0x8(%rbx), %xmm0
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl $0xff0000, %ecx         # imm = 0xFF0000
callq 0x7388
movq 0x130(%rbx), %rdi
movsd (%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movsd 0x8(%rbx), %xmm0
mulsd (%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl $0xff0000, %ecx         # imm = 0xFF0000
callq 0x7388
movq 0x130(%rbx), %rdi
movsd (%rbx), %xmm0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %esi
movsd 0x8(%rbx), %xmm0
mulsd (%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl $0xff0000, %ecx         # imm = 0xFF0000
callq 0x7388
movsd 0x10(%rsp), %xmm1
addsd 0x5f2b(%rip), %xmm1     # 0xe418
decl %ebp
jne 0x840f
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/mini2d.c
// Function: draw_square
void		draw_square(t_img_coord *co, int x, int y)
{
	int		color;
	double	i;
	double	j;
	int		a;
	int		b;

	i = co->argi.reso_x / 5 / co->mapi.width_map;
	j = co->argi.reso_y / 5 / (co->mapi.height_map);
	a = 0;
	while ((x + a) < (x + i))
	{
		b = 0;
		while ((y + b) < (y + j))
		{
			if (co->mapi.mapp[y][x] == '1')
				color = 0x00337C85;
			else if (chose_color(co, x, y) == 1)
				color = 0x00F1D2FB;
			else
				color = 0x00581845;
			my_mlx_pixel_put(co->img, ((x * i) + a), ((y * j) + b), color);
			b++;
		}
		a++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rdi, %r15
movl 0x140(%rdi), %eax
movl 0x144(%rdi), %ecx
pushq $0x5
popq %rdi
cltd
idivl %edi
cltd
idivl 0x1c8(%r15)
cvtsi2sd %eax, %xmm0
movl %ecx, %eax
cltd
idivl %edi
cltd
idivl 0x1cc(%r15)
cvtsi2sd %eax, %xmm1
cvtsi2sd %esi, %xmm2
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, 0x10(%rsp)
cvtsi2sd %ebx, %xmm3
movapd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x30(%rsp)
movslq %ebx, %r12
movq %rsi, 0x18(%rsp)
movslq %esi, %r13
xorl %ecx, %ecx
mulsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
mulsd %xmm1, %xmm3
movsd %xmm3, 0x28(%rsp)
movq 0x18(%rsp), %rax
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8669
movq %rcx, 0x20(%rsp)
cvtsi2sd %ecx, %xmm0
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %ebp
xorl %r14d, %r14d
leal (%rbx,%r14), %eax
cvtsi2sd %eax, %xmm0
movsd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x865d
movq 0x1c0(%r15), %rax
movq (%rax,%r12,8), %rax
movzbl (%rax,%r13), %eax
addl $-0x30, %eax
cmpl $0x27, %eax
ja 0x8656
movabsq $0x8840200001, %rcx     # imm = 0x8840200001
btq %rax, %rcx
jae 0x864b
movl $0xf1d2fb, %ecx         # imm = 0xF1D2FB
cvtsi2sd %r14d, %xmm0
movq 0x130(%r15), %rdi
addsd 0x28(%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl %ebp, %esi
callq 0x7388
incl %r14d
jmp 0x85e8
movl $0x337c85, %ecx         # imm = 0x337C85
cmpq $0x1, %rax
je 0x8629
movl $0x581845, %ecx         # imm = 0x581845
jmp 0x8629
movq 0x20(%rsp), %rcx
incl %ecx
jmp 0x85b7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/mini2d.c
// Function: draw_minimap
void		draw_minimap(t_img_coord *co)
{
	int		x;
	int		y;

	x = 0;
	y = 0;
	while (x < co->mapi.width_map)
	{
		while (y <= co->mapi.height_map)
		{
			draw_square(co, x, y);
			y++;
		}
		y = 0;
		x++;
	}
	draw_position(co);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x1c8(%rbx), %ebp
jge 0x86ab
xorl %r14d, %r14d
cmpl 0x1cc(%rbx), %r14d
jg 0x86a7
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x8530
incl %r14d
jmp 0x868c
incl %ebp
jmp 0x8681
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x83ac
nop
// File: /workspace/github_c_makefile_star2_O2/florianne1212[P]Cub3D_42/srcs/movement.c
// Function: move_forward
int		move_forward(t_img_coord *co)
{
	char	at;
	double	next;
	double	movespeed;

	movespeed = 0.02;
	next = co->posy + co->diry * movespeed;
	at = co->mapi.mapp[(int)next][(int)co->posx];
	if (at != '1' && at != ' ' && at != '2')
		co->posy = next;
	next = co->posx + co->dirx * movespeed;
	at = co->mapi.mapp[(int)co->posy][(int)next];
	if (at != '1' && at != ' ' && at != '2')
		co->posx = next;
	co->x = 0;
	return (1);
}

// Assembly:
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
mulsd 0x5dda(%rip), %xmm2     # 0xe4a8
addsd %xmm1, %xmm2
movq 0x1c0(%rdi), %rax
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
cvttsd2si %xmm0, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %edx
movabsq $0x6000100000000, %rcx  # imm = 0x6000100000000
cmpq $0x32, %rdx
ja 0x8705
btq %rdx, %rcx
jb 0x870e
movsd %xmm2, 0x8(%rdi)
movapd %xmm2, %xmm1
movsd 0x10(%rdi), %xmm2
mulsd 0x5d8d(%rip), %xmm2     # 0xe4a8
cvttsd2si %xmm1, %edx
addsd %xmm0, %xmm2
movslq %edx, %rdx
cvttsd2si %xmm2, %esi
movq (%rax,%rdx,8), %rax
movslq %esi, %rdx
movzbl (%rax,%rdx), %eax
cmpq $0x32, %rax
ja 0x8741
btq %rax, %rcx
jb 0x8745
movsd %xmm2, (%rdi)
andl $0x0, 0xa4(%rdi)
pushq $0x1
popq %rax
retq