LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing.c
// Function: main
int		main(int argc, char **argv)
{
	t_recup recup;

	recup.save = 0;
	ft_initialisation(&recup);
	if (argc == 2 || (argc == 3 && ft_check_save(argv[2]) == 1))
	{
		if (argc == 3)
			recup.save = 1;
		ft_cub(argv[1], &recup);
	}
	else
		write(1, "Error\nArguments invalides\n", 30);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movl $0x0, 0x68(%rdi)
callq 0x7f5a
cmpl $0x2, %ebp
je 0x77aa
cmpl $0x3, %ebp
jne 0x77ba
movq 0x10(%rbx), %rdi
callq 0x9afa
cmpl $0x1, %eax
jne 0x77ba
movl $0x1, 0x70(%rsp)
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x771b
jmp 0x77d0
leaq 0x58c0(%rip), %rsi      # 0xd081
movl $0x1e, %edx
movl $0x1, %edi
callq 0x73d0
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_atoi2
int		ft_atoi2(const char *str, t_recup *recup)
{
	int		sum;

	sum = 0;
	if (str[1] != ' ' || ft_charinstr((char *)str, ',') == 1)
		recup->erreur = 2;
	while (str[recup->i] == ' ' || str[recup->i] == '\t'
			|| str[recup->i] == ',' || str[recup->i] == '\n'
			|| str[recup->i] == '\r' || str[recup->i] == '\v'
			|| str[recup->i] == '\f')
		recup->i++;
	if (str[recup->i] == '-' || str[recup->i] == '+')
		recup->erreur = 2;
	while (str[recup->i] >= '0' && str[recup->i] <= '9')
	{
		if (sum > 21474636)
			break ;
		sum = (sum * 10) + (str[recup->i] - 48);
		recup->i++;
	}
	while (str[recup->i] >= '0' && str[recup->i] <= '9')
		recup->i++;
	return (sum);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x20, 0x1(%rdi)
jne 0x77fe
movq %r14, %rdi
movl $0x2c, %esi
callq 0x7ee6
cmpl $0x1, %eax
jne 0x7805
movl $0x2, 0x74(%rbx)
movslq 0x8(%rbx), %rcx
movq %rcx, %rax
addq %r14, %rax
movzbl (%rax), %edx
leal -0x9(%rdx), %esi
cmpl $0x5, %esi
jae 0x7824
incl %ecx
movl %ecx, 0x8(%rbx)
incq %rax
jmp 0x780f
cmpl $0x2b, %edx
jg 0x7830
cmpl $0x20, %edx
je 0x781a
jmp 0x7884
cmpl $0x2c, %edx
je 0x781a
cmpl $0x2d, %edx
jne 0x7841
movl $0x2, 0x74(%rbx)
movslq %ecx, %rsi
movb (%r14,%rsi), %dl
xorl %eax, %eax
cmpb $0x30, %dl
jl 0x785d
xorl %eax, %eax
cmpb $0x39, %dl
jbe 0x788b
movslq %ecx, %rsi
movb (%r14,%rsi), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x787c
leaq 0x1(%rsi), %rcx
movl %ecx, 0x8(%rbx)
movb 0x1(%r14,%rsi), %dl
addb $-0x30, %dl
movq %rcx, %rsi
cmpb $0xa, %dl
jb 0x7865
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2b, %edx
je 0x783a
jmp 0x7841
movslq %ecx, %rax
incl %ecx
leaq (%r14,%rax), %rsi
incq %rsi
xorl %eax, %eax
movl %ecx, %edi
movl %edi, %ecx
leal (%rax,%rax,4), %eax
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rax,2), %eax
movl %edi, 0x8(%rbx)
movb (%rsi), %dl
cmpb $0x2f, %dl
jle 0x7856
cmpb $0x39, %dl
ja 0x7856
incq %rsi
leal 0x1(%rcx), %edi
cmpl $0x147ad4c, %eax        # imm = 0x147AD4C
jle 0x789b
jmp 0x7856
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_atoi3
int		ft_atoi3(const char *str, t_recup *recup)
{
	int		verify;

	verify = 0;
	if (str[1] != ' ')
		recup->erreur = 2;
	ft_atoi3_check(str, recup);
	while (str[recup->i] == ' ' || str[recup->i] == '\t' || str[recup->i]
			== ',' || str[recup->i] == '\n' || str[recup->i] == '\r'
			|| str[recup->i] == '\v' || str[recup->i] == '\f')
	{
		recup->i++;
		verify = 0;
		if (str[recup->i] >= '0' && str[recup->i] <= '9')
			recup->indicateur2++;
		while (str[recup->i] >= '0' && str[recup->i] <= '9')
		{
			verify = (verify * 10) + str[recup->i] - 48;
			recup->sum = (recup->sum * 10) + (str[recup->i] - 48);
			recup->i++;
		}
		if (verify > 255 || verify < 0)
			recup->erreur = 2;
	}
	return (recup->sum);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x20, 0x1(%rdi)
je 0x78de
movl $0x2, 0x74(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa094
movl 0x8(%rbx), %ecx
leaq 0x1(%r14), %rax
movslq %ecx, %rdx
movzbl (%r14,%rdx), %ecx
leal -0x9(%rcx), %esi
cmpl $0x5, %esi
jae 0x797b
leaq 0x1(%rdx), %rcx
movl %ecx, 0x8(%rbx)
movb 0x1(%r14,%rdx), %dl
addb $-0x30, %dl
cmpb $0x9, %dl
ja 0x78f0
incl 0x60(%rbx)
movb (%r14,%rcx), %dil
leal -0x30(%rdi), %edx
cmpb $0x9, %dl
ja 0x78f0
movl 0x8c(%rbx), %esi
movq %rcx, %rdx
addq %rax, %rdx
xorl %r8d, %r8d
movzbl %dil, %edi
leal (%r8,%r8,4), %r8d
leal (%rdi,%r8,2), %r8d
addl $-0x30, %r8d
leal (%rsi,%rsi,4), %esi
leal (%rdi,%rsi,2), %esi
addl $-0x30, %esi
movl %esi, 0x8c(%rbx)
incl %ecx
movl %ecx, 0x8(%rbx)
movb (%rdx), %dil
leal -0x30(%rdi), %r9d
incq %rdx
cmpb $0xa, %r9b
jb 0x7932
cmpl $0x100, %r8d            # imm = 0x100
jb 0x78f0
movl $0x2, 0x74(%rbx)
jmp 0x78f0
cmpl $0x2c, %ecx
je 0x7900
cmpl $0x20, %ecx
je 0x7900
movl 0x8c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_path_texture
int		ft_path_texture(char *str, char **texture, t_recup *recup, int j)
{
	recup->count2 = 0;
	if (*texture != NULL)
	{
		recup->erreur = 2;
		return (0);
	}
	if (ft_charinstr(str, '.') == 0 || ft_charinstr(str, '/') == 0
			|| ft_strlen2(str) <= 2)
		recup->erreur = 2;
	while (str[j] != '.')
	{
		if (str[j] != ' ' && str[j] != '.')
			recup->erreur = 2;
		j++;
	}
	if (!(*texture = (char *)(malloc(sizeof(char) * (ft_strlen2(str) + 1)))))
		recup->erreur = 2;
	while (str[j] != '\0')
	{
		(*texture)[recup->count2] = str[j];
		recup->count2++;
		j++;
	}
	(*texture)[recup->count2] = '\0';
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0x0, 0x88(%rdx)
cmpq $0x0, (%rsi)
je 0x79c1
movl $0x2, 0x74(%rbx)
jmp 0x7a92
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x2e, %esi
callq 0x7ee6
testl %eax, %eax
je 0x79f5
movq %r15, %rdi
movl $0x2f, %esi
callq 0x7ee6
testl %eax, %eax
je 0x79f5
movq %r15, %rdi
callq 0x7eb8
cmpl $0x2, %eax
jg 0x79fc
movl $0x2, 0x74(%rbx)
movslq %ebp, %r13
leaq (%r15,%r13), %r12
incq %r12
shlq $0x20, %r13
movabsq $0x100000000, %rax      # imm = 0x100000000
movzbl -0x1(%r12), %ecx
cmpl $0x20, %ecx
je 0x7a2b
cmpl $0x2e, %ecx
je 0x7a33
movl $0x2, 0x74(%rbx)
incq %r12
addq %rax, %r13
jmp 0x7a14
movq %r15, %rdi
callq 0x7eb8
incl %eax
movslq %eax, %rdi
callq 0x7100
movq %rax, (%r14)
testq %rax, %rax
jne 0x7a54
movl $0x2, 0x74(%rbx)
sarq $0x20, %r13
movb (%r15,%r13), %dl
movl 0x88(%rbx), %ecx
testb %dl, %dl
je 0x7a8b
movq (%r14), %rax
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x88(%rbx), %ecx
incl %ecx
movl %ecx, 0x88(%rbx)
movb (%r12), %dl
incq %r12
testb %dl, %dl
jne 0x7a66
movq (%r14), %rax
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_texture
void	ft_texture(char *str, t_recup *recup)
{
	int			i;
	static int	j = 0;

	i = 0;
	if (str[i] == 'S' && str[i + 1] == 'O')
		ft_path_texture(str, &recup->no, recup, 2);
	else if (str[i] == 'N' && str[i + 1] == 'O')
		ft_path_texture(str, &recup->so, recup, 2);
	else if (str[i] == 'E' && str[i + 1] == 'A')
		ft_path_texture(str, &recup->we, recup, 2);
	else if (str[i] == 'W' && str[i + 1] == 'E')
		ft_path_texture(str, &recup->ea, recup, 2);
	else if (str[i] == 'S' && str[i + 1] != 'O')
		ft_path_texture(str, &recup->sp, recup, 1);
	else if (str[0] != 'N' && str[0] != 'S' && str[0] != 'W' && str[0] != 'E'
			&& str[0] != 'R' && str[0] != 'F' && str[0] != 'C'
			&& str[0] > 65 && str[0] < 122)
		recup->erreur = 2;
	j++;
}

// Assembly:
pushq %rax
movq %rsi, %rdx
movb (%rdi), %al
movzbl %al, %ecx
cmpl $0x4d, %ecx
jle 0x7ad5
addl $-0x4e, %ecx
cmpl $0x9, %ecx
ja 0x7ae4
leaq 0x55dc(%rip), %rsi      # 0xd09c
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
cmpb $0x4f, 0x1(%rdi)
jne 0x7b2a
leaq 0x20(%rdx), %rsi
jmp 0x7b15
cmpl $0x43, %ecx
je 0x7b2a
cmpl $0x45, %ecx
je 0x7b0b
cmpl $0x46, %ecx
je 0x7b2a
addb $-0x42, %al
cmpb $0x37, %al
ja 0x7b2a
movl $0x2, 0x74(%rdx)
jmp 0x7b2a
cmpb $0x4f, 0x1(%rdi)
jne 0x7b1c
leaq 0x18(%rdx), %rsi
jmp 0x7b15
cmpb $0x45, 0x1(%rdi)
jne 0x7b2a
leaq 0x30(%rdx), %rsi
jmp 0x7b15
cmpb $0x41, 0x1(%rdi)
jne 0x7b2a
leaq 0x28(%rdx), %rsi
movl $0x2, %ecx
jmp 0x7b25
leaq 0x38(%rdx), %rsi
movl $0x1, %ecx
callq 0x7997
incl 0xd774(%rip)            # 0x152a4
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_color_resolution_texture.c
// Function: ft_color_resolution
void	ft_color_resolution(char **str, t_recup *recup)
{
	int			i;

	i = 0;
	recup->i = 1;
	if (recup->sizeline > 0 && (recup->no == NULL || recup->so == NULL ||
				recup->we == NULL || recup->ea == NULL || recup->sp == NULL))
		recup->erreur = 2;
	if ((recup->no != NULL || recup->so != NULL || recup->we != NULL ||
				recup->ea != NULL || recup->sp != NULL) && (recup->rx == 0
				|| recup->ry == 0))
		recup->erreur = 2;
	if (*str[i] == 'R')
	{
		if (recup->rx != 0 && recup->ry != 0)
			recup->erreur = 2;
		recup->rx = ft_atoi2(*str, recup);
		recup->ry = ft_atoi2(*str, recup);
		if (ft_atoi2(*str, recup) > 0 || recup->rx == 0 || recup->ry == 0)
			recup->erreur = 2;
	}
	else if (*str[i] == 'F')
		recup->f = ft_atoi3(*str, recup);
	else if (*str[i] == 'C')
		recup->c = ft_atoi3(*str, recup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0x8(%rsi)
cmpl $0x0, 0x44(%rsi)
movq 0x18(%rsi), %rax
jle 0x7b75
testq %rax, %rax
je 0x7b6e
cmpq $0x0, 0x20(%rbx)
je 0x7b6e
cmpq $0x0, 0x28(%rbx)
je 0x7b6e
cmpq $0x0, 0x30(%rbx)
je 0x7b6e
cmpq $0x0, 0x38(%rbx)
jne 0x7b96
movl $0x2, 0x74(%rbx)
testq %rax, %rax
jne 0x7b96
cmpq $0x0, 0x20(%rbx)
jne 0x7b96
cmpq $0x0, 0x28(%rbx)
jne 0x7b96
cmpq $0x0, 0x30(%rbx)
jne 0x7b96
cmpq $0x0, 0x38(%rbx)
je 0x7ba8
cmpl $0x0, (%rbx)
je 0x7ba1
cmpl $0x0, 0x4(%rbx)
jne 0x7ba8
movl $0x2, 0x74(%rbx)
movq (%r14), %rdi
movzbl (%rdi), %eax
cmpl $0x43, %eax
je 0x7c0c
cmpl $0x46, %eax
je 0x7bff
cmpl $0x52, %eax
jne 0x7c17
cmpl $0x0, (%rbx)
je 0x7bcf
cmpl $0x0, 0x4(%rbx)
je 0x7bcf
movl $0x2, 0x74(%rbx)
movq %rbx, %rsi
callq 0x77dc
movl %eax, (%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x77dc
movl %eax, 0x4(%rbx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x77dc
testl %eax, %eax
jle 0x7c1f
movl $0x2, 0x74(%rbx)
jmp 0x7c17
movq %rbx, %rsi
callq 0x78c7
movl %eax, 0xc(%rbx)
jmp 0x7c17
movq %rbx, %rsi
callq 0x78c7
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%rbx)
je 0x7bf6
cmpl $0x0, 0x4(%rbx)
jne 0x7c17
jmp 0x7bf6
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_murs
int		ft_murs(t_recup *recup)
{
	int i;

	i = 0;
	while (i < recup->nblines)
	{
		if (recup->map[i][0] != '1')
			return (1);
		i++;
	}
	i = 0;
	while (i < recup->nblines)
	{
		if (recup->map[i][recup->sizeline - 1] != '1')
			return (1);
		i++;
	}
	if (ft_murs_util(recup->map[0]) == 1)
		return (1);
	if (ft_murs_util(recup->map[recup->nblines - 1]) == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x40(%rdi), %rcx
testq %rcx, %rcx
jle 0x7c79
movq 0x48(%rbx), %rdx
xorl %esi, %esi
movl $0x1, %eax
movq (%rdx,%rsi,8), %rdi
cmpb $0x31, (%rdi)
jne 0x7cad
incq %rsi
cmpq %rsi, %rcx
jne 0x7c44
testl %ecx, %ecx
jle 0x7c79
movq 0x48(%rbx), %rdx
movslq 0x44(%rbx), %rsi
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
cmpb $0x31, -0x1(%r8,%rsi)
jne 0x7cad
incq %rdi
cmpq %rdi, %rcx
jne 0x7c63
jmp 0x7c7d
movq 0x48(%rbx), %rdx
movq (%rdx), %rdi
callq 0x7f40
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x7cad
movq 0x48(%rbx), %rax
movslq 0x40(%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rdi
callq 0x7f40
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_copy_map
int		ft_copy_map(char *str, t_recup *recup)
{
	static int	i = 0;
	int			j;

	j = 0;
	recup->map[i] = NULL;
	if (!(recup->map[i] = malloc(sizeof(char) * recup->sizeline + 1)))
		return (0);
	while (str[j] != '\0')
	{
		if (ft_depart(str[j], recup, i, j) == 1)
			recup->map[i][j] = '0';
		else if (str[j] == ' ')
			recup->map[i][j] = '1';
		else
			recup->map[i][j] = str[j];
		j++;
	}
	while (j <= (recup->sizeline - 1))
	{
		recup->map[i][j] = '1';
		j++;
	}
	recup->map[i][j] = '\0';
	i++;
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r12
movq 0x48(%rsi), %rax
movslq 0xd5df(%rip), %r15      # 0x152a8
movq $0x0, (%rax,%r15,8)
movslq 0x44(%rsi), %r13
leaq 0x1(%r13), %rdi
callq 0x7100
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
testq %rax, %rax
je 0x7d90
movb (%r12), %al
xorl %r14d, %r14d
testb %al, %al
je 0x7d58
movsbl %al, %edi
movq %rbx, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x7f0b
cmpl $0x1, %eax
jne 0x7d26
movq 0x48(%rbx), %rax
movslq 0xd58d(%rip), %r15      # 0x152a8
movq (%rax,%r15,8), %rax
movb $0x30, (%rax,%r14)
jmp 0x7d48
movb (%r12,%r14), %al
movq 0x48(%rbx), %rcx
movslq 0xd573(%rip), %r15      # 0x152a8
movq (%rcx,%r15,8), %rcx
cmpb $0x20, %al
jne 0x7d44
movb $0x31, (%rcx,%r14)
jmp 0x7d48
movb %al, (%rcx,%r14)
movb 0x1(%r12,%r14), %al
incq %r14
testb %al, %al
jne 0x7cfa
movl 0x44(%rbx), %r13d
movslq %r15d, %rax
cmpl %r13d, %r14d
jge 0x7d79
movl %r14d, %r14d
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movb $0x31, (%rcx,%r14)
incq %r14
cmpl %r14d, 0x44(%rbx)
jg 0x7d63
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movl %r14d, %edx
movb $0x0, (%rcx,%rdx)
incl %eax
movl %eax, 0xd518(%rip)      # 0x152a8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_is_map
int		ft_is_map(char *str, t_recup *recup)
{
	int i;

	i = 0;
	if (!str)
		return (0);
	if (ft_charinstr(str, '1') == 1 || ft_charinstr(str, '0') == 1)
	{
		while (str[i] != '\0')
		{
			if (str[i] != ' ' && str[i] != '0' && str[i] != '1' \
					&& str[i] != '2' && str[i] != 'N' && str[i] != 'S' \
					&& str[i] != 'E' && str[i] != 'W' && str[i] != '\n'
					&& str[i] != '\t')
			{
				if (recup->insidemap == 1)
					recup->wrongcharmap = 2;
				return (0);
			}
			i++;
		}
		return (1);
	}
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7e21
movq %rsi, %r14
movq %rdi, %r15
movl $0x31, %esi
callq 0x7ee6
cmpl $0x1, %eax
je 0x7dcf
movq %r15, %rdi
movl $0x30, %esi
callq 0x7ee6
cmpl $0x1, %eax
jne 0x7e21
movl $0x44201, %eax          # imm = 0x44201
movabsq $0x7000100000600, %rcx  # imm = 0x7000100000600
movzbl (%r15), %edx
cmpq $0x32, %rdx
ja 0x7df3
btq %rdx, %rcx
jb 0x7e00
testq %rdx, %rdx
je 0x7e05
addl $-0x45, %edx
cmpl $0x12, %edx
ja 0x7e0c
btl %edx, %eax
jae 0x7e0c
incq %r15
jmp 0x7dde
movl $0x1, %ebx
jmp 0x7e21
cmpl $0x1, 0x80(%r14)
jne 0x7e21
movl $0x2, 0x90(%r14)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_map
void	ft_map(char *str, t_recup *recup)
{
	int			i;
	static int	snblines = 0;
	static int	ssizeline = 0;

	i = 0;
	if (ft_is_map(str, recup) == 1)
	{
		if (recup->f == -1 || recup->c == -1 || recup->no == NULL ||
				recup->so == NULL || recup->we == NULL ||
				recup->ea == NULL || recup->sp == NULL)
			recup->erreur = 2;
		if ((i = ft_strlen(str)) > ssizeline)
			ssizeline = i;
		snblines = snblines + 1;
	}
	recup->nblines = snblines;
	recup->sizeline = ssizeline;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7d9c
testl %eax, %eax
je 0x7e9c
cmpl $-0x1, 0xc(%rbx)
je 0x7e6b
cmpl $-0x1, 0x10(%rbx)
je 0x7e6b
cmpq $0x0, 0x18(%rbx)
je 0x7e6b
cmpq $0x0, 0x20(%rbx)
je 0x7e6b
cmpq $0x0, 0x28(%rbx)
je 0x7e6b
cmpq $0x0, 0x30(%rbx)
je 0x7e6b
cmpq $0x0, 0x38(%rbx)
jne 0x7e72
movl $0x2, 0x74(%rbx)
movq %r14, %rdi
callq 0x9d78
movl 0xd430(%rip), %ecx      # 0x152b0
cmpl %ecx, %eax
jle 0x7e8c
movl %eax, 0xd426(%rip)      # 0x152b0
movl %eax, %ecx
movl 0xd41a(%rip), %eax      # 0x152ac
incl %eax
movl %eax, 0xd412(%rip)      # 0x152ac
jmp 0x7ea8
movl 0xd40a(%rip), %eax      # 0x152ac
movl 0xd408(%rip), %ecx      # 0x152b0
movl %eax, 0x40(%rbx)
movl %ecx, 0x44(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_utils.c
// Function: ft_strlen2
int		ft_strlen2(char *str)
{
	int j;
	int i;

	j = 0;
	i = 0;
	while (str[i] != '.')
		i++;
	while (str[i] != '\0')
	{
		i++;
		j++;
	}
	return (j);
}

// Assembly:
movq $-0x1, %rcx
cmpb $0x2e, 0x1(%rdi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x7ebf
movl %ecx, %eax
cmpb $0x0, (%rdi,%rax)
je 0x7ee3
xorl %eax, %eax
leaq (%rdi,%rax), %rdx
incq %rax
cmpb $0x0, 0x1(%rcx,%rdx)
jne 0x7ed4
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_utils.c
// Function: ft_charinstr
int		ft_charinstr(char *str, char c)
{
	int i;

	i = 0;
	if (!str)
		return (0);
	while (str[i] != '\0')
	{
		if (str[i] == c)
			return (1);
		i++;
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x7f04
movb (%rdi), %cl
testb %cl, %cl
je 0x7f04
incq %rdi
cmpb %sil, %cl
je 0x7f05
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x7ef6
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/parsing_utils.c
// Function: ft_depart
int		ft_depart(char c, t_recup *recup, int i, int j)
{
	if (c == 'N' || c == 'S' || c == 'E' || c == 'W')
	{
		if (recup->depart != 'x')
			recup->multijoueurs = 1;
		recup->depart = c;
		recup->dx = i;
		recup->dy = j;
		return (1);
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
leal -0x45(%rdi), %r8d
cmpl $0x12, %r8d
ja 0x7f3f
movl $0x44201, %r9d          # imm = 0x44201
btl %r8d, %r9d
jae 0x7f3f
cmpb $0x78, 0x50(%rsi)
je 0x7f30
movl $0x1, 0x78(%rsi)
movb %dil, 0x50(%rsi)
movl %edx, 0x54(%rsi)
movl %ecx, 0x58(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_key_press
int		ft_key_press(int keycode, t_recup *recup)
{
	if (keycode == FORWARD_W_Z)
		recup->data.forward = 1;
	else if (keycode == BACK_S_S)
		recup->data.back = 1;
	else if (keycode == LEFT_A_Q)
		recup->data.left = 1;
	else if (keycode == RIGHT_D_D)
		recup->data.right = 1;
	else if (keycode == ROTATE_LEFT)
		recup->data.rotate_left = 1;
	else if (keycode == ROTATE_RIGHT)
		recup->data.rotate_right = 1;
	else if (keycode == 65307)
		ft_error(recup, "Non jrigole\n");
	return (1);
}

// Assembly:
cmpl $0x76, %edi
jle 0x7fc3
cmpl $0xff50, %edi           # imm = 0xFF50
jg 0x7fde
cmpl $0x77, %edi
je 0x8006
cmpl $0xff1b, %edi           # imm = 0xFF1B
jne 0x8028
pushq %rax
leaq 0x5112(%rip), %rax      # 0xd0c4
movq %rsi, %rdi
movq %rax, %rsi
callq 0x970c
addq $0x8, %rsp
jmp 0x8028
cmpl $0x61, %edi
je 0x7ffa
cmpl $0x64, %edi
je 0x801e
cmpl $0x73, %edi
jne 0x8028
movl $0x1, 0x2a8(%rsi)
jmp 0x8028
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x8012
cmpl $0xff53, %edi           # imm = 0xFF53
jne 0x8028
movl $0x1, 0x2b8(%rsi)
jmp 0x8028
movl $0x1, 0x2ac(%rsi)
jmp 0x8028
movl $0x1, 0x2a4(%rsi)
jmp 0x8028
movl $0x1, 0x2b4(%rsi)
jmp 0x8028
movl $0x1, 0x2b0(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_key_release
int		ft_key_release(int keycode, t_recup *recup)
{
	if (keycode == FORWARD_W_Z)
		recup->data.forward = 0;
	else if (keycode == BACK_S_S)
		recup->data.back = 0;
	else if (keycode == LEFT_A_Q)
		recup->data.left = 0;
	else if (keycode == RIGHT_D_D)
		recup->data.right = 0;
	else if (keycode == ROTATE_LEFT)
		recup->data.rotate_left = 0;
	else if (keycode == ROTATE_RIGHT)
		recup->data.rotate_right = 0;
	return (1);
}

// Assembly:
cmpl $0x76, %edi
jg 0x804e
cmpl $0x61, %edi
je 0x806f
cmpl $0x64, %edi
je 0x8087
cmpl $0x73, %edi
jne 0x809d
movl $0x0, 0x2a8(%rsi)
jmp 0x809d
cmpl $0xff53, %edi           # imm = 0xFF53
je 0x807b
cmpl $0xff51, %edi           # imm = 0xFF51
je 0x8093
cmpl $0x77, %edi
jne 0x809d
movl $0x0, 0x2a4(%rsi)
jmp 0x809d
movl $0x0, 0x2ac(%rsi)
jmp 0x809d
movl $0x0, 0x2b8(%rsi)
jmp 0x809d
movl $0x0, 0x2b0(%rsi)
jmp 0x809d
movl $0x0, 0x2b4(%rsi)
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_color_column
int		ft_color_column(t_recup *recup)
{
	int j;
	int i;

	j = -1;
	recup->ray.drawend = recup->ry - recup->ray.drawstart;
	i = recup->ray.drawend;
	while (++j < recup->ray.drawstart)
		recup->data.addr[j * recup->data.line_length / 4 +
			recup->ray.x] = recup->c;
	if (j <= recup->ray.drawend)
		ft_draw_texture(recup, recup->ray.x, j);
	j = i;
	while (++j < recup->ry)
		recup->data.addr[j * recup->data.line_length / 4 +
			recup->ray.x] = recup->f;
	return (0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
movl 0x364(%rdi), %eax
subl %eax, %ebp
movl %ebp, 0x368(%rdi)
testl %eax, %eax
jle 0x810d
movq 0x290(%rbx), %rcx
movl 0x10(%rbx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, %esi
leal 0x1(%rsi), %eax
movl 0x29c(%rbx), %edi
imull %eax, %edi
leal 0x3(%rdi), %r8d
testl %edi, %edi
cmovnsl %edi, %r8d
sarl $0x2, %r8d
movslq 0x380(%rbx), %rdi
movslq %r8d, %r8
addq %rdi, %r8
movl %edx, (%rcx,%r8,4)
addl $0x2, %esi
cmpl 0x364(%rbx), %esi
jl 0x80cd
movl 0x368(%rbx), %ecx
jmp 0x8114
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %ebp, %ecx
cmpl %ecx, %eax
jge 0x8126
movl 0x380(%rbx), %esi
movq %rbx, %rdi
callq 0x816b
incl %ebp
cmpl 0x4(%rbx), %ebp
jge 0x8162
movq 0x290(%rbx), %rax
movl 0xc(%rbx), %ecx
movl 0x29c(%rbx), %edx
imull %ebp, %edx
leal 0x3(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x2, %esi
movslq 0x380(%rbx), %rdx
movslq %esi, %rsi
addq %rdx, %rsi
movl %ecx, (%rax,%rsi,4)
incl %ebp
cmpl 0x4(%rbx), %ebp
jl 0x8137
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/keys_draw.c
// Function: ft_draw_texture
void	ft_draw_texture(t_recup *recup, int x, int y)
{
	y = recup->ray.drawstart - 1;
	ft_init_texture(recup);
	recup->t.step = 1.0 * recup->texture[0].height / recup->ray.lineheight;
	recup->t.texx = (int)(recup->t.wallx * (double)recup->texture
			[recup->t.texdir].width);
	if (recup->ray.side == 0 && recup->ray.raydirx > 0)
		recup->t.texx = recup->texture[recup->t.texdir].width -
			recup->t.texx - 1;
	if (recup->ray.side == 1 && recup->ray.raydiry < 0)
		recup->t.texx = recup->texture[recup->t.texdir].width -
			recup->t.texx - 1;
	recup->t.texpos = (recup->ray.drawstart - recup->ry / 2 +
			recup->ray.lineheight / 2) * recup->t.step;
	while (++y <= recup->ray.drawend)
	{
		recup->t.texy = (int)recup->t.texpos &
			(recup->texture[recup->t.texdir].height - 1);
		recup->t.texpos += recup->t.step;
		if (y < recup->ry && x < recup->rx)
			recup->data.addr[y * recup->data.line_length / 4 + x] =
				recup->texture[recup->t.texdir].addr[recup->t.texy *
					recup->texture[recup->t.texdir].line_length /
					4 + recup->t.texx];
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x364(%rdi), %r14d
callq 0x83dc
cvtsi2sdl 0xe4(%rbx), %xmm0
movl 0x354(%rbx), %esi
movl 0x360(%rbx), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x3a0(%rbx)
movslq 0x388(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
movl 0xe0(%rbx,%rcx), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd 0x390(%rbx), %xmm1
cvttsd2si %xmm1, %edx
movl %edx, 0x398(%rbx)
cmpl $0x1, %esi
je 0x82dd
testl %esi, %esi
jne 0x81fc
movsd 0x308(%rbx), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x81fc
notl %edx
addl %edx, %ecx
movl %ecx, 0x398(%rbx)
movl 0x4(%rbx), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x364(%rbx), %ecx
sarl %edx
subl %edx, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x3a8(%rbx)
movl 0x368(%rbx), %ecx
cmpl %ecx, %r14d
jg 0x82d8
leaq 0x98(%rbx), %rax
cvttsd2si %xmm1, %edi
movslq 0x388(%rbx), %rdx
leaq (%rdx,%rdx,2), %rsi
shlq $0x5, %rsi
movl 0x4c(%rax,%rsi), %edx
decl %edx
andl %edi, %edx
movl %edx, 0x39c(%rbx)
cmpl 0x4(%rbx), %r14d
jge 0x82bc
cmpl %ebp, (%rbx)
jle 0x82bc
movq 0x18(%rax,%rsi), %rcx
imull 0x24(%rax,%rsi), %edx
leal 0x3(%rdx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
sarl $0x2, %esi
movslq 0x398(%rbx), %rdx
movslq %esi, %rsi
addq %rdx, %rsi
movl (%rcx,%rsi,4), %ecx
movq 0x290(%rbx), %rdx
movl 0x29c(%rbx), %esi
imull %r14d, %esi
leal 0x3(%rsi), %edi
testl %esi, %esi
cmovnsl %esi, %edi
sarl $0x2, %edi
addl %ebp, %edi
movslq %edi, %rsi
movl %ecx, (%rdx,%rsi,4)
movl 0x368(%rbx), %ecx
addsd %xmm0, %xmm1
leal 0x1(%r14), %edx
cmpl %ecx, %r14d
movl %edx, %r14d
jl 0x8242
movsd %xmm1, 0x3a8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
xorpd %xmm1, %xmm1
ucomisd 0x310(%rbx), %xmm1
ja 0x81f2
jmp 0x81fc
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_initialisation2
void	ft_initialisation2(t_recup *recup)
{
	if (!(recup->s.zbuffer = (double *)malloc(sizeof(double) * recup->rx)))
		exit(0);
	recup->data.forward = 0;
	recup->data.back = 0;
	recup->data.left = 0;
	recup->data.right = 0;
	recup->data.rotate_right = 0;
	recup->data.rotate_left = 0;
	recup->ray.posx = (double)recup->dx + 0.5;
	recup->ray.posy = (double)recup->dy + 0.5;
	recup->ray.dirx = 0;
	recup->ray.diry = 0;
	recup->ray.planx = 0;
	recup->ray.plany = 0;
	ft_init_dir(recup);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, 0x410(%rbx)
testq %rax, %rax
je 0x8351
xorps %xmm0, %xmm0
movups %xmm0, 0x2a4(%rbx)
movq $0x0, 0x2b4(%rbx)
cvtdq2pd 0x54(%rbx), %xmm1
addpd 0x4dae(%rip), %xmm1     # 0xd0e0
movupd %xmm1, 0x2d8(%rbx)
movups %xmm0, 0x2e8(%rbx)
movups %xmm0, 0x2f8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9f6a
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_initialisation3
void	ft_initialisation3(t_recup *recup)
{
	recup->ray.hit = 0;
	recup->ray.perpwalldist = 0;
	recup->ray.camerax = 2 * recup->ray.x / (double)recup->rx - 1;
	recup->ray.raydirx = recup->ray.dirx + recup->ray.planx * \
						recup->ray.camerax;
	recup->ray.raydiry = recup->ray.diry + recup->ray.plany * \
						recup->ray.camerax;
	recup->ray.mapx = (int)recup->ray.posx;
	recup->ray.mapy = (int)recup->ray.posy;
	recup->ray.movespeed = 0.1;
	recup->ray.rotspeed = 0.033 * 1.8;
	ft_init_more3(recup);
}

// Assembly:
movl $0x0, 0x350(%rdi)
movq $0x0, 0x358(%rdi)
movl 0x380(%rdi), %eax
addl %eax, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl (%rdi), %xmm1
divsd %xmm1, %xmm0
addsd 0x4d77(%rip), %xmm0     # 0xd100
movsd %xmm0, 0x318(%rdi)
movupd 0x2d8(%rdi), %xmm1
movupd 0x2e8(%rdi), %xmm2
movupd 0x2f8(%rdi), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, 0x308(%rdi)
cvttpd2dq %xmm1, %xmm0
movlpd %xmm0, 0x320(%rdi)
movaps 0x4d20(%rip), %xmm0     # 0xd0f0
movups %xmm0, 0x370(%rdi)
jmp 0x9fdf
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_texture
void	ft_init_texture(t_recup *recup)
{
	if (recup->ray.side == 0 && recup->ray.raydirx < 0)
		recup->t.texdir = 0;
	if (recup->ray.side == 0 && recup->ray.raydirx >= 0)
		recup->t.texdir = 1;
	if (recup->ray.side == 1 && recup->ray.raydiry < 0)
		recup->t.texdir = 2;
	if (recup->ray.side == 1 && recup->ray.raydiry >= 0)
		recup->t.texdir = 3;
	if (recup->ray.side == 0)
		recup->t.wallx = recup->ray.posy + recup->ray.perpwalldist \
						* recup->ray.raydiry;
	else
		recup->t.wallx = recup->ray.posx + recup->ray.perpwalldist \
						* recup->ray.raydirx;
	recup->t.wallx -= floor((recup->t.wallx));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2d8(%rdi), %rax
movl 0x354(%rdi), %edx
movl $0x308, %ecx            # imm = 0x308
cmpl $0x1, %edx
je 0x8439
testl %edx, %edx
jne 0x8465
movsd 0x308(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x841b
movl $0x0, 0x388(%rbx)
ucomisd %xmm1, %xmm0
jb 0x842b
movl $0x1, 0x388(%rbx)
leaq 0x2e0(%rbx), %rax
movl $0x310, %ecx            # imm = 0x310
jmp 0x8465
movsd 0x310(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8455
movl $0x2, 0x388(%rbx)
ucomisd %xmm1, %xmm0
jb 0x8465
movl $0x3, 0x388(%rbx)
movsd 0x358(%rbx), %xmm0
mulsd (%rbx,%rcx), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7380
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x390(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_sprite
void	ft_init_sprite(t_recup *recup)
{
	int i;
	int j;

	i = -1;
	recup->s.nbspr = 0;
	ft_verify_errors(recup);
	while (++i < recup->nblines)
	{
		j = -1;
		while (++j < recup->sizeline)
		{
			if (recup->map[i][j] == '2')
				recup->s.nbspr += 1;
		}
	}
	if (!(recup->sxy = (t_sprxy *)malloc(sizeof(t_sprxy) * recup->s.nbspr)))
		ft_error(recup, "Malloc sxy*");
	if (!(recup->s.order = (int *)malloc(sizeof(int) * recup->s.nbspr)))
		ft_error(recup, "Malloc s.order*");
	if (!(recup->s.dist = (double *)malloc(sizeof(double) * recup->s.nbspr)))
		ft_error(recup, "Malloc s.dist*");
	ft_init_sprite2(recup, 0, 0, 0);
	ft_mlx(recup);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x3b0(%rdi)
callq 0x9680
movslq 0x40(%rbx), %rax
testq %rax, %rax
jle 0x84e7
movl 0x44(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x84df
movq 0x48(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %edi, %edi
cmpb $0x32, (%rsi,%rdi)
jne 0x84d7
incl 0x3b0(%rbx)
incq %rdi
cmpq %rdi, %rcx
jne 0x84cb
incq %rdx
cmpq %rax, %rdx
jne 0x84bd
movslq 0x3b0(%rbx), %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x7100
movq %rax, 0x418(%rbx)
testq %rax, %rax
jne 0x851c
leaq 0x4c03(%rip), %rsi      # 0xd110
movq %rbx, %rdi
callq 0x970c
movslq 0x3b0(%rbx), %r14
leaq (,%r14,4), %rdi
callq 0x7100
movq %rax, 0x3b8(%rbx)
testq %rax, %rax
jne 0x854b
leaq 0x4be0(%rip), %rsi      # 0xd11c
movq %rbx, %rdi
callq 0x970c
movslq 0x3b0(%rbx), %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x7100
movq %rax, 0x3c0(%rbx)
testq %rax, %rax
jne 0x8572
leaq 0x4bc2(%rip), %rsi      # 0xd12c
movq %rbx, %rdi
callq 0x970c
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x858d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9110
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_sprite2
void	ft_init_sprite2(t_recup *recup, int i, int j, int v)
{
	i = i - 1;
	while (++i < recup->nblines)
	{
		j = -1;
		while (++j < recup->sizeline)
		{
			if (recup->map[i][j] == '2')
			{
				recup->sxy[v].x = (double)i + 0.5;
				recup->sxy[v].y = (double)j + 0.5;
				v++;
			}
		}
	}
}

// Assembly:
movslq 0x40(%rdi), %rax
cmpl %esi, %eax
jle 0x8600
movl 0x44(%rdi), %edx
movslq %esi, %rsi
movsd 0x4b65(%rip), %xmm0     # 0xd108
testl %edx, %edx
jle 0x85f8
movq 0x48(%rdi), %r8
movq (%r8,%rsi,8), %r8
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
addsd %xmm0, %xmm1
xorl %r9d, %r9d
cmpb $0x32, (%r8,%r9)
jne 0x85f0
movq 0x418(%rdi), %r10
movslq %ecx, %rcx
movq %rcx, %r11
shlq $0x4, %r11
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
movsd %xmm1, (%r10,%r11)
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%r10,%r11)
incl %ecx
incq %r9
cmpq %r9, %rdx
jne 0x85bd
incq %rsi
cmpq %rax, %rsi
jne 0x85a3
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_utils.c
// Function: ft_stepsidedist
void	ft_stepsidedist(t_recup *recup)
{
	if (recup->ray.raydirx < 0)
	{
		recup->ray.stepx = -1;
		recup->ray.sidedistx = (recup->ray.posx - recup->ray.mapx) \
							* recup->ray.deltadistx;
	}
	else
	{
		recup->ray.stepx = 1;
		recup->ray.sidedistx = (recup->ray.mapx + 1.0 - recup->ray.posx) \
							* recup->ray.deltadistx;
	}
	if (recup->ray.raydiry < 0)
	{
		recup->ray.stepy = -1;
		recup->ray.sidedisty = (recup->ray.posy - recup->ray.mapy) \
							* recup->ray.deltadisty;
	}
	else
	{
		recup->ray.stepy = 1;
		recup->ray.sidedisty = (recup->ray.mapy + 1.0 - recup->ray.posy) \
							* recup->ray.deltadisty;
	}
	ft_incrementray(recup);
}

// Assembly:
xorpd %xmm0, %xmm0
ucomisd 0x308(%rdi), %xmm0
jbe 0x862d
movsd 0x2d8(%rdi), %xmm0
cvtsi2sdl 0x320(%rdi), %xmm1
subsd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x864d
xorps %xmm0, %xmm0
cvtsi2sdl 0x320(%rdi), %xmm0
addsd 0x4b00(%rip), %xmm0     # 0xd140
subsd 0x2d8(%rdi), %xmm0
movl $0x1, %eax
mulsd 0x338(%rdi), %xmm0
movl %eax, 0x348(%rdi)
movsd %xmm0, 0x328(%rdi)
xorpd %xmm0, %xmm0
ucomisd 0x310(%rdi), %xmm0
jbe 0x868f
movsd 0x2e0(%rdi), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x324(%rdi), %xmm1
subsd %xmm1, %xmm0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x86af
xorps %xmm0, %xmm0
cvtsi2sdl 0x324(%rdi), %xmm0
addsd 0x4a9e(%rip), %xmm0     # 0xd140
subsd 0x2e0(%rdi), %xmm0
movl $0x1, %eax
mulsd 0x340(%rdi), %xmm0
movl %eax, 0x34c(%rdi)
movsd %xmm0, 0x330(%rdi)
jmp 0x86ca
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_utils.c
// Function: ft_incrementray
void	ft_incrementray(t_recup *recup)
{
	while (recup->ray.hit == 0)
	{
		if (recup->ray.sidedistx < recup->ray.sidedisty)
		{
			recup->ray.sidedistx += recup->ray.deltadistx;
			recup->ray.mapx += recup->ray.stepx;
			recup->ray.side = 0;
		}
		else
		{
			recup->ray.sidedisty += recup->ray.deltadisty;
			recup->ray.mapy += recup->ray.stepy;
			recup->ray.side = 1;
		}
		if (recup->map[recup->ray.mapx][recup->ray.mapy] == '1')
			recup->ray.hit = 1;
	}
	ft_drawstartend(recup);
}

// Assembly:
cmpl $0x0, 0x350(%rdi)
jne 0x8764
movq 0x48(%rdi), %rax
movsd 0x328(%rdi), %xmm0
movsd 0x330(%rdi), %xmm1
movl 0x324(%rdi), %ecx
movl 0x320(%rdi), %edx
ucomisd %xmm0, %xmm1
jbe 0x871d
addsd 0x338(%rdi), %xmm0
movsd %xmm0, 0x328(%rdi)
addl 0x348(%rdi), %edx
movl %edx, 0x320(%rdi)
xorl %esi, %esi
jmp 0x873e
addsd 0x340(%rdi), %xmm1
movsd %xmm1, 0x330(%rdi)
addl 0x34c(%rdi), %ecx
movl %ecx, 0x324(%rdi)
movl $0x1, %esi
movl %esi, 0x354(%rdi)
movslq %edx, %rsi
movq (%rax,%rsi,8), %rsi
movslq %ecx, %r8
cmpb $0x31, (%rsi,%r8)
jne 0x86f7
movl $0x1, 0x350(%rdi)
jmp 0x8764
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_utils.c
// Function: ft_drawstartend
void	ft_drawstartend(t_recup *recup)
{
	if (recup->ray.side == 0)
		recup->ray.perpwalldist = ((double)recup->ray.mapx - \
				recup->ray.posx + (1 - (double)recup->ray.
				stepx) / 2) / recup->ray.raydirx;
	else
		recup->ray.perpwalldist = ((double)recup->ray.mapy - \
				recup->ray.posy + (1 - (double)recup->ray.
				stepy) / 2) / recup->ray.raydiry;
	recup->ray.lineheight = (int)(recup->ry / recup->ray.perpwalldist);
	recup->ray.drawstart = -recup->ray.lineheight / 2 + recup->ry / 2;
	if (recup->ray.drawstart < 0)
		recup->ray.drawstart = 0;
	recup->ray.drawend = recup->ray.lineheight / 2 + recup->ry / 2;
	if (recup->ray.drawend >= recup->ry || recup->ray.drawend < 0)
		recup->ray.drawend = recup->ry - 1;
}

// Assembly:
cmpl $0x0, 0x354(%rdi)
je 0x8787
leaq 0x324(%rdi), %rdx
leaq 0x2e0(%rdi), %rcx
movl $0x310, %eax            # imm = 0x310
movl $0x34c, %esi            # imm = 0x34C
jmp 0x879f
leaq 0x2d8(%rdi), %rcx
leaq 0x320(%rdi), %rdx
movl $0x308, %eax            # imm = 0x308
movl $0x348, %esi            # imm = 0x348
cvtsi2sdl (%rdx), %xmm0
subsd (%rcx), %xmm0
cvtsi2sdl (%rdi,%rsi), %xmm1
movsd 0x498c(%rip), %xmm2     # 0xd140
subsd %xmm1, %xmm2
mulsd 0x4948(%rip), %xmm2     # 0xd108
addsd %xmm0, %xmm2
divsd (%rdi,%rax), %xmm2
movsd %xmm2, 0x358(%rdi)
movl 0x4(%rdi), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm2, %xmm0
cvttsd2si %xmm0, %ecx
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movl %ecx, %esi
shrl $0x1f, %esi
addl %ecx, %esi
sarl %esi
movl %edx, %r8d
subl %esi, %r8d
xorl %r9d, %r9d
testl %r8d, %r8d
cmovgl %r8d, %r9d
movl %ecx, 0x360(%rdi)
movl %r9d, 0x364(%rdi)
addl %edx, %esi
leal -0x1(%rax), %ecx
testl %esi, %esi
movl %esi, %edx
cmovsl %ecx, %edx
cmpl %eax, %esi
cmovgel %ecx, %edx
movl %edx, 0x368(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_move.c
// Function: ft_forward_back
void	ft_forward_back(t_recup *recup)
{
	if (recup->data.forward == 1)
	{
		if (recup->map[(int)(recup->ray.posx + (recup->ray.dirx * recup->
						ray.movespeed * 2))][(int)recup->ray.posy] == '0')
			recup->ray.posx += recup->ray.dirx * recup->ray.movespeed;
		if (recup->map[(int)(recup->ray.posx)][(int)(recup->ray.posy +
					(recup->ray.diry * recup->ray.movespeed * 2))] == '0')
			recup->ray.posy += recup->ray.diry * recup->ray.movespeed;
	}
	if (recup->data.back == 1)
	{
		if (recup->map[(int)(recup->ray.posx - (recup->ray.dirx * recup->
						ray.movespeed * 2))][(int)(recup->ray.posy)] == '0')
			recup->ray.posx -= recup->ray.dirx * recup->ray.movespeed;
		if (recup->map[(int)(recup->ray.posx)][(int)(recup->ray.posy -
					(recup->ray.diry * recup->ray.movespeed * 2))] == '0')
			recup->ray.posy -= recup->ray.diry * recup->ray.movespeed;
	}
}

// Assembly:
cmpl $0x1, 0x2a4(%rdi)
jne 0x88e5
movq 0x48(%rdi), %rax
movsd 0x2d8(%rdi), %xmm2
movsd 0x370(%rdi), %xmm0
movsd 0x2e8(%rdi), %xmm3
mulsd %xmm0, %xmm3
movapd %xmm3, %xmm1
addsd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x2e0(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x88ad
addsd %xmm3, %xmm2
movsd %xmm2, 0x2d8(%rdi)
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0x2f0(%rdi), %xmm0
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x88e5
addsd %xmm1, %xmm0
movsd %xmm0, 0x2e0(%rdi)
cmpl $0x1, 0x2a8(%rdi)
jne 0x89a6
movq 0x48(%rdi), %rax
movsd 0x2d8(%rdi), %xmm2
movsd 0x2e8(%rdi), %xmm3
movsd 0x370(%rdi), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm1, %xmm1
movapd %xmm2, %xmm4
subsd %xmm1, %xmm4
cvttsd2si %xmm4, %ecx
movslq %ecx, %rcx
movsd 0x2e0(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x895a
xorpd 0x4806(%rip), %xmm3     # 0xd150
mulsd %xmm0, %xmm3
addsd %xmm3, %xmm2
movsd %xmm2, 0x2d8(%rdi)
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
movsd 0x2f0(%rdi), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm3
movapd %xmm1, %xmm4
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x89a6
xorpd 0x47ba(%rip), %xmm2     # 0xd150
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x2e0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_move.c
// Function: ft_left_right
void	ft_left_right(t_recup *recup)
{
	if (recup->data.right == 1)
	{
		if (recup->map[(int)(recup->ray.posx + recup->ray.diry *
					(recup->ray.movespeed * 2))][(int)recup->ray.posy] == '0')
			recup->ray.posx += recup->ray.diry * recup->ray.movespeed;
		if (recup->map[(int)recup->ray.posx][(int)(recup->ray.posy -
					recup->ray.dirx *
					(recup->ray.movespeed * 2))] == '0')
			recup->ray.posy -= recup->ray.dirx * recup->ray.movespeed;
	}
	if (recup->data.left == 1)
	{
		if (recup->map[(int)(recup->ray.posx - recup->ray.diry *
					(recup->ray.movespeed * 2))][(int)recup->ray.posy] == '0')
			recup->ray.posx -= recup->ray.diry * recup->ray.movespeed;
		if (recup->map[(int)recup->ray.posx][(int)(recup->ray.posy +
					recup->ray.dirx *
					(recup->ray.movespeed * 2))] == '0')
			recup->ray.posy += recup->ray.dirx * recup->ray.movespeed;
	}
}

// Assembly:
cmpl $0x1, 0x2b0(%rdi)
jne 0x8a58
movq 0x48(%rdi), %rax
movsd 0x2d8(%rdi), %xmm3
movsd 0x2f0(%rdi), %xmm4
movsd 0x370(%rdi), %xmm0
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movapd %xmm4, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
cvttsd2si %xmm1, %ecx
movslq %ecx, %rcx
movsd 0x2e0(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x8a14
mulsd %xmm0, %xmm4
addsd %xmm4, %xmm3
movsd %xmm3, 0x2d8(%rdi)
cvttsd2si %xmm3, %ecx
movslq %ecx, %rcx
movsd 0x2e8(%rdi), %xmm3
mulsd %xmm3, %xmm2
movapd %xmm1, %xmm4
subsd %xmm2, %xmm4
cvttsd2si %xmm4, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x8a58
xorpd 0x4708(%rip), %xmm3     # 0xd150
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x2e0(%rdi)
cmpl $0x1, 0x2ac(%rdi)
jne 0x8b09
movq 0x48(%rdi), %rax
movsd 0x2d8(%rdi), %xmm3
movsd 0x2f0(%rdi), %xmm4
movsd 0x370(%rdi), %xmm0
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
movapd %xmm4, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm3, %xmm5
subsd %xmm1, %xmm5
cvttsd2si %xmm5, %ecx
movslq %ecx, %rcx
movsd 0x2e0(%rdi), %xmm1
cvttsd2si %xmm1, %edx
movq (%rax,%rcx,8), %rcx
movslq %edx, %rdx
cmpb $0x30, (%rcx,%rdx)
jne 0x8ad1
xorpd 0x468f(%rip), %xmm4     # 0xd150
mulsd %xmm0, %xmm4
addsd %xmm4, %xmm3
movsd %xmm3, 0x2d8(%rdi)
cvttsd2si %xmm3, %ecx
movslq %ecx, %rcx
movsd 0x2e8(%rdi), %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x8b09
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x2e0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_move.c
// Function: ft_rotate_right_left
void	ft_rotate_right_left(t_recup *recup)
{
	double oldplanx;
	double olddirx;

	oldplanx = recup->ray.planx;
	olddirx = recup->ray.dirx;
	if (recup->data.rotate_right == 1)
	{
		recup->ray.dirx = recup->ray.dirx * cos(-recup->ray.rotspeed / 2) -
			recup->ray.diry * sin(-recup->ray.rotspeed / 2);
		recup->ray.diry = olddirx * sin(-recup->ray.rotspeed / 2) +
			recup->ray.diry * cos(-recup->ray.rotspeed / 2);
		recup->ray.planx = recup->ray.planx * cos(-recup->ray.rotspeed / 2)
			- recup->ray.plany * sin(-recup->ray.rotspeed / 2);
		recup->ray.plany = oldplanx * sin(-recup->ray.rotspeed / 2) +
			recup->ray.plany * cos(-recup->ray.rotspeed / 2);
	}
	ft_rotate_left(recup, olddirx);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x2b8(%rdi)
jne 0x8cb1
movsd 0x2e8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4615(%rip), %xmm0     # 0xd160
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x45ed(%rip), %xmm0     # 0xd160
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x45bb(%rip), %xmm0     # 0xd160
callq 0x7420
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4593(%rip), %xmm0     # 0xd160
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4553(%rip), %xmm0     # 0xd160
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x452b(%rip), %xmm0     # 0xd160
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x44f9(%rip), %xmm0     # 0xd160
callq 0x7420
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x44d9(%rip), %xmm0     # 0xd160
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x8cbe
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting_move.c
// Function: ft_rotate_left
void	ft_rotate_left(t_recup *recup, double olddirx)
{
	double oldplanex;

	if (recup->data.rotate_left == 1)
	{
		olddirx = recup->ray.dirx;
		oldplanex = recup->ray.planx;
		recup->ray.dirx = recup->ray.dirx * cos(recup->ray.rotspeed / 2) -
			recup->ray.diry * sin(recup->ray.rotspeed / 2);
		recup->ray.diry = olddirx * sin(recup->ray.rotspeed / 2) + recup->
			ray.diry * cos(recup->ray.rotspeed / 2);
		recup->ray.planx = recup->ray.planx * cos(recup->ray.rotspeed / 2) -
			recup->ray.plany * sin(recup->ray.rotspeed / 2);
		recup->ray.plany = oldplanex * sin(recup->ray.rotspeed / 2) +
			recup->ray.plany * cos(recup->ray.rotspeed / 2);
	}
}

// Assembly:
cmpl $0x1, 0x2b4(%rdi)
jne 0x8e6a
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0x2e8(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2f8(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x378(%rdi), %xmm0
mulsd 0x4409(%rip), %xmm0     # 0xd108
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x43e1(%rip), %xmm0     # 0xd108
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x43af(%rip), %xmm0     # 0xd108
callq 0x7420
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4387(%rip), %xmm0     # 0xd108
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4347(%rip), %xmm0     # 0xd108
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x431f(%rip), %xmm0     # 0xd108
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x42ed(%rip), %xmm0     # 0xd108
callq 0x7420
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x42cd(%rip), %xmm0     # 0xd108
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_get_texture
void	ft_get_texture(t_recup *recup)
{
	if (!(recup->texture[0].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->no, &(recup->texture[0].width),
					&(recup->texture[0].height))))
		ft_error(recup, "Texture SO\n");
	if (!(recup->texture[1].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->so, &(recup->texture[1].width),
					&(recup->texture[1].height))))
		ft_error(recup, "Texture NO\n");
	if (!(recup->texture[2].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->we, &(recup->texture[2].width),
					&(recup->texture[2].height))))
		ft_error(recup, "Texture EA\n");
	if (!(recup->texture[3].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->ea, &(recup->texture[3].width),
					&(recup->texture[3].height))))
		ft_error(recup, "Texture WE\n");
	if (!(recup->texture[4].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->sp, &(recup->texture[4].width),
					&(recup->texture[4].height))))
		ft_error(recup, "Texture S\n");
	ft_get_texture_adress(recup);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x278(%rdi), %rdi
movq 0x18(%rbx), %rsi
leaq 0xe0(%rbx), %rdx
leaq 0xe4(%rbx), %rcx
callq 0xbf10
movq %rax, 0xa8(%rbx)
testq %rax, %rax
jne 0x8f77
leaq 0x41f9(%rip), %rsi      # 0xd168
movq %rbx, %rdi
callq 0x970c
movq 0x278(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x140(%rbx), %rdx
leaq 0x144(%rbx), %rcx
callq 0xbf10
movq %rax, 0x108(%rbx)
testq %rax, %rax
jne 0x8fb0
leaq 0x41cc(%rip), %rsi      # 0xd174
movq %rbx, %rdi
callq 0x970c
movq 0x278(%rbx), %rdi
movq 0x28(%rbx), %rsi
leaq 0x1a0(%rbx), %rdx
leaq 0x1a4(%rbx), %rcx
callq 0xbf10
movq %rax, 0x168(%rbx)
testq %rax, %rax
jne 0x8fe9
leaq 0x419f(%rip), %rsi      # 0xd180
movq %rbx, %rdi
callq 0x970c
movq 0x278(%rbx), %rdi
movq 0x30(%rbx), %rsi
leaq 0x200(%rbx), %rdx
leaq 0x204(%rbx), %rcx
callq 0xbf10
movq %rax, 0x1c8(%rbx)
testq %rax, %rax
jne 0x9022
leaq 0x4172(%rip), %rsi      # 0xd18c
movq %rbx, %rdi
callq 0x970c
movq 0x278(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x260(%rbx), %rdx
leaq 0x264(%rbx), %rcx
callq 0xbf10
movq %rax, 0x228(%rbx)
testq %rax, %rax
jne 0x905b
leaq 0x4145(%rip), %rsi      # 0xd198
movq %rbx, %rdi
callq 0x970c
movq %rbx, %rdi
popq %rbx
jmp 0x8e6c