LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 $0x76, %edi
jle 0x8a1a
cmpl $0xff50, %edi           # imm = 0xFF50
jle 0x8a36
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x8a44
cmpl $0xff53, %edi           # imm = 0xFF53
jne 0x8a6f
movq 0xd8(%rsi), %rax
addq $0x14, %rax
jmp 0x8a69
cmpl $0x61, %edi
je 0x8a51
cmpl $0x64, %edi
je 0x8a5e
cmpl $0x73, %edi
jne 0x8a6f
movq 0xd8(%rsi), %rax
addq $0x4, %rax
jmp 0x8a69
cmpl $0x77, %edi
jne 0x8a75
movq 0xd8(%rsi), %rax
jmp 0x8a69
movq 0xd8(%rsi), %rax
addq $0x10, %rax
jmp 0x8a69
movq 0xd8(%rsi), %rax
addq $0xc, %rax
jmp 0x8a69
movq 0xd8(%rsi), %rax
addq $0x8, %rax
movl $0x1, (%rax)
movl $0x1, %eax
retq
cmpl $0xff1b, %edi           # imm = 0xFF1B
jne 0x8a6f
pushq %rax
movq %rsi, %rdi
callq 0x89d0
// File: /workspace/github_c_makefile_star2_O1/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 $0x76, %edi
jg 0x8aa7
cmpl $0x61, %edi
je 0x8ac5
cmpl $0x64, %edi
je 0x8adf
cmpl $0x73, %edi
jne 0x8afd
movq 0xd8(%rsi), %rax
addq $0x4, %rax
jmp 0x8af7
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x8ad2
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x8aec
cmpl $0x77, %edi
jne 0x8afd
movq 0xd8(%rsi), %rax
jmp 0x8af7
movq 0xd8(%rsi), %rax
addq $0xc, %rax
jmp 0x8af7
movq 0xd8(%rsi), %rax
addq $0x14, %rax
jmp 0x8af7
movq 0xd8(%rsi), %rax
addq $0x8, %rax
jmp 0x8af7
movq 0xd8(%rsi), %rax
addq $0x10, %rax
movl $0x0, (%rax)
movl $0x1, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_color.c
// Function: create_rgb_floor
int			create_rgb_floor(t_img_coord co)
{
	int		r;
	int		g;
	int		b;

	r = co.argi.color_floor_r;
	g = co.argi.color_floor_g;
	b = co.argi.color_floor_b;
	return ((r & 0xff) << 16) + ((g & 0xff) << 8) + (b & 0xff);
}

// Assembly:
movl 0x194(%rsp), %eax
movl 0x198(%rsp), %ecx
movzbl 0x19c(%rsp), %edx
movzbl %al, %esi
shll $0x10, %esi
shll $0x8, %ecx
movzwl %cx, %eax
orl %esi, %eax
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_color.c
// Function: create_rgb_ceiling
int			create_rgb_ceiling(t_img_coord co)
{
	int		r;
	int		g;
	int		b;

	r = co.argi.color_ceiling_r;
	g = co.argi.color_ceiling_g;
	b = co.argi.color_ceiling_b;
	return ((r & 0xff) << 16) + ((g & 0xff) << 8) + (b & 0xff);
}

