LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_map.c
// Function: ft_check_map
t_map					ft_check_map(t_map *map, int i, int j)
{
	static	t_map_funct	funct_map[255] = {NULL};
	int					x;
	int					y;

	x = 0;
	y = 0;
	if (funct_map[0] == NULL)
		set_funct_map(funct_map);
	map->number_sprite = 0;
	while (x < i + 1)
	{
		while (y < j)
		{
			if (funct_map[(int)map->mapp[x][y]] != NULL)
				funct_map[(int)map->mapp[x][y]](map, x, y);
			y++;
		}
		y = 0;
		x++;
	}
	check_pos(map);
	ft_tab_sprite(map);
	return (*map);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0xe7f1(%rip)      # 0x18ad0
jne 0xa353
leaq 0xe7e8(%rip), %rdi      # 0x18ad0
movl $0x7f0, %edx            # imm = 0x7F0
xorl %esi, %esi
callq 0x7030
movq $-0x1, 0xe7d1(%rip) # 0x18ad0
leaq -0x28ca(%rip), %rax     # 0x7a3c
movq %rax, 0xe943(%rip)      # 0x18c50
leaq 0x57c(%rip), %rax       # 0xa890
movq %rax, 0xe945(%rip)      # 0x18c60
leaq 0x290(%rip), %rax       # 0xa5b2
movq %rax, 0xea17(%rip)      # 0x18d40
leaq 0x2c2(%rip), %rax       # 0xa5f2
movq %rax, 0xea31(%rip)      # 0x18d68
leaq 0x2f4(%rip), %rax       # 0xa632
movq %rax, 0xea43(%rip)      # 0x18d88
leaq 0x326(%rip), %rax       # 0xa672
movq %rax, 0xe9a5(%rip)      # 0x18cf8
movl $0x0, 0x1c(%r14)
testl %r15d, %r15d
js 0xa3ac
incl %r15d
movl 0xc(%rsp), %ebx
xorl %r12d, %r12d
leaq 0xe75f(%rip), %rbp      # 0x18ad0
cmpl $0x0, 0xc(%rsp)
jle 0xa3a4
xorl %r13d, %r13d
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movsbq (%rax,%r13), %rax
movq (%rbp,%rax,8), %rax
testq %rax, %rax
je 0xa39c
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq *%rax
incq %r13
cmpq %r13, %rbx
jne 0xa37b
incq %r12
cmpq %r15, %r12
jne 0xa371
movq %r14, %rdi
callq 0x7908
movq %r14, %rdi
callq 0xa89e
movq 0x20(%r14), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%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/parse_map.c
// Function: read_line
int						read_line(int fd, int count)
{
	int					r;
	char				*line;

	while ((r = get_next_line(fd, &line)) == 1 && count > 1)
	{
		free(line);
		count--;
	}
	free(line);
	count = 0;
	return (count);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movl %edi, %ebx
leaq 0x8(%rsp), %rsi
callq 0xbb6b
cmpl $0x1, %eax
setne %al
cmpl $0x2, %r14d
setl %cl
orb %al, %cl
jne 0xa43c
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rdi
callq 0x7170
movl %ebx, %edi
movq %r15, %rsi
callq 0xbb6b
cmpl $0x1, %eax
jne 0xa43c
leal -0x1(%r14), %eax
cmpl $0x2, %r14d
movl %eax, %r14d
jg 0xa416
movq 0x8(%rsp), %rdi
callq 0x7170
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_map.c
// Function: ft_parse_map
t_map					ft_parse_map(int i, int j, int count, char *path)
{
	t_map				map;
	int					fd;
	char				*line;
	int					r;
	int					e;

	e = 0;
	map = set_map(&map, i, j);
	fd = open(path, O_RDONLY);
	count = read_line(fd, count);
	while ((r = get_next_line(fd, &line) >= 0 && count < i + 1))
	{
		while (line[e] != '\0')
		{
			map.mapp[count][e] = line[e];
			e++;
		}
		e = 0;
		free(line);
		count++;
	}
	free(line);
	close(fd);
	map = full_check(map, i, j);
	return (map);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movl %ecx, %r12d
movl %edx, %ecx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %ecx, 0x3c(%rsp)
callq 0xa1ac
movq 0x20(%r13), %rax
movq %rax, 0x20(%rbx)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
movl %eax, %r15d
movl %eax, %edi
movl %r12d, %esi
callq 0xa3e8
leaq 0x30(%rsp), %rsi
movl %r15d, %edi
callq 0xbb6b
orl %r14d, %eax
js 0xa51a
movslq %r14d, %r13
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
movq 0x30(%rsp), %rdi
movb (%rdi), %al
testb %al, %al
je 0xa4fa
xorl %ecx, %ecx
movq (%rbx), %rdx
movq (%rdx,%rbp,8), %rdx
movb %al, (%rdx,%rcx)
movq 0x30(%rsp), %rdi
movb 0x1(%rdi,%rcx), %al
incq %rcx
testb %al, %al
jne 0xa4e0
callq 0x7170
movl %r15d, %edi
movq %r12, %rsi
callq 0xbb6b
testl %eax, %eax
js 0xa51a
leaq 0x1(%rbp), %rax
cmpq %r13, %rbp
movq %rax, %rbp
jl 0xa4d3
movq 0x30(%rsp), %rdi
callq 0x7170
movl %r15d, %edi
callq 0x7040
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
movl 0x3c(%rsp), %edx
callq 0x7930
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_position.c
// Function: ft_secure
void	ft_secure(t_map *map)
{
	if (map->position_x != 0 || map->position_y != 0 ||
	map->position_direction != '0')
	{
		put_color("\033[31m",
		"\nError\n The beginning position is filled twice !");
		exit(0);
	}
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
jne 0xa597
cmpl $0x0, 0x14(%rdi)
jne 0xa597
cmpb $0x30, 0x18(%rdi)
jne 0xa597
retq
pushq %rax
leaq 0x4a6d(%rip), %rdi      # 0xf00c
leaq 0x4fce(%rip), %rsi      # 0xf574
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_position.c
// Function: ft_position_n
void	ft_position_n(t_map *map, int x, int y)
{
	ft_secure(map);
	map->position_x = x;
	map->position_y = y;
	if (map->mapp[x][y] == 'N')
		map->position_direction = 'N';
	ft_check_borders(map, x, y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0xa584
movl %ebp, 0x10(%r14)
movl %ebx, 0x14(%r14)
movq (%r14), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
movslq %ebx, %rcx
cmpb $0x4e, (%rax,%rcx)
jne 0xa5e2
movb $0x4e, 0x18(%r14)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x7a3c
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_position.c
// Function: ft_position_s
void	ft_position_s(t_map *map, int x, int y)
{
	ft_secure(map);
	map->position_x = x;
	map->position_y = y;
	if (map->mapp[x][y] == 'S')
		map->position_direction = 'S';
	ft_check_borders(map, x, y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0xa584
movl %ebp, 0x10(%r14)
movl %ebx, 0x14(%r14)
movq (%r14), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
movslq %ebx, %rcx
cmpb $0x53, (%rax,%rcx)
jne 0xa622
movb $0x53, 0x18(%r14)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x7a3c
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_position.c
// Function: ft_position_w
void	ft_position_w(t_map *map, int x, int y)
{
	ft_secure(map);
	map->position_x = x;
	map->position_y = y;
	if (map->mapp[x][y] == 'W')
		map->position_direction = 'W';
	ft_check_borders(map, x, y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0xa584
movl %ebp, 0x10(%r14)
movl %ebx, 0x14(%r14)
movq (%r14), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
movslq %ebx, %rcx
cmpb $0x57, (%rax,%rcx)
jne 0xa662
movb $0x57, 0x18(%r14)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x7a3c
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_position.c
// Function: ft_position_e
void	ft_position_e(t_map *map, int x, int y)
{
	ft_secure(map);
	map->position_x = x;
	map->position_y = y;
	if (map->mapp[x][y] == 'E')
		map->position_direction = 'E';
	ft_check_borders(map, x, y);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0xa584
movl %ebp, 0x10(%r14)
movl %ebx, 0x14(%r14)
movq (%r14), %rax
movslq %ebp, %rcx
movq (%rax,%rcx,8), %rax
movslq %ebx, %rcx
cmpb $0x45, (%rax,%rcx)
jne 0xa6a2
movb $0x45, 0x18(%r14)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x7a3c
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_resolution.c
// Function: ft_resolution
size_t	ft_resolution(char *line, int e, t_args *args)
{
	int i;

	i = 0;
	if (line[e] == 'R' && (ft_isspace(line[e + 1]) == 1 || line[e + 1] == 0))
	{
		i += find_i(line, e, 2);
		check_twice_res(args);
		args->reso_x = ft_atoi_test(&line[e + 1]);
		if (ft_isspace(line[e + 1]) == 0)
		{
			put_color("\033[31m", "\nError\n Missing space or arguments");
			exit(0);
		}
		i += ft_count(args->reso_x) + 1;
		args->reso_y = ft_atoi_test(&line[e + i + 1]);
		if (args->reso_y == -1 || args->reso_x == -1)
		{
			put_color(RED, "\nError\n wrong number of argument for resolution");
			exit(0);
		}
	}
	return (i + ft_count(args->reso_y) + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movslq %esi, %r13
xorl %ebp, %ebp
cmpb $0x52, (%rdi,%r13)
jne 0xa77f
movl %esi, %r15d
movq %rdi, %r14
addq %rdi, %r13
movsbl 0x1(%r13), %edi
incq %r13
callq 0xb768
cmpl $0x1, %eax
je 0xa716
cmpb $0x0, (%r13)
jne 0xa77f
movq %r14, %rdi
movl %r15d, %esi
movl $0x2, %edx
callq 0x7eec
movl %eax, %r12d
movq %rbx, %rdi
callq 0xa6b4
movq %r13, %rdi
callq 0xb7fd
movl %eax, 0x8(%rbx)
movsbl (%r13), %edi
callq 0xb768
testl %eax, %eax
je 0xa7af
movl 0x8(%rbx), %edi
callq 0xbddc
movq %rax, %r13
addl %r12d, %eax
addl %r15d, %eax
incl %eax
cltq
leaq (%r14,%rax), %rdi
incq %rdi
callq 0xb7fd
movl %eax, 0xc(%rbx)
cmpl $-0x1, %eax
je 0xa79f
cmpl $-0x1, 0x8(%rbx)
je 0xa79f
leal (%r12,%r13), %ebp
incl %ebp
movslq %ebp, %r14
movl 0xc(%rbx), %edi
callq 0xbddc
addq %r14, %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4866(%rip), %rdi      # 0xf00c
leaq 0x4e3f(%rip), %rsi      # 0xf5ec
jmp 0xa7bd
leaq 0x4856(%rip), %rdi      # 0xf00c
leaq 0x4e0c(%rip), %rsi      # 0xf5c9
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_resolution.c
// Function: check_resolution
t_args	check_resolution(t_args argy, t_mlx_coord mlxco)
{
	mlxco.size_x = malloc(sizeof(int*));
	mlxco.size_y = malloc(sizeof(int*));
	mlx_get_screen_size(mlxco.mlx, mlxco.size_x, mlxco.size_y);
	if (argy.save == 0)
	{
		if (argy.reso_x >= *mlxco.size_x)
		{
			argy.reso_x = *mlxco.size_x;
			put_color("\033[33m", "\nError\n resolution x has been resized");
		}
		if (argy.reso_y >= *mlxco.size_y)
		{
			argy.reso_y = *mlxco.size_y;
			put_color("\033[33m", "\nError\n resolution y has been resized");
		}
	}
	free(mlxco.size_x);
	free(mlxco.size_y);
	return (argy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x8, %edi
callq 0x7100
movq %rax, %r15
movq %rax, 0xc8(%rsp)
movl $0x8, %edi
callq 0x7100
movq %rax, %r12
movq %rax, 0xd0(%rsp)
movq 0xb8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe6e0
cmpl $0x0, 0x6c(%r14)
jne 0xa85e
movl (%r15), %eax
cmpl %eax, 0x8(%r14)
jl 0xa83d
movl %eax, 0x8(%r14)
leaq 0x4ad7(%rip), %rdi      # 0xf308
leaq 0x4de4(%rip), %rsi      # 0xf61c
callq 0xbf90
movl (%r12), %eax
cmpl %eax, 0xc(%r14)
jl 0xa85e
movl %eax, 0xc(%r14)
leaq 0x4ab6(%rip), %rdi      # 0xf308
leaq 0x4de9(%rip), %rsi      # 0xf642
callq 0xbf90
movq %r15, %rdi
callq 0x7170
movq %r12, %rdi
callq 0x7170
movl $0x88, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/parse_sprite.c
// Function: ft_tab_sprite
void		ft_tab_sprite(t_map *map)
{
	int		x;
	int		y;
	int		i;

	x = 0;
	y = 0;
	i = 0;
	if (!(map->sprite = malloc(sizeof(t_sprite) * map->number_sprite)))
		return ;
	while (x < map->height_map)
	{
		while (y < map->width_map)
		{
			if (map->mapp[x][y] == '2' && i < map->number_sprite)
			{
				map->sprite[i] = load_sprites(map->sprite[i], x, y);
				i++;
			}
			y++;
		}
		y = 0;
		x++;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x1c(%rdi), %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xa915
cmpl $0x0, 0xc(%rbx)
jle 0xa915
xorl %eax, %eax
movabsq $0x100000000, %rcx      # imm = 0x100000000
xorl %edx, %edx
xorl %esi, %esi
cmpl $0x0, 0x8(%rbx)
jle 0xa906
xorl %edi, %edi
movq (%rbx), %r8
movq (%r8,%rdx,8), %r8
cmpb $0x32, (%r8,%rdi)
jne 0xa8fa
cmpl 0x1c(%rbx), %esi
jge 0xa8fa
movq 0x20(%rbx), %r8
movslq %esi, %r9
leaq (%rax,%rdi), %r10
movq %r10, (%r8,%r9,8)
incl %esi
incq %rdi
movslq 0x8(%rbx), %r8
cmpq %r8, %rdi
jl 0xa8d6
incq %rdx
movslq 0xc(%rbx), %rdi
addq %rcx, %rax
cmpq %rdi, %rdx
jl 0xa8ce
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_sprite.c
// Function: free_text
void		free_text(t_args *args, char *line)
{
	if (args->text_east != NULL)
		free(args->text_east);
	if (args->text_west != NULL)
		free(args->text_west);
	if (args->text_south != NULL)
		free(args->text_south);
	if (args->text_north != NULL)
		free(args->text_north);
	free(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xa930
callq 0x7170
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0xa93e
callq 0x7170
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xa94c
callq 0x7170
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0xa95a
callq 0x7170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7170
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_sprite.c
// Function: ft_check_path_sprite
int			ft_check_path_sprite(char *line, int e, char *path, t_args *args)
{
	int		i;

	i = 0;
	if (line[e] != 'm' && line[e - 1] != 'p' &&
		line[e - 2] != 'x' && line[e - 3] != '.')
	{
		put_color("\033[31m",
		"\nError\n wrong format for sprite check your path");
		free_text(args, line);
		exit(0);
	}
	e = 0;
	line[0] = '1';
	if ((i = open(path, O_RDONLY)) == -1)
	{
		put_color("\033[31m",
		"\nError\n file can't open for sprite check your path");
		free_text(args, line);
		exit(0);
	}
	else
		close(i);
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movslq %esi, %rax
cmpb $0x6d, (%rdi,%rax)
je 0xa994
cmpb $0x70, -0x1(%r14,%rax)
je 0xa994
cmpb $0x78, -0x2(%r14,%rax)
je 0xa994
cmpb $0x2e, -0x3(%r14,%rax)
jne 0xa9e2
movb $0x31, (%r14)
movq %rdx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
cmpl $-0x1, %eax
je 0xa9bd
movl %eax, %edi
callq 0x7040
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4648(%rip), %rdi      # 0xf00c
leaq 0x4ccd(%rip), %rsi      # 0xf698
callq 0xbf90
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa918
xorl %edi, %edi
callq 0x70a0
leaq 0x4623(%rip), %rdi      # 0xf00c
leaq 0x4c78(%rip), %rsi      # 0xf668
jmp 0xa9cb
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_sprite.c
// Function: ft_s_case
size_t		ft_s_case(char *line, int e, t_args *args)
{
	size_t	i;

	i = 0;
	if (line[e] == 'S' && line[e + 1] == 'O')
		i = ft_texture_south(line, e, args);
	else if (line[e] == 'S' && (ft_isspace(line[e + 1]) == 1 ||
	line[e + 1] == 0))
		i = ft_texture_sprite(line, e, args);
	return (i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq %esi, %r15
movb (%rdi,%r15), %al
cmpb $0x53, %al
jne 0xaa47
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x4f, 0x1(%rdi,%r15)
jne 0xaa2b
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xae09
cmpb $0x53, %al
jne 0xaa47
movsbl 0x1(%r14,%r15), %edi
callq 0xb768
cmpl $0x1, %eax
je 0xaa54
cmpb $0x0, 0x1(%r14,%r15)
je 0xaa54
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaa6b
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_sprite.c
// Function: ft_texture_sprite
size_t		ft_texture_sprite(char *line, int e, t_args *args)
{
	int		i;
	int		j;
	char	*path;

	i = 0;
	j = 0;
	if (line[e] == 'S' && (ft_isspace(line[e + 1]) == 1 || line[e + 1] == 0))
	{
		i = check_twice_sprite(args, line, e);
		j = find_j(line, (e + i));
		if (!(path = malloc(sizeof(char) * (j + 1))))
			return (0);
		path = put_path(e + i + 2, path, line);
		if (ft_check_path_sprite(line, (e + i + j + 1), path, args) == 1)
		{
			args->text_sprite = path;
			args->error_sprite = 1;
		}
		else
		{
			args->error_sprite = 0;
			free_text(args, line);
		}
	}
	return (e + i + j + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %r13
xorl %r15d, %r15d
cmpb $0x53, (%rdi,%r13)
jne 0xab16
movq %rdx, %r14
movq %rdi, %r12
movsbl 0x1(%rdi,%r13), %edi
callq 0xb768
cmpl $0x1, %eax
je 0xaab1
cmpb $0x0, 0x1(%r12,%r13)
movl $0x0, %r13d
jne 0xab4a
movq %r14, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7b90
movl %eax, %r15d
leal (%r15,%rbx), %r14d
movq %r12, %rdi
movl %r14d, %esi
callq 0x7ed0
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0xab1b
movq %rax, %rbp
movslq %r14d, %rcx
movb 0x2(%r12,%rcx), %al
testb %al, %al
je 0xab1f
addq $0x2, %rcx
leaq (%rcx,%r12), %rdx
incq %rdx
xorl %ecx, %ecx
movb %al, (%rbp,%rcx)
movb (%rdx,%rcx), %al
incq %rcx
testb %al, %al
jne 0xab04
movl %ecx, %eax
jmp 0xab21
xorl %r13d, %r13d
jmp 0xab4a
xorl %eax, %eax
jmp 0xab55
xorl %eax, %eax
movb $0x0, (%rbp,%rax)
leal (%r14,%r13), %esi
incl %esi
movq %r12, %rdi
movq %rbp, %rdx
movq (%rsp), %r14
movq %r14, %rcx
callq 0xa969
movq %rbp, 0x38(%r14)
movl $0x1, 0x50(%r14)
addl %r15d, %ebx
leal (%rbx,%r13), %eax
incl %eax
cltq
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/path_sprite.c
// Function: put_path
char		*put_path(int i, char *path, char *line)
{
	int		j;

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

// Assembly:
movq %rsi, %rax
movslq %edi, %rsi
movb (%rdx,%rsi), %cl
testb %cl, %cl
je 0xab8a
addq %rdx, %rsi
incq %rsi
xorl %edx, %edx
movb %cl, (%rax,%rdx)
movb (%rsi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xab79
movl %edx, %ecx
jmp 0xab8c
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_texture.c
// Function: ft_check_path_text
int			ft_check_path_text(char *line, int e, char *path)
{
	int		i;

	i = 0;
	if (line[e] != 'm' && line[e - 1] != 'p' &&
		line[e - 2] != 'x' && line[e - 3] != '.')
	{
		put_color("\033[33m",
		"\nError\n wrong format for texture");
		exit(0);
	}
	e = 0;
	line[0] = '1';
	if ((i = open(path, O_RDONLY)) == -1)
	{
		put_color("\033[33m",
		"\nError\n texture can't be open");
		exit(0);
	}
	else
		close(i);
	return (1);
}

// Assembly:
pushq %rax
movslq %esi, %rax
cmpb $0x6d, (%rdi,%rax)
je 0xabb3
cmpb $0x70, -0x1(%rdi,%rax)
je 0xabb3
cmpb $0x78, -0x2(%rdi,%rax)
je 0xabb3
cmpb $0x2e, -0x3(%rdi,%rax)
jne 0xabef
movb $0x31, (%rdi)
movq %rdx, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7400
cmpl $-0x1, %eax
je 0xabd5
movl %eax, %edi
callq 0x7040
movl $0x1, %eax
popq %rcx
retq
leaq 0x472c(%rip), %rdi      # 0xf308
leaq 0x4b09(%rip), %rsi      # 0xf6ec
callq 0xbf90
xorl %edi, %edi
callq 0x70a0
leaq 0x4712(%rip), %rdi      # 0xf308
leaq 0x4ace(%rip), %rsi      # 0xf6cb
jmp 0xabe3
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_texture.c
// Function: ft_texture_north
size_t		ft_texture_north(char *line, int e, t_args *args)
{
	int		i;
	int		j;
	char	*path;

	i = 0;
	j = 0;
	if (line[e] == 'N' && line[e + 1] == 'O')
	{
		i = check_twice_north(args, line, e);
		j = find_j(line, (e + i));
		if (!(path = malloc(sizeof(char) * (j + 1))))
			return (0);
		path = put_path(e + i + 2, path, line);
		if (ft_check_path_text(line, (e + i + j + 1), path) == 1)
		{
			args->text_north = path;
			args->error_north = 1;
		}
		else
		{
			args->error_north = 0;
			free(path);
		}
	}
	return (e + i + j + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %rax
xorl %r15d, %r15d
cmpb $0x4e, (%rdi,%rax)
jne 0xac8c
movq %rdi, %r12
cmpb $0x4f, 0x1(%rdi,%rax)
movl $0x0, %r13d
jne 0xac8f
movq %rdx, %r14
movq %rdx, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7ad0
movl %eax, %r15d
leal (%r15,%rbx), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x7ed0
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0xaca9
leal 0x2(%rbp), %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0xab64
leal 0x1(%r13,%rbp), %esi
movq %r12, %rdi
movq %rax, %r12
movq %rax, %rdx
callq 0xab94
movq %r12, 0x18(%r14)
movl $0x1, 0x40(%r14)
jmp 0xac8f
xorl %r13d, %r13d
addl %r15d, %ebx
leal (%rbx,%r13), %eax
incl %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xac9a
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_texture.c
// Function: ft_texture_west
size_t		ft_texture_west(char *line, int e, t_args *args)
{
	int		i;
	int		j;
	char	*path;

	i = 0;
	j = 0;
	if (line[e] == 'W' && line[e + 1] == 'E')
	{
		i = check_twice_west(args, line, e);
		j = find_j(line, (e + i));
		if (!(path = malloc(sizeof(char) * (j + 1))))
			return (0);
		path = put_path(e + i + 2, path, line);
		if (ft_check_path_text(line, (e + i + j + 1), path) == 1)
		{
			args->text_west = path;
			args->error_west = 1;
		}
		else
		{
			args->error_west = 0;
			free(path);
		}
	}
	return (e + i + j + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %rax
xorl %r15d, %r15d
cmpb $0x57, (%rdi,%rax)
jne 0xad3a
movq %rdi, %r12
cmpb $0x45, 0x1(%rdi,%rax)
movl $0x0, %r13d
jne 0xad3d
movq %rdx, %r14
movq %rdx, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7b60
movl %eax, %r15d
leal (%r15,%rbx), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x7ed0
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0xad57
leal 0x2(%rbp), %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0xab64
leal 0x1(%r13,%rbp), %esi
movq %r12, %rdi
movq %rax, %r12
movq %rax, %rdx
callq 0xab94
movq %r12, 0x28(%r14)
movl $0x1, 0x48(%r14)
jmp 0xad3d
xorl %r13d, %r13d
addl %r15d, %ebx
leal (%rbx,%r13), %eax
incl %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xad48
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_texture.c
// Function: ft_texture_east
size_t		ft_texture_east(char *line, int e, t_args *args)
{
	int		i;
	int		j;
	char	*path;

	i = 0;
	j = 0;
	if (line[e] == 'E' && line[e + 1] == 'A')
	{
		i = check_twice_east(args, line, e);
		j = find_j(line, (e + i));
		if (!(path = malloc(sizeof(char) * (j + 1))))
			return (0);
		path = put_path(e + i + 2, path, line);
		if (ft_check_path_text(line, (e + i + j + 1), path) == 1)
		{
			args->text_east = path;
			args->error_east = 1;
		}
		else
		{
			args->error_east = 0;
			free(path);
		}
	}
	return (e + i + j + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %rax
xorl %r15d, %r15d
cmpb $0x45, (%rdi,%rax)
jne 0xade8
movq %rdi, %r12
cmpb $0x41, 0x1(%rdi,%rax)
movl $0x0, %r13d
jne 0xadeb
movq %rdx, %r14
movq %rdx, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7b30
movl %eax, %r15d
leal (%r15,%rbx), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x7ed0
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0xae05
leal 0x2(%rbp), %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0xab64
leal 0x1(%r13,%rbp), %esi
movq %r12, %rdi
movq %rax, %r12
movq %rax, %rdx
callq 0xab94
movq %r12, 0x30(%r14)
movl $0x1, 0x4c(%r14)
jmp 0xadeb
xorl %r13d, %r13d
addl %r15d, %ebx
leal (%rbx,%r13), %eax
incl %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xadf6
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/path_texture.c
// Function: ft_texture_south
size_t		ft_texture_south(char *line, int e, t_args *args)
{
	int		i;
	int		j;
	char	*path;

	j = 0;
	i = 0;
	if (line[e] == 'S' && line[e + 1] == 'O')
	{
		i = check_twice_south(args, line, e);
		j = find_j(line, (e + i));
		if (!(path = malloc(sizeof(char) * (j + 1))))
			return (0);
		path = put_path(e + i + 2, path, line);
		if (ft_check_path_text(line, (e + i + j + 1), path) == 1)
		{
			args->text_south = path;
			args->error_south = 1;
		}
		else
		{
			args->error_south = 0;
			free(path);
		}
	}
	return (e + i + j + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq %esi, %rax
xorl %r15d, %r15d
cmpb $0x53, (%rdi,%rax)
jne 0xae96
movq %rdi, %r12
cmpb $0x4f, 0x1(%rdi,%rax)
movl $0x0, %r13d
jne 0xae99
movq %rdx, %r14
movq %rdx, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x7b00
movl %eax, %r15d
leal (%r15,%rbx), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x7ed0
movl %eax, %r13d
leal 0x1(%r13), %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0xaeb3
leal 0x2(%rbp), %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0xab64
leal 0x1(%r13,%rbp), %esi
movq %r12, %rdi
movq %rax, %r12
movq %rax, %rdx
callq 0xab94
movq %r12, 0x20(%r14)
movl $0x1, 0x44(%r14)
jmp 0xae99
xorl %r13d, %r13d
addl %r15d, %ebx
leal (%rbx,%r13), %eax
incl %eax
cltq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xaea4
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/rotation.c
// Function: rotate_right
void	rotate_right(t_img_coord *co)
{
	double	old_dirx;
	double	old_planex;
	double	rotspeed;

	rotspeed = 0.01;
	old_dirx = co->dirx;
	old_planex = co->planex;
	co->dirx = co->dirx * cos(rotspeed) - co->diry * sin(rotspeed);
	co->diry = old_dirx * sin(rotspeed) + co->diry * cos(rotspeed);
	co->planex = co->planex * cos(rotspeed) - co->planey * sin(rotspeed);
	co->planey = old_planex * sin(rotspeed) + co->planey * cos(rotspeed);
	co->x = 0;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
movsd 0x4841(%rip), %xmm3     # 0xf710
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
movsd 0x4839(%rip), %xmm5     # 0xf718
movapd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm4, %xmm6
movsd %xmm6, 0x10(%rdi)
mulsd %xmm5, %xmm2
movsd 0x4824(%rip), %xmm4     # 0xf720
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x28(%rdi), %xmm1
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, 0x20(%rdi)
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rdi)
movl $0x0, 0xa4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/rotation.c
// Function: rotate_left
void	rotate_left(t_img_coord *co)
{
	double	old_dirx;
	double	old_planex;
	double	rotspeed;

	rotspeed = -0.01;
	old_dirx = co->dirx;
	old_planex = co->planex;
	co->dirx = co->dirx * cos(rotspeed) - co->diry * sin(rotspeed);
	co->diry = old_dirx * sin(rotspeed) + co->diry * cos(rotspeed);
	co->planex = co->planex * cos(rotspeed) - co->planey * sin(rotspeed);
	co->planey = old_planex * sin(rotspeed) + co->planey * cos(rotspeed);
	co->x = 0;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
movsd 0x47ca(%rip), %xmm3     # 0xf720
movapd %xmm2, %xmm4
mulsd %xmm3, %xmm4
movsd 0x47b2(%rip), %xmm5     # 0xf718
movapd %xmm1, %xmm6
mulsd %xmm5, %xmm6
addsd %xmm4, %xmm6
movsd %xmm6, 0x10(%rdi)
mulsd %xmm5, %xmm2
movsd 0x478d(%rip), %xmm4     # 0xf710
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rdi)
movsd 0x28(%rdi), %xmm1
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm5, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, 0x20(%rdi)
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rdi)
movl $0x0, 0xa4(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/texture_valid.c
// Function: texture_valid
int		texture_valid(t_img_coord *co, int i)
{
	if (i == 0 && co->argi.error_north == 1)
		return (1);
	if (i == 1 && co->argi.error_south == 1)
		return (1);
	if (i == 2 && co->argi.error_east == 1)
		return (1);
	if (i == 3 && co->argi.error_west == 1)
		return (1);
	return (0);
}

// Assembly:
cmpl $0x3, %esi
ja 0xb035
movl %esi, %eax
leaq 0x4752(%rip), %rcx      # 0xf728
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %eax
cmpl $0x1, 0x178(%rdi)
je 0xb037
cmpl $0x3, %esi
je 0xb027
cmpl $0x2, %esi
je 0xb014
cmpl $0x1, %esi
jne 0xb035
movl $0x1, %eax
cmpl $0x1, 0x17c(%rdi)
je 0xb037
cmpl $0x3, %esi
je 0xb027
cmpl $0x2, %esi
jne 0xb035
movl $0x1, %eax
cmpl $0x1, 0x184(%rdi)
je 0xb037
cmpl $0x3, %esi
jne 0xb035
movl $0x1, %eax
cmpl $0x1, 0x180(%rdi)
je 0xb037
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured.c
// Function: manage_3d
t_img_coord		manage_3d(t_img_coord *co)
{
	while (co->x < co->argi.reso_x)
	{
		init_calc_finder(co, co->argi);
		dir_dist_finder(co);
		dda_calc(co);
		dist_heigh_calc(co);
		start_end_calc(co);
		texture_calc(co);
		draw_3d(co);
		co->buf_sprit[co->x] = co->longueur_mur;
		co->x++;
	}
	sprite_cast(co);
	draw_minimap(co);
	if (co->argi.save == 0)
		mlx_put_image_to_window(co->mlx.mlx, co->mlx.mlx_win,
		co->img->img, 0, 0);
	return (*co);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
movq %rdi, %rbx
movl 0xa4(%rsi), %eax
cmpl 0x140(%rsi), %eax
jge 0xb0f5
leaq 0x138(%r14), %r15
leaq 0x90(%rsp), %r12
movl $0x11, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movq %r14, %rsi
callq 0xb153
movq %r12, %rdi
movq %r14, %rsi
callq 0xb24a
movq %r12, %rdi
movq %r14, %rsi
callq 0xb30b
movq %r12, %rdi
movq %r14, %rsi
callq 0xb4bc
movq %r12, %rdi
movq %r14, %rsi
callq 0xb552
movq %r14, %rdi
callq 0x94a4
movq %r12, %rdi
movq %r14, %rsi
callq 0xb687
movsd 0x78(%r14), %xmm0
movq 0xc0(%r14), %rax
movslq 0xa4(%r14), %rcx
movsd %xmm0, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0xa4(%r14)
cmpl 0x140(%r14), %eax
jl 0xb06d
movq %r14, %rdi
callq 0x9187
movq %r14, %rdi
callq 0x999b
cmpl $0x0, 0x1a4(%r14)
jne 0xb131
movq 0x110(%r14), %rdi
movq 0x118(%r14), %rsi
movq 0x130(%r14), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xce10
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured.c
// Function: init_calc_finder
t_img_coord		init_calc_finder(t_img_coord *co, t_args argy)
{
	co->rayposx = co->posx;
	co->rayposy = co->posy;
	co->camerax = 2 * co->x / (double)(argy.reso_x) - 1;
	co->raydirx = co->dirx + co->planex * co->camerax;
	co->raydiry = co->diry + co->planey * co->camerax;
	co->mapx = (int)co->rayposx;
	co->mapy = (int)co->rayposy;
	co->dist2murx = sqrt(1 + (co->raydiry * co->raydiry) /
	(co->raydirx * co->raydirx));
	co->dist2mury = sqrt(1 + (co->raydirx * co->raydirx) /
	(co->raydiry * co->raydiry));
	return (*co);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
movsd %xmm1, 0x30(%rsi)
movsd %xmm2, 0x38(%rsi)
movl 0xa4(%rsi), %eax
addl %eax, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0x28(%rsp), %xmm3
divsd %xmm3, %xmm0
addsd 0x45ad(%rip), %xmm0     # 0xf738
movsd %xmm0, 0x50(%rsi)
movsd 0x20(%rsi), %xmm3
mulsd %xmm0, %xmm3
addsd 0x10(%rsi), %xmm3
movsd %xmm3, 0x40(%rsi)
mulsd 0x28(%rsi), %xmm0
addsd 0x18(%rsi), %xmm0
movq %rdi, %r14
movsd %xmm0, 0x48(%rsi)
cvttsd2si %xmm1, %eax
movl %eax, 0x98(%rsi)
cvttsd2si %xmm2, %eax
mulsd %xmm0, %xmm0
mulsd %xmm3, %xmm3
divsd %xmm3, %xmm0
addsd 0x4249(%rip), %xmm0     # 0xf420
movl %eax, 0x9c(%rsi)
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0xb1ed
sqrtsd %xmm0, %xmm0
jmp 0xb1f6
callq 0x73d0
xorpd %xmm2, %xmm2
movsd %xmm0, 0x68(%rbx)
movsd 0x40(%rbx), %xmm0
movsd 0x48(%rbx), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
addsd 0x4207(%rip), %xmm0     # 0xf420
ucomisd %xmm2, %xmm0
jb 0xb225
sqrtsd %xmm0, %xmm0
jmp 0xb22a
callq 0x73d0
movsd %xmm0, 0x70(%rbx)
movl $0x1e8, %edx            # imm = 0x1E8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured.c
// Function: dir_dist_finder
t_img_coord		dir_dist_finder(t_img_coord *co)
{
	if (co->raydirx < 0)
	{
		co->etapex = -1;
		co->dist_murx = (co->rayposx - co->mapx) * co->dist2murx;
	}
	else
	{
		co->etapex = 1;
		co->dist_murx = (co->mapx + 1.0 - co->rayposx) * co->dist2murx;
	}
	if (co->raydiry < 0)
	{
		co->etapey = -1;
		co->dist_mury = (co->rayposy - co->mapy) * co->dist2mury;
	}
	else
	{
		co->etapey = 1;
		co->dist_mury = (co->mapy + 1.0 - co->rayposy) * co->dist2mury;
	}
	return (*co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorpd %xmm0, %xmm0
ucomisd 0x40(%rsi), %xmm0
jbe 0xb276
movl $0xffffffff, 0x8c(%rsi) # imm = 0xFFFFFFFF
movsd 0x30(%rsi), %xmm0
cvtsi2sdl 0x98(%rsi), %xmm1
subsd %xmm1, %xmm0
jmp 0xb298
movl $0x1, 0x8c(%rsi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x98(%rsi), %xmm0
addsd 0x418d(%rip), %xmm0     # 0xf420
subsd 0x30(%rsi), %xmm0
mulsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x58(%rsi)
xorpd %xmm0, %xmm0
ucomisd 0x48(%rsi), %xmm0
jbe 0xb2cd
movl $0xffffffff, 0x90(%rsi) # imm = 0xFFFFFFFF
movsd 0x38(%rsi), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x9c(%rsi), %xmm1
subsd %xmm1, %xmm0
jmp 0xb2ef
movl $0x1, 0x90(%rsi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x9c(%rsi), %xmm0
addsd 0x4136(%rip), %xmm0     # 0xf420
subsd 0x38(%rsi), %xmm0
mulsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x60(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured.c
// Function: dda_calc
t_img_coord		dda_calc(t_img_coord *co)
{
	int			touche;

	touche = 0;
	while (touche == 0)
	{
		if (co->dist_murx < co->dist_mury)
		{
			co->dist_murx += co->dist2murx;
			co->mapx += co->etapex;
			co->hori_verti = 0;
		}
		else
		{
			co->dist_mury += co->dist2mury;
			co->mapy += co->etapey;
			co->hori_verti = 1;
		}
		if (co->mapi.mapp[co->mapy][co->mapx] == '1')
			touche = 1;
	}
	return (*co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1c0(%rsi), %rax
movsd 0x58(%rsi), %xmm0
movsd 0x60(%rsi), %xmm1
movl 0x9c(%rsi), %ecx
movl 0x98(%rsi), %edx
ucomisd %xmm0, %xmm1
jbe 0xb354
addsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x58(%rsi)
addl 0x8c(%rsi), %edx
movl %edx, 0x98(%rsi)
movl $0x0, 0x94(%rsi)
jmp 0xb374
addsd 0x70(%rsi), %xmm1
movsd %xmm1, 0x60(%rsi)
addl 0x90(%rsi), %ecx
movl %ecx, 0x9c(%rsi)
movl $0x1, 0x94(%rsi)
movslq %ecx, %rdi
movq (%rax,%rdi,8), %rdi
movslq %edx, %r8
cmpb $0x31, (%rdi,%r8)
jne 0xb32c
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured.c
// Function: init_imgco
t_img_coord		init_imgco(t_img_coord imgco, t_map mapy)
{
	imgco.mapi = mapy;
	imgco.posx = mapy.position_y;
	imgco.posy = mapy.position_x;
	imgco.camerax = 0;
	imgco.dist_murx = 0;
	imgco.dist_mury = 0;
	imgco.longueur_mur = 0;
	imgco.etapex = 0;
	imgco.etapey = 0;
	imgco.hori_verti = 2;
	imgco.mapx = 0;
	imgco.mapy = 0;
	imgco.x = 0;
	imgco = init_position(imgco);
	imgco = init_color(imgco);
	imgco.count = 0;
	return (imgco);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3d8, %rsp            # imm = 0x3D8
movq %rdi, %rbx
movq 0x608(%rsp), %rax
leaq 0x400(%rsp), %r14
movq %rax, 0x1e0(%r14)
movups 0x5e8(%rsp), %xmm0
movups 0x5f8(%rsp), %xmm1
movaps %xmm1, 0x1d0(%r14)
movaps %xmm0, 0x1c0(%r14)
xorps %xmm0, %xmm0
cvtsi2sdl 0x5fc(%rsp), %xmm0
movsd %xmm0, (%r14)
xorps %xmm0, %xmm0
cvtsi2sdl 0x5f8(%rsp), %xmm0
movsd %xmm0, 0x8(%r14)
xorl %r12d, %r12d
movq %r12, 0x78(%r14)
movq %r12, 0x8c(%r14)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x50(%r14)
movq %r12, 0x60(%r14)
movq $0x2, 0x94(%r14)
movl %r12d, 0x9c(%r14)
movl %r12d, 0xa4(%r14)
movl $0x3d, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1f0(%rsp), %r15
movq %r15, %rdi
callq 0x8cb6
movl $0x1e8, %edx            # imm = 0x1E8
movq %r14, %rdi
movq %r15, %rsi
callq 0x73f0
movl $0x3d, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x1f0(%rsp), %r15
movq %r15, %rdi
callq 0x8b52
movl $0x1e8, %edx            # imm = 0x1E8
movq %r14, %rdi
movq %r15, %rsi
callq 0x73f0
movl %r12d, 0xb8(%r14)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x3d8, %rsp            # imm = 0x3D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured_two.c
// Function: dist_heigh_calc
t_img_coord	dist_heigh_calc(t_img_coord *co)
{
	if (co->hori_verti == 0)
	{
		co->longueur_mur = fabs((co->mapx - co->rayposx +
		(1 - co->etapex) / 2) / co->raydirx);
	}
	else
	{
		co->longueur_mur = fabs((co->mapy - co->rayposy +
		(1 - co->etapey) / 2) / co->raydiry);
	}
	co->hauteur_mur = (int)(co->argi.reso_y / co->longueur_mur);
	return (*co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x94(%rsi)
je 0xb4e4
cvtsi2sdl 0x9c(%rsi), %xmm0
subsd 0x38(%rsi), %xmm0
leaq 0x90(%rsi), %rcx
movl $0x48, %eax
jmp 0xb4fd
cvtsi2sdl 0x98(%rsi), %xmm0
subsd 0x30(%rsi), %xmm0
leaq 0x8c(%rsi), %rcx
movl $0x40, %eax
movl $0x1, %edx
subl (%rcx), %edx
movl %edx, %ecx
shrl $0x1f, %ecx
addl %edx, %ecx
sarl %ecx
cvtsi2sd %ecx, %xmm1
addsd %xmm0, %xmm1
divsd (%rsi,%rax), %xmm1
andpd 0x421e(%rip), %xmm1     # 0xf740
movlpd %xmm1, 0x78(%rsi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x144(%rsi), %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x88(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured_two.c
// Function: start_end_calc
t_img_coord	start_end_calc(t_img_coord *co)
{
	co->drawstart = -co->hauteur_mur / 2 + co->argi.reso_y / 2;
	if (co->drawstart < 0)
		co->drawstart = 0;
	co->drawend = co->hauteur_mur / 2 + co->argi.reso_y / 2;
	if (co->drawend >= co->argi.reso_y)
		co->drawend = co->argi.reso_y - 1;
	return (*co);
}

// Assembly:
pushq %rbx
movl 0x88(%rsi), %eax
movl 0x144(%rsi), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
movl %eax, %r8d
shrl $0x1f, %r8d
addl %eax, %r8d
sarl %r8d
movl %edx, %eax
subl %r8d, %eax
xorl %r9d, %r9d
testl %eax, %eax
cmovgl %eax, %r9d
movq %rdi, %rbx
movl %r9d, 0xa8(%rsi)
addl %edx, %r8d
leal -0x1(%rcx), %eax
cmpl %ecx, %r8d
cmovll %r8d, %eax
movl %eax, 0xac(%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/world_textured_two.c
// Function: verif_3d
t_img_coord	verif_3d(t_img_coord *co)
{
	if (co->drawend < 0)
		co->drawend = co->argi.reso_y;
	else if (co->drawend > co->argi.reso_y)
		co->drawend = co->argi.reso_y;
	if (co->drawstart < 0)
		co->drawstart = 0;
	else if (co->drawstart > co->argi.reso_y)
		co->drawstart = co->argi.reso_y;
	return (*co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xac(%rsi), %ecx
movl 0x144(%rsi), %eax
testl %ecx, %ecx
sets %dl
cmpl %eax, %ecx
setg %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0xb5d6
movl %eax, 0xac(%rsi)
movl 0xa8(%rsi), %ecx
testl %ecx, %ecx
js 0xb5ec
movl 0x144(%rsi), %eax
cmpl %eax, %ecx
jg 0xb5ee
jmp 0xb5f4
xorl %eax, %eax
movl %eax, 0xa8(%rsi)
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured_two.c
// Function: draw_text
t_img_coord	draw_text(t_img_coord *co)
{
	int j;

	j = 0;
	while (j < 4)
	{
		if (co->text[j]->error == 1)
		{
			co->text[j]->step = 1.0 * co->text[j]->height / co->hauteur_mur;
			co->text[j]->tex_pos = (co->drawstart -
			co->argi.reso_y / 2 + co->hauteur_mur / 2) * co->text[j]->step;
		}
		j++;
	}
	return (*co);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1e, %eax
movq (%rsi,%rax,8), %rcx
cmpl $0x1, 0x50(%rcx)
jne 0xb66c
xorps %xmm0, %xmm0
cvtsi2sdl 0x34(%rcx), %xmm0
movl 0x88(%rsi), %edx
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rcx)
movl 0x144(%rsi), %edi
movl %edi, %r8d
shrl $0x1f, %r8d
addl %edi, %r8d
sarl %r8d
movl %edx, %edi
shrl $0x1f, %edi
addl %edx, %edi
sarl %edi
addl 0xa8(%rsi), %edi
subl %r8d, %edi
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x48(%rcx)
incq %rax
cmpq $0x22, %rax
jne 0xb60f
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
callq 0x73f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/world_textured_two.c
// Function: draw_3d
t_img_coord	draw_3d(t_img_coord *co)
{
	int	i;
	int	e;

	verif_3d(co);
	i = 0;
	e = co->drawend;
	while (i < co->drawstart && i < (co->argi.reso_y / 2))
	{
		my_mlx_pixel_put(co->img, co->x, i, co->color_ceiling);
		i++;
	}
	draw_text(co);
	while (i < e)
	{
		co->i = i;
		draw_texture(co);
		i++;
	}
	while (i < co->argi.reso_y)
	{
		my_mlx_pixel_put(co->img, co->x, i, co->color_floor);
		i++;
	}
	return (*co);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xb5af
movl 0xac(%r14), %r15d
cmpl $0x0, 0xa8(%r14)
jle 0xb6f2
xorl %ebp, %ebp
movl 0x144(%r14), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, %ebp
jge 0xb6f4
movq 0x130(%r14), %rdi
movl 0xa4(%r14), %esi
movl 0xb4(%r14), %ecx
movl %ebp, %edx
callq 0x8438
incl %ebp
cmpl 0xa8(%r14), %ebp
jl 0xb6b5
jmp 0xb6f4
xorl %ebp, %ebp
movq %rsp, %rdi
movq %r14, %rsi
callq 0xb606
cmpl %r15d, %ebp
jge 0xb73d
movl %ebp, 0xa0(%r14)
movq %r14, %rdi
callq 0x93cf
incl %ebp
cmpl %ebp, %r15d
jne 0xb704
movl %r15d, %ebp
jmp 0xb73d
movq 0x130(%r14), %rdi
movl 0xa4(%r14), %esi
movl 0xb0(%r14), %ecx
movl %ebp, %edx
callq 0x8438
incl %ebp
cmpl 0x144(%r14), %ebp
jl 0xb71f
movl $0x1e8, %edx            # imm = 0x1E8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73f0
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_atoi.c
// Function: ft_atoi
int				ft_atoi(const char *str)
{
	long int	i;
	long int	resu;
	long int	sign;
	long int	test;

	i = 0;
	resu = 0;
	sign = 1;
	test = 0;
	while (str[i] != '\0' && ft_isspace(str[i]) == 1)
		i++;
	while (str[i] == '-' || str[i] == '+')
	{
		if (str[i] == '-')
			sign = -1;
		i++;
		test++;
	}
	while ((str[i] != '\0') && (str[i] >= '0' && str[i] <= '9'))
		resu = resu * 10 + (str[i++] - '0');
	if (test > 1)
		return (0);
	return (sign * resu);
}

// Assembly:
incq %rdi
movzbl -0x1(%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jb 0xb77e
cmpl $0x20, %eax
je 0xb77e
movl $0x1, %ecx
xorl %edx, %edx
movq $-0x1, %rax
movzbl -0x1(%rdi), %esi
cmpl $0x2b, %esi
je 0xb7ae
cmpl $0x2d, %esi
jne 0xb7be
cmpb $0x2d, %sil
cmoveq %rax, %rcx
incq %rdx
incq %rdi
jmp 0xb7a0
movb -0x1(%rdi), %r8b
leal -0x30(%r8), %eax
xorl %esi, %esi
cmpb $0x9, %al
ja 0xb7f0
xorl %eax, %eax
leaq (%rax,%rax,4), %rax
addb $-0x30, %r8b
movzbl %r8b, %r8d
leaq (%r8,%rax,2), %rax
movb (%rdi), %r8b
leal -0x30(%r8), %r9d
incq %rdi
cmpb $0xa, %r9b
jb 0xb7ce
jmp 0xb7f2
xorl %eax, %eax
imull %ecx, %eax
cmpq $0x2, %rdx
cmovael %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_atoi.c
// Function: ft_atoi_test
int				ft_atoi_test(const char *str)
{
	long int	i;
	long int	resu;
	long int	sign;
	long int	test;

	i = 0;
	resu = 0;
	sign = 1;
	test = 0;
	while (str[i] != '\0' && (ft_isspace(str[i]) == 1 || str[i] == 0))
		i++;
	if (str[i] == '\0')
		return (-1);
	while (str[i] == '-' || str[i] == '+')
	{
		if (str[i] == '-')
			sign = -1;
		i++;
		test++;
	}
	while ((str[i] != '\0') && (str[i] >= '0' && str[i] <= '9'))
		resu = resu * 10 + (str[i++] - '0');
	if (test > 1)
		return (0);
	return (sign * resu);
}

// Assembly:
movb (%rdi), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %dl, %dl
sete %cl
je 0xb8a2
incq %rdi
movzbl %dl, %edx
leal -0x9(%rdx), %esi
cmpl $0x5, %esi
jae 0xb82b
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
sete %cl
jne 0xb812
jmp 0xb8a2
cmpl $0x20, %edx
je 0xb81d
testb $0x1, %cl
jne 0xb8a2
movl $0x1, %ecx
xorl %edx, %edx
movq $-0x1, %rax
movzbl -0x1(%rdi), %esi
cmpl $0x2b, %esi
je 0xb851
cmpl $0x2d, %esi
jne 0xb861
cmpb $0x2d, %sil
cmoveq %rax, %rcx
incq %rdx
incq %rdi
jmp 0xb843
movb -0x1(%rdi), %r8b
leal -0x30(%r8), %esi
xorl %eax, %eax
cmpb $0x9, %sil
ja 0xb895
xorl %esi, %esi
leaq (%rsi,%rsi,4), %rsi
addb $-0x30, %r8b
movzbl %r8b, %r8d
leaq (%r8,%rsi,2), %rsi
movb (%rdi), %r8b
leal -0x30(%r8), %r9d
incq %rdi
cmpb $0xa, %r9b
jb 0xb873
jmp 0xb897
xorl %esi, %esi
cmpq $0x1, %rdx
ja 0xb8a2
imull %ecx, %esi
movl %esi, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_empty_line.c
// Function: ft_empty_line
int			ft_empty_line(char *line)
{
	int		i;

	i = 0;
	if (line == NULL)
		return (0);
	while (line[i] != '\0')
	{
		if (ft_isspace(line[i]) == 0)
			return (1);
		i++;
	}
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xb8e0
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
je 0xb8e0
incq %r14
movsbl %al, %edi
callq 0xb768
testl %eax, %eax
je 0xb8db
movb (%r14), %al
incq %r14
testb %al, %al
jne 0xb8c3
jmp 0xb8e0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_strcmp.c
// Function: ft_strcmp
int		ft_strcmp(char *s1, char *s2)
{
	int	i;
	int	e;

	i = 0;
	e = 0;
	if (s1 == NULL || s2 == NULL)
		return (-1);
	while (*(s1 + i) != '\0')
	{
		if (*(s1 + i) < *(s2 + i))
		{
			e = *(s1 + i) - *(s2 + i);
			return (e);
		}
		else if (*(s1 + i) > *(s2 + i))
		{
			e = *(s1 + i) - *(s2 + i);
			return (e);
		}
		else if (*(s1 + i) == *(s2 + i))
		{
			i++;
		}
	}
	return (e);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0xb982
movb (%rdi), %al
testb %al, %al
je 0xb980
xorl %ecx, %ecx
xorl %edx, %edx
movsbl (%rsi,%rcx), %r8d
cmpb %r8b, %al
jl 0xb983
cmpb %r8b, %al
jg 0xb983
xorl %ecx, %ecx
cmpb %r8b, %al
sete %cl
movl %edx, %eax
addq %rax, %rcx
movb (%rdi,%rcx), %al
movl %ecx, %edx
testb %al, %al
jne 0xb95b
xorl %eax, %eax
retq
movsbl %al, %eax
subl %r8d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_strcmp_c.c
// Function: ft_strcmp_c
int		ft_strcmp_c(char *p_src, char p_target)
{
	int	i;

	i = 0;
	if (p_src == NULL || p_target == '\0')
		return (0);
	while (p_src[i] != '\0')
	{
		if (p_src[i] == p_target)
			return (1);
		i++;
	}
	return (0);
}

// Assembly:
testq %rdi, %rdi
sete %cl
testb %sil, %sil
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xb9b5
movb (%rdi), %cl
testb %cl, %cl
je 0xb9b5
incq %rdi
cmpb %sil, %cl
je 0xb9b6
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xb9a7
retq
movl $0x1, %eax
retq