// Assembly:
movl 0x1a0(%rsp), %eax
movl 0x1a4(%rsp), %ecx
movzbl 0x1a8(%rsp), %edx
movzbl %al, %esi
shll $0x10, %esi
shll $0x8, %ecx
movzwl %cx, %eax
orl %esi, %eax
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_position.c
// Function: position_south
t_img_coord		position_south(t_img_coord co)
{
	co.dirx = 0;
	co.diry = 1;
	co.planex = 0.66;
	co.planey = 0;
	return (co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x18(%rsi)
movabsq $0x3fe51eb851eb851f, %rcx # imm = 0x3FE51EB851EB851F
movq %rcx, 0x20(%rsi)
movq %rax, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_position.c
// Function: position_north
t_img_coord		position_north(t_img_coord co)
{
	co.dirx = 0;
	co.diry = -1;
	co.planex = -0.66;
	co.planey = 0;
	return (co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x18(%rsi)
movabsq $-0x401ae147ae147ae1, %rcx # imm = 0xBFE51EB851EB851F
movq %rcx, 0x20(%rsi)
movq %rax, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_position.c
// Function: position_east
t_img_coord		position_east(t_img_coord co)
{
	co.dirx = 1;
	co.diry = 0;
	co.planex = 0;
	co.planey = 0.66;
	return (co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movabsq $0x3fe51eb851eb851f, %rax # imm = 0x3FE51EB851EB851F
movq %rax, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/init_position.c
// Function: position_west
t_img_coord		position_west(t_img_coord co)
{
	co.dirx = -1;
	co.diry = 0;
	co.planex = 0;
	co.planey = 0.66;
	return (co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movabsq $0x3fe51eb851eb851f, %rax # imm = 0x3FE51EB851EB851F
movq %rax, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpb $0x4e, 0x1d8(%rsi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
jne 0x8cee
xorl %ecx, %ecx
movq %rcx, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movabsq $-0x401ae147ae147ae1, %rdx # imm = 0xBFE51EB851EB851F
movq %rdx, 0x20(%rsi)
movq %rcx, 0x28(%rsi)
cmpb $0x53, 0x1d8(%rsi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movabsq $0x3fe51eb851eb851f, %rdx # imm = 0x3FE51EB851EB851F
jne 0x8d1d
xorl %edi, %edi
movq %rdi, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rdx, 0x20(%rsi)
movq %rdi, 0x28(%rsi)
cmpb $0x57, 0x1d8(%rsi)
jne 0x8d35
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movq %rax, 0x10(%rsi)
movq %rdx, 0x28(%rsi)
cmpb $0x45, 0x1d8(%rsi)
jne 0x8d4d
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsi)
movq %rcx, 0x10(%rsi)
movq %rdx, 0x28(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movslq 0x1dc(%rdi), %r15
leaq (,%r15,4), %rdi
callq 0x7100
movq %rax, 0xc8(%r14)
testq %rax, %rax
je 0x8e14
movq %rax, %rbx
shlq $0x3, %r15
movq %r15, %rdi
callq 0x7100
movq %rax, 0xd0(%r14)
testq %rax, %rax
je 0x8e14
cmpl $0x0, 0x1dc(%r14)
jle 0x8e14
movq 0x1e0(%r14), %rcx
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movl 0x1dc(%r14), %esi
cmpl $0x2, %esi
movl $0x1, %edx
cmovgel %esi, %edx
xorl %esi, %esi
xorps %xmm2, %xmm2
cvtsi2sdl (%rcx,%rsi,8), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtsi2sdl 0x4(%rcx,%rsi,8), %xmm2
movapd %xmm1, %xmm4
subsd %xmm2, %xmm4
movl %esi, (%rbx,%rsi,4)
mulsd %xmm4, %xmm4
mulsd %xmm3, %xmm3
addsd %xmm4, %xmm3
movsd %xmm3, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x8dd7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x1dc(%rdi)
jle 0x8e94
movl $0x1, %eax
xorl %ecx, %ecx
movq %rcx, %rdx
incq %rcx
movslq 0x1dc(%rdi), %rsi
cmpq %rsi, %rcx
jge 0x8e85
movq 0xd0(%rdi), %rsi
movq %rax, %r8
movsd (%rsi,%rdx,8), %xmm0
movsd (%rsi,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8e79
movsd %xmm1, (%rsi,%rdx,8)
movsd %xmm0, (%rsi,%r8,8)
movq 0xc8(%rdi), %r9
movl (%r9,%rdx,4), %r10d
movl (%r9,%r8,4), %r11d
movl %r11d, (%r9,%rdx,4)
movl %r10d, (%r9,%r8,4)
incq %r8
cmpl %r8d, 0x1dc(%rdi)
jg 0x8e46
movslq 0x1dc(%rdi), %rdx
incq %rax
cmpq %rdx, %rcx
jl 0x8e2a
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
movslq %esi, %rax
movq 0xc8(%rdi), %rdx
movslq (%rdx,%rax,4), %rdx
cvtsi2sdl (%rcx,%rdx,8), %xmm2
movq 0xe8(%rdi), %rax
subsd (%rdi), %xmm2
movsd 0x6556(%rip), %xmm1     # 0xf418
addsd %xmm1, %xmm2
movsd %xmm2, (%rax)
cvtsi2sdl 0x4(%rcx,%rdx,8), %xmm0
subsd 0x8(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x20(%rdi), %xmm3
movsd 0x10(%rdi), %xmm4
movsd 0x18(%rdi), %xmm1
movsd 0x28(%rdi), %xmm5
movapd %xmm3, %xmm6
mulsd %xmm1, %xmm6
mulsd %xmm2, %xmm1
mulsd %xmm5, %xmm2
mulsd %xmm4, %xmm5
subsd %xmm5, %xmm6
movsd 0x650e(%rip), %xmm5     # 0xf420
movapd %xmm5, %xmm7
divsd %xmm6, %xmm7
movsd %xmm7, 0x10(%rax)
mulsd %xmm0, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm7, %xmm1
movsd %xmm1, 0x18(%rax)
mulsd %xmm3, %xmm0
subsd %xmm2, %xmm0
mulsd %xmm7, %xmm0
movsd %xmm0, 0x20(%rax)
movl 0x140(%rdi), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
xorps %xmm2, %xmm2
cvtsi2sd %edx, %xmm2
divsd %xmm0, %xmm1
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movl %ecx, 0x28(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
divsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %edx
movl %edx, %esi
negl %esi
cmovsl %edx, %esi
movl %esi, 0x2c(%rax)
shrl %esi
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl %edx, %edi
subl %esi, %edi
xorl %r8d, %r8d
testl %edi, %edi
cmovgl %edi, %r8d
movl %r8d, 0x34(%rax)
addl %esi, %edx
leal -0x1(%rcx), %esi
cmpl %ecx, %edx
cmovll %edx, %esi
movl %esi, 0x38(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/manage_sprite_two.c
// Function: sprite_cast_4
void	sprite_cast_4(t_img_coord *co)
{
	co->calc->width = abs((int)(co->argi.reso_y / (co->calc->transformy)));
	co->calc->drawstartx = -co->calc->width / 2 + co->calc->scren_x;
	if (co->calc->drawstartx < 0)
		co->calc->drawstartx = 0;
	co->calc->drawendx = co->calc->width / 2 + co->calc->scren_x;
	if (co->calc->drawendx >= co->argi.reso_x)
		co->calc->drawendx = co->argi.reso_x - 1;
}

// Assembly:
cvtsi2sdl 0x144(%rdi), %xmm0
movq 0xe8(%rdi), %rax
divsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, %edx
negl %edx
cmovsl %ecx, %edx
movl %edx, 0x30(%rax)
shrl %edx
movl 0x28(%rax), %ecx
movl %ecx, %esi
subl %edx, %esi
xorl %r8d, %r8d
testl %esi, %esi
cmovgl %esi, %r8d
movl %r8d, 0x3c(%rax)
addl %ecx, %edx
movl %edx, 0x40(%rax)
movl 0x140(%rdi), %ecx
cmpl %ecx, %edx
jl 0x9008
decl %ecx
movl %ecx, 0x40(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/manage_sprite_two.c
// Function: color_sprite
int		color_sprite(t_img_coord *co, int texx, int texy)
{
	int color;

	color = (*(int *)(co->text_sp->addr + (4 * texx) +
	(co->text_sp->line_length * texy)));
	return (color);
}

// Assembly:
movq 0xe0(%rdi), %rax
movslq %esi, %rcx
shlq $0x2, %rcx
addq 0x20(%rax), %rcx
movslq 0x14(%rax), %rax
movslq %edx, %rdx
imulq %rax, %rdx
movl (%rdx,%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq 0xe8(%rdi), %rax
movl 0x34(%rax), %ebp
cmpl 0x38(%rax), %ebp
jge 0x90e7
movl %edx, %ebx
movq %rdi, %r14
xorpd %xmm0, %xmm0
divsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %ecx
movslq %esi, %r15
shlq $0x2, %r15
movl %ebp, %r12d
shll $0x8, %r12d
shll $0x8, %ecx
subl %ecx, %r12d
movl 0x144(%r14), %ecx
shll $0x7, %ecx
movl 0x2c(%rax), %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 0x90d2
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x8, %edx
movq 0x20(%rcx), %rax
addq %r15, %rax
movslq 0x14(%rcx), %rcx
movslq %edx, %rdx
imulq %rcx, %rdx
movl (%rdx,%rax), %ecx
testl $0xffffff, %ecx         # imm = 0xFFFFFF
je 0x90d2
movq 0x130(%r14), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x8438
incl %ebp
movq 0xe8(%r14), %rax
addl $0x100, %r12d           # imm = 0x100
cmpl 0x38(%rax), %ebp
jl 0x906b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq 0xe8(%rdi), %rcx
movl 0x3c(%rcx), %ebp
cmpl 0x40(%rcx), %ebp
jge 0x9180
movq %rdi, %rbx
xorpd %xmm2, %xmm2
movl 0x30(%rcx), %esi
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
shrl %eax
subl 0x28(%rcx), %eax
addl %ebp, %eax
movq 0xe0(%rbx), %rdx
imull 0x30(%rdx), %eax
shll $0x8, %eax
cltd
idivl %esi
leal 0xff(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
testl %ebp, %ebp
jle 0x9172
movsd 0x20(%rcx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x9172
cmpl 0x140(%rbx), %ebp
jge 0x9172
movq 0xc0(%rbx), %rax
movl %ebp, %ecx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9172
sarl $0x8, %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x902a
xorpd %xmm2, %xmm2
incl %ebp
movq 0xe8(%rbx), %rcx
cmpl 0x40(%rcx), %ebp
jl 0x9109
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8d60
movq %rbx, %rdi
callq 0x8e1a
cmpl $0x0, 0x1dc(%rbx)
jle 0x91d1
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8e95
movq %rbx, %rdi
callq 0x8f6b
movq %rbx, %rdi
callq 0x8fbc
movq %rbx, %rdi
callq 0x90f0
incl %ebp
cmpl 0x1dc(%rbx), %ebp
jl 0x91a5
movq 0xc8(%rbx), %rdi
callq 0x7170
movq 0xd0(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7170
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0xb8(%rdi), %ebp
cmpl $0x3, %ebp
jg 0x9340
leaq 0x160(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x168(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x158(%rbx), %r13
leaq 0x150(%rbx), %r15
leaq 0x61d1(%rip), %r12      # 0xf428
movl $0x58, %edi
callq 0x7100
movq %rax, %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0xafc8
cmpl $0x1, %eax
jne 0x9294
movl 0xb8(%rbx), %eax
cmpq $0x3, %rax
ja 0x9339
movslq (%r12,%rax,4), %rcx
addq %r12, %rcx
movq %r15, %rax
jmpq *%rcx
movq %r13, %rax
jmp 0x92b0
movq %r14, %rbp
addq $0x50, %rbp
movl $0x0, (%rbp)
jmp 0x930c
movq 0x8(%rsp), %rax
jmp 0x92b0
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x110(%rbx), %rdi
movq %rdi, (%r14)
leaq 0x50(%r14), %rbp
movl $0x1, 0x50(%r14)
leaq 0x30(%r14), %rdx
leaq 0x34(%r14), %rcx
callq 0xdcf0
movq %rax, 0x28(%r14)
testq %rax, %rax
jne 0x92e6
movl $0x0, (%rbp)
cmpl $0x1, (%rbp)
jne 0x930c
leaq 0x10(%r14), %rsi
leaq 0x14(%r14), %rdx
movq %r14, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xcdf0
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x929b
movl 0x50(%r14), %edi
callq 0x7f72
movslq 0xb8(%rbx), %rax
leal 0x1(%rax), %ebp
movq %r14, 0xf0(%rbx,%rax,8)
movl %ebp, 0xb8(%rbx)
cmpq $0x3, %rax
jl 0x9257
jmp 0x9340
xorl %esi, %esi
jmp 0x92b3
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/manage_texture.c
// Function: which_wall
int			which_wall(t_img_coord *co)
{
	if (co->hori_verti == 0)
	{
		if (co->raydirx > 0)
			return (2);
		else
			return (3);
	}
	if (co->hori_verti == 1)
	{
		if (co->raydiry < 0)
			return (1);
		else
			return (0);
	}
	return (2);
}

// Assembly:
movl 0x94(%rdi), %ecx
cmpl $0x1, %ecx
je 0x937c
movl $0x2, %eax
testl %ecx, %ecx
jne 0x938a
movsd 0x40(%rdi), %xmm0
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
xorl $0x3, %eax
retq
xorpd %xmm0, %xmm0
xorl %eax, %eax
ucomisd 0x48(%rdi), %xmm0
seta %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x93b8
movl $0x54145e, %eax         # imm = 0x54145E
testl %ecx, %ecx
jne 0x93ce
movsd 0x40(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0xfab8de, %ecx         # imm = 0xFAB8DE
movl $0x6ad9ff, %eax         # imm = 0x6AD9FF
jmp 0x93cb
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_O1/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:
movl 0x94(%rdi), %eax
cmpl $0x1, %eax
je 0x93fb
movl $0x2, %ecx
testl %eax, %eax
jne 0x9409
movsd 0x40(%rdi), %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
seta %cl
xorq $0x3, %rcx
jmp 0x9409
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
ucomisd 0x48(%rdi), %xmm0
seta %cl
movq 0xf0(%rdi,%rcx,8), %rcx
cmpl $0x1, 0x50(%rcx)
jne 0x944c
movsd 0x48(%rcx), %xmm0
cvttsd2si %xmm0, %eax
movl 0x34(%rcx), %edx
decl %edx
addsd 0x40(%rcx), %xmm0
andl %eax, %edx
movsd %xmm0, 0x48(%rcx)
movslq 0x38(%rcx), %rax
shlq $0x2, %rax
addq 0x20(%rcx), %rax
imull 0x30(%rcx), %edx
shll $0x2, %edx
movslq %edx, %rcx
movl (%rcx,%rax), %ecx
jmp 0x9489
cmpl $0x1, %eax
je 0x9473
movl $0x54145e, %ecx         # imm = 0x54145E
testl %eax, %eax
jne 0x9489
movsd 0x40(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movl $0xfab8de, %eax         # imm = 0xFAB8DE
movl $0x6ad9ff, %ecx         # imm = 0x6AD9FF
jmp 0x9486
xorpd %xmm0, %xmm0
ucomisd 0x48(%rdi), %xmm0
movl $0xbab3fa, %eax         # imm = 0xBAB3FA
movl $0xf0da99, %ecx         # imm = 0xF0DA99
cmoval %eax, %ecx
movq 0x130(%rdi), %rax
movl 0xa0(%rdi), %edx
movl 0xa4(%rdi), %esi
movq %rax, %rdi
jmp 0x8438
// File: /workspace/github_c_makefile_star2_O1/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
movq 0xf0(%rbx,%r14,8), %r15
cmpl $0x1, 0x50(%r15)
jne 0x954a
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 0x7360
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x80(%rbx)
movl 0x30(%r15), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x38(%r15)
testl %ebp, %ebp
jne 0x952e
movsd 0x40(%rbx), %xmm0
ucomisd 0x5f34(%rip), %xmm0     # 0xf458
jbe 0x952e
notl %ecx
addl %eax, %ecx
movl %ecx, 0x38(%r15)
cmpl $0x1, %ebp
jne 0x954a
xorpd %xmm0, %xmm0
ucomisd 0x48(%rbx), %xmm0
jbe 0x954a
movl 0x38(%r15), %ecx
notl %ecx
addl %ecx, %eax
movl %eax, 0x38(%r15)
incq %r14
cmpq $0x4, %r14
jne 0x94b1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x58, %edi
callq 0x7100
testq %rax, %rax
je 0x9601
movq %rax, %rbx
cmpl $0x1, 0x188(%r14)
jne 0x9605
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 0xdcf0
movq %rax, 0x28(%rbx)
testq %rax, %rax
jne 0x95d9
movl $0x0, (%r14)
cmpl $0x1, (%r14)
jne 0x9613
leaq 0x10(%rbx), %rsi
leaq 0x14(%rbx), %rdx
movq %rbx, %rcx
addq $0x18, %rcx
movq %rax, %rdi
callq 0xcdf0
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x9613
jmp 0x960c
xorl %ebx, %ebx
jmp 0x9619
movq %rbx, %r14
addq $0x50, %r14
movl $0x0, (%r14)
cmpl $0x0, 0x50(%rbx)
je 0x9624
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x59e1(%rip), %rdi      # 0xf00c
leaq 0x5e2e(%rip), %rsi      # 0xf460
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
nop
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x140(%rdi), %rax
cmpq $0x10, %rax
setge %sil
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
cltd
idivl 0x1c8(%rdi)
movl %eax, %ecx
movl 0x144(%rdi), %eax
movslq %eax, %rdi
imulq $0x66666667, %rdi, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rax
addl %edx, %eax
cltd
idivl 0x1cc(%rbx)
cmpl $0x10, %edi
setge %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x97b0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm1, %xmm1
movl $0x5, %ebp
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 0x8438
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 0x8438
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 0x8438
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 0x8438
movsd 0x10(%rsp), %xmm1
addsd 0x5c78(%rip), %xmm1     # 0xf420
decl %ebp
jne 0x96ca
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %ecx
movq %rdi, %rbx
movslq 0x140(%rdi), %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rax
addl %edx, %eax
cltd
idivl 0x1c8(%rdi)
movl %eax, %edi
movslq 0x144(%rbx), %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rax
addl %edx, %eax
cltd
idivl 0x1cc(%rbx)
cvtsi2sd %edi, %xmm0
movq %rsi, 0x10(%rsp)
cvtsi2sd %esi, %xmm1
movapd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd %xmm1, (%rsp)
movsd %xmm2, 0x28(%rsp)
ucomisd %xmm1, %xmm2
jbe 0x998c
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
cvtsi2sd %ecx, %xmm3
movapd %xmm3, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsp)
movslq %ecx, %r15
movslq 0x10(%rsp), %r12
leal 0x1(%r15), %r13d
movq $0x0, 0x8(%rsp)
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd %xmm3, 0x20(%rsp)
mulsd %xmm3, %xmm2
movsd %xmm2, 0x30(%rsp)
movsd 0x18(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x995e
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
cvttsd2si %xmm0, %ebp
xorl %r14d, %r14d
movq 0x1c0(%rbx), %rax
movq (%rax,%r15,8), %rax
movzbl (%rax,%r12), %eax
addl $-0x30, %eax
cmpl $0x27, %eax
ja 0x9957
movabsq $0x8840200001, %rcx     # imm = 0x8840200001
btq %rax, %rcx
jae 0x994c
movl $0xf1d2fb, %ecx         # imm = 0xF1D2FB
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq 0x130(%rbx), %rdi
addsd 0x30(%rsp), %xmm0
cvttsd2si %xmm0, %edx
movl %ebp, %esi
callq 0x8438
leal (%r14,%r13), %eax
incl %r14d
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x18(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x98e3
jmp 0x995e
movl $0x337c85, %ecx         # imm = 0x337C85
cmpq $0x1, %rax
je 0x9910
movl $0x581845, %ecx         # imm = 0x581845
jmp 0x9910
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
addl %ecx, %eax
incl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
incl %ecx
movsd 0x28(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movl %ecx, %eax
movq %rax, 0x8(%rsp)
ja 0x98bc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x1c8(%rdi)
jle 0x99df
xorl %ebp, %ebp
cmpl $0x0, 0x1cc(%rbx)
js 0x99d5
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
incl %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x97ed
cmpl 0x1cc(%rbx), %r14d
jl 0x99bc
incl %ebp
cmpl 0x1c8(%rbx), %ebp
jl 0x99ad
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9640
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x18(%rdi), %xmm1
mulsd 0x5a87(%rip), %xmm1     # 0xf480
addsd 0x8(%rdi), %xmm1
movsd (%rdi), %xmm0
movq 0x1c0(%rdi), %rax
cvttsd2si %xmm1, %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 0x9a35
btq %rdx, %rcx
jb 0x9a3a
movsd %xmm1, 0x8(%rdi)
movsd 0x10(%rdi), %xmm1
mulsd 0x5a39(%rip), %xmm1     # 0xf480
cvttsd2si 0x8(%rdi), %edx
addsd %xmm0, %xmm1
movslq %edx, %rdx
cvttsd2si %xmm1, %esi
movq (%rax,%rdx,8), %rax
movslq %esi, %rdx
movzbl (%rax,%rdx), %eax
cmpq $0x32, %rax
ja 0x9a6e
btq %rax, %rcx
jb 0x9a72
movsd %xmm1, (%rdi)
movl $0x0, 0xa4(%rdi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/movement.c
// Function: move_right
void	move_right(t_img_coord *co)
{
	char	at;
	double	next;
	double	movespeed;

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

// Assembly:
movsd 0x28(%rdi), %xmm1
mulsd 0x5968(%rip), %xmm1     # 0xf488
addsd 0x8(%rdi), %xmm1
movsd (%rdi), %xmm0
movq 0x1c0(%rdi), %rax
cvttsd2si %xmm1, %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 0x9b5c
btq %rdx, %rcx
jb 0x9b61
movsd %xmm1, 0x8(%rdi)
movsd 0x20(%rdi), %xmm1
mulsd 0x591a(%rip), %xmm1     # 0xf488
cvttsd2si 0x8(%rdi), %edx
addsd %xmm1, %xmm0
movslq %edx, %rdx
cvttsd2si %xmm0, %esi
movq (%rax,%rdx,8), %rax
movslq %esi, %rdx
movzbl (%rax,%rdx), %eax
cmpq $0x32, %rax
ja 0x9b95
btq %rax, %rcx
jb 0x9b99
movsd %xmm0, (%rdi)
movl $0x0, 0xa4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_args.c
// Function: create_t_args
t_args					create_t_args(t_args args)
{
	args.buf = NULL;
	args.reso_x = -1;
	args.reso_y = -1;
	args.text_north = NULL;
	args.text_west = NULL;
	args.text_east = NULL;
	args.text_south = NULL;
	args.text_sprite = NULL;
	args.color_floor_r = -1;
	args.color_floor_g = -1;
	args.color_floor_b = -1;
	args.color_ceiling_r = -1;
	args.color_ceiling_g = -1;
	args.color_ceiling_b = -1;
	args.ready = 0;
	args.ready_s = 0;
	args.ready_j = 0;
	args = create_bis(args);
	return (args);
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %r8d, %r8d
leaq 0x90(%rsp), %rax
movq %r8, (%rax)
movq $-0x1, %rcx
movq %rcx, 0x8(%rax)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x18(%rax)
movdqu %xmm0, 0x28(%rax)
movq %r8, 0x38(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x54(%rax)
movq %rcx, 0x64(%rax)
movq %r8, 0x70(%rax)
movl %r8d, 0x78(%rax)
movq %rsp, %rdx
movl $0xf, %ecx
movq %rdx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r8d, 0x78(%rdx)
movdqu %xmm0, 0x40(%rdx)
movl $0xffffffff, 0x50(%rdx) # imm = 0xFFFFFFFF
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x78(%rdx), %ecx
movl %ecx, 0x78(%rax)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x7c(%rax)
movl $0x88, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_args.c
// Function: ft_else
size_t					ft_else(char *line, int e, t_args *args)
{
	if (ft_isspace(line[e]) == 1 || line[e] == 0 || line[e] == 32)
		return (0);
	else
	{
		put_color(RED, "\nERrror\n wrong char in your .cub file");
		exit(0);
		args->save = 0;
	}
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movsbl (%rdi,%r14), %edi
callq 0xb768
cmpl $0x1, %eax
je 0x9d3a
movzbl (%rbx,%r14), %eax
testb $-0x21, %al
jne 0x9d44
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x52c1(%rip), %rdi      # 0xf00c
leaq 0x573e(%rip), %rsi      # 0xf490
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_args.c
// Function: set_funct_args
void					set_funct_args(t_args_funct *funct_args)
{
	size_t				i;

	i = 0;
	while (i < 254)
	{
		funct_args[i] = ft_else;
		i++;
	}
	funct_args[0] = ft_else;
	funct_args['R'] = ft_resolution;
	funct_args['N'] = ft_texture_north;
	funct_args['W'] = ft_texture_west;
	funct_args['E'] = ft_texture_east;
	funct_args['S'] = ft_s_case;
	funct_args['F'] = ft_floor_color;
	funct_args['C'] = ft_color_ceilling;
}

// Assembly:
xorl %eax, %eax
leaq -0x4f(%rip), %rcx       # 0x9d18
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0xfe, %rax
jne 0x9d67
movq %rcx, (%rdi)
leaq 0x956(%rip), %rax       # 0xa6d6
movq %rax, 0x290(%rdi)
leaq 0xe71(%rip), %rax       # 0xabff
movq %rax, 0x270(%rdi)
leaq 0xf11(%rip), %rax       # 0xacad
movq %rax, 0x2b8(%rdi)
leaq 0xfb1(%rip), %rax       # 0xad5b
movq %rax, 0x228(%rdi)
leaq 0xc3a(%rip), %rax       # 0xa9f2
movq %rax, 0x298(%rdi)
leaq 0x1d7(%rip), %rax       # 0x9f9d
movq %rax, 0x230(%rdi)
leaq 0x323(%rip), %rax       # 0xa0f7
movq %rax, 0x218(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_args.c
// Function: ft_parse_arg
t_args					ft_parse_arg(char *line, t_args args)
{
	static t_args_funct	funct_args[255] = {NULL};
	int					i;

	if (args.set_p == -1)
	{
		set_funct_args(funct_args);
		args.set_p = 1;
	}
	i = 0;
	args.buf = line;
	while (i < ft_strlen(line))
	{
		if (funct_args[(int)line[i]] != NULL)
			i += funct_args[(int)line[i]](line, i, &args);
		i++;
	}
	return (args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
cmpl $-0x1, 0x80(%r14)
leaq 0xe4d2(%rip), %r12      # 0x182d0
jne 0x9e91
xorl %eax, %eax
leaq -0xf5(%rip), %rcx       # 0x9d18
movq %rcx, (%rax,%r12)
addq $0x8, %rax
cmpq $0x7f0, %rax            # imm = 0x7F0
jne 0x9e0d
movq %rcx, 0xe4ac(%rip)      # 0x182d0
leaq 0x8ab(%rip), %rax       # 0xa6d6
movq %rax, 0xe72e(%rip)      # 0x18560
leaq 0xdc6(%rip), %rax       # 0xabff
movq %rax, 0xe700(%rip)      # 0x18540
leaq 0xe66(%rip), %rax       # 0xacad
movq %rax, 0xe73a(%rip)      # 0x18588
leaq 0xf06(%rip), %rax       # 0xad5b
movq %rax, 0xe69c(%rip)      # 0x184f8
leaq 0xb8f(%rip), %rax       # 0xa9f2
movq %rax, 0xe6fe(%rip)      # 0x18568
leaq 0x12c(%rip), %rax       # 0x9f9d
movq %rax, 0xe688(%rip)      # 0x18500
leaq 0x278(%rip), %rax       # 0xa0f7
movq %rax, 0xe662(%rip)      # 0x184e8
movl $0x1, 0x80(%r14)
movq %r15, (%r14)
movq %r15, %rdi
callq 0xbc3c
testl %eax, %eax
jle 0x9ecf
xorl %ebp, %ebp
movslq %ebp, %rax
movsbq (%r15,%rax), %rax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0x9ec1
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq *%rax
addl %ebp, %eax
movl %eax, %ebp
incl %ebp
movq %r15, %rdi
callq 0xbc3c
cmpl %eax, %ebp
jl 0x9ea2
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_color.c
// Function: ft_value_color_f
int			ft_value_color_f(char *line, int e, t_args *args)
{
	int		d;
	int		result;

	d = 0;
	result = 0;
	while (e < ft_strlen(line) && ft_strcmp_c("01234567789-,", line[e]) == 1)
	{
		result = ft_atoi(&line[e]);
		if (result > 255 || result < 0)
		{
			put_color(RED, "\nError\n wrong value for the floor color");
			exit(0);
		}
		if (d == 0)
			args->color_floor_r = result;
		else if (d == 1)
			args->color_floor_g = result;
		else if (d == 2)
			args->color_floor_b = result;
		e += ft_count(result) + 1;
		d++;
	}
	return (e - 2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0xbc3c
cmpl %ebx, %eax
jle 0x9f6f
xorl %ebp, %ebp
leaq 0x55a5(%rip), %r12      # 0xf4b6
movslq %ebx, %r13
movsbl (%r15,%r13), %esi
movq %r12, %rdi
callq 0xb98c
cmpl $0x1, %eax
jne 0x9f6f
addq %r15, %r13
movq %r13, %rdi
callq 0xb77e
cmpl $0x100, %eax            # imm = 0x100
jae 0x9f83
cmpl $0x2, %ebp
je 0x9f52
cmpl $0x1, %ebp
je 0x9f4c
testl %ebp, %ebp
jne 0x9f56
movl %eax, 0x54(%r14)
jmp 0x9f56
movl %eax, 0x58(%r14)
jmp 0x9f56
movl %eax, 0x5c(%r14)
movl %eax, %edi
callq 0xbddc
addl %eax, %ebx
incl %ebx
incl %ebp
movq %r15, %rdi
callq 0xbc3c
cmpl %eax, %ebx
jl 0x9f11
addl $-0x2, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5082(%rip), %rdi      # 0xf00c
leaq 0x5533(%rip), %rsi      # 0xf4c4
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_color.c
// Function: ft_floor_color
size_t		ft_floor_color(char *line, int e, t_args *args)
{
	int		i;
	int		r;
	int		j;

	r = 0;
	j = 0;
	i = 0;
	if (line[e] == 'F' && (ft_isspace(line[e + 1]) == 1 || line[e + 1] == 0))
	{
		check_twice_color_f(args);
		i = find_i(line, e, 2);
		while (line[e + i + j + 2] != '\0')
		{
			if (line[e + i + j + 2] == ',')
				r++;
			j++;
		}
		if (r != 2)
		{
			put_color(RED, "\nError\n wrong number of argument floor color");
			exit(0);
		}
		j = ft_value_color_f(line, (e + i + 2), args);
	}
	return (j);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %r15
cmpb $0x46, (%rdi,%r15)
jne 0x9fce
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movsbl 0x1(%rdi,%r15), %edi
callq 0xb768
cmpl $0x1, %eax
je 0x9fd2
cmpb $0x0, 0x1(%r14,%r15)
je 0x9fd2
xorl %eax, %eax
jmp 0xa024
movq %rbx, %rdi
callq 0x7bc0
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x7eec
addl %ebp, %eax
movslq %eax, %rcx
leaq (%r14,%rcx), %rdx
addq $0x2, %rdx
xorl %ecx, %ecx
movzbl (%rdx), %esi
cmpl $0x2c, %esi
je 0xa006
testl %esi, %esi
jne 0xa008
jmp 0xa00d
incl %ecx
incq %rdx
jmp 0x9ff8
cmpl $0x2, %ecx
jne 0xa02f
addl $0x2, %eax
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x9eec
cltq
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4fd6(%rip), %rdi      # 0xf00c
leaq 0x54af(%rip), %rsi      # 0xf4ec
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_color.c
// Function: ft_value_color_c
int			ft_value_color_c(char *line, int e, t_args *args)
{
	int		d;
	int		result;

	d = 0;
	result = 0;
	while (e < ft_strlen(line) && ft_strcmp_c("01234567789-,", line[e]) == 1)
	{
		result = ft_atoi(&line[e]);
		if (result > 255 || result < 0)
		{
			put_color(RED, "\nError\n wrong value for the ceiling's color");
			exit(0);
		}
		if (d == 0)
			args->color_ceiling_r = result;
		else if (d == 1)
			args->color_ceiling_g = result;
		else if (d == 2)
			args->color_ceiling_b = result;
		e += ft_count(result) + 1;
		d++;
	}
	return (e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0xbc3c
cmpl %ebx, %eax
jle 0xa0cc
xorl %ebp, %ebp
leaq 0x5448(%rip), %r12      # 0xf4b6
movslq %ebx, %r13
movsbl (%r15,%r13), %esi
movq %r12, %rdi
callq 0xb98c
cmpl $0x1, %eax
jne 0xa0cc
addq %r15, %r13
movq %r13, %rdi
callq 0xb77e
cmpl $0x100, %eax            # imm = 0x100
jae 0xa0dd
cmpl $0x2, %ebp
je 0xa0af
cmpl $0x1, %ebp
je 0xa0a9
testl %ebp, %ebp
jne 0xa0b3
movl %eax, 0x60(%r14)
jmp 0xa0b3
movl %eax, 0x64(%r14)
jmp 0xa0b3
movl %eax, 0x68(%r14)
movl %eax, %edi
callq 0xbddc
addl %eax, %ebx
incl %ebx
incl %ebp
movq %r15, %rdi
callq 0xbc3c
cmpl %eax, %ebx
jl 0xa06e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f28(%rip), %rdi      # 0xf00c
leaq 0x542e(%rip), %rsi      # 0xf519
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_color.c
// Function: ft_color_ceilling
size_t		ft_color_ceilling(char *line, int e, t_args *args)
{
	int		i;
	int		r;
	int		j;

	r = 0;
	j = 0;
	i = 0;
	if (line[e] == 'C' && (ft_isspace(line[e + 1]) == 1 || line[e + 1] == 0))
	{
		check_twice_color_c(args);
		i = find_i(line, e, 2);
		while (line[e + i + j + 2] != '\0')
		{
			if (line[e + i + j + 2] == ',')
				r++;
			j++;
		}
		if (r != 2)
		{
			put_color(RED, "\nError\n wrong number of argument ceiling color");
			exit(0);
		}
		j = ft_value_color_c(line, (e + i + 2), args);
	}
	return (j - 2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %r12
movq $-0x2, %r15
cmpb $0x43, (%rdi,%r12)
jne 0xa186
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movsbl 0x1(%rdi,%r12), %edi
callq 0xb768
cmpl $0x1, %eax
je 0xa130
cmpb $0x0, 0x1(%r14,%r12)
jne 0xa186
movq %rbx, %rdi
callq 0x7bee
movq %r14, %rdi
movl %ebp, %esi
movl $0x2, %edx
callq 0x7eec
addl %ebp, %eax
movslq %eax, %rcx
leaq (%r14,%rcx), %rdx
addq $0x2, %rdx
xorl %ecx, %ecx
movzbl (%rdx), %esi
cmpl $0x2c, %esi
je 0xa164
testl %esi, %esi
jne 0xa166
jmp 0xa16b
incl %ecx
incq %rdx
jmp 0xa156
cmpl $0x2, %ecx
jne 0xa192
addl $0x2, %eax
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xa049
addl $-0x2, %eax
movslq %eax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e73(%rip), %rdi      # 0xf00c
leaq 0x53a5(%rip), %rsi      # 0xf545
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_map.c
// Function: set_map
t_map					set_map(t_map *map, int i, int j)
{
	int					e;

	e = 0;
	map->position_y = 0;
	map->position_x = 0;
	map->position_direction = '0';
	map->height_map = i;
	map->width_map = j;
	if (!(map->mapp = (char **)malloc(sizeof(char *) * (i + 1))))
		return (*map);
	while (e <= i)
	{
		map->mapp[e] = ft_strnew(j, 32);
		e++;
	}
	return (*map);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rsi)
movb $0x30, 0x18(%rsi)
movl %edx, 0xc(%rsi)
movl %ecx, 0x8(%rsi)
movslq %edx, %r12
leaq 0x8(,%r12,8), %rdi
callq 0x7100
movq %rax, (%r14)
testq %rax, %rax
sete %al
testl %r12d, %r12d
sets %cl
orb %al, %cl
jne 0xa21c
movslq %ebp, %r12
incl %r15d
xorl %r13d, %r13d
movq %r12, %rdi
movl $0x20, %esi
callq 0xba50
movq (%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0xa200
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_map.c
// Function: set_funct_map
void					set_funct_map(t_map_funct *funct_map)
{
	size_t				i;

	i = 0;
	while (i < 254)
	{
		funct_map[i] = NULL;
		i++;
	}
	funct_map[0] = (void *)(-1);
	funct_map['0'] = ft_check_borders;
	funct_map['2'] = ft_sprite;
	funct_map['N'] = ft_position_n;
	funct_map['S'] = ft_position_s;
	funct_map['W'] = ft_position_w;
	funct_map['E'] = ft_position_e;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x7f0, %edx            # imm = 0x7F0
xorl %esi, %esi
callq 0x7030
movq $-0x1, (%rbx)
leaq -0x282f(%rip), %rax     # 0x7a3c
movq %rax, 0x180(%rbx)
leaq 0x617(%rip), %rax       # 0xa890
movq %rax, 0x190(%rbx)
leaq 0x32b(%rip), %rax       # 0xa5b2
movq %rax, 0x270(%rbx)
leaq 0x35d(%rip), %rax       # 0xa5f2
movq %rax, 0x298(%rbx)
leaq 0x38f(%rip), %rax       # 0xa632
movq %rax, 0x2b8(%rbx)
leaq 0x3c1(%rip), %rax       # 0xa672
movq %rax, 0x228(%rbx)
popq %rbx
retq