LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_c_color.c
// Function: ft_recup_c_color
int	ft_recup_c_color(t_map *map, char *line, int i)
{
	t_color	color;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8de0
movq %rax, %r13
cmpl $-0x1, 0x78(%r15)
je 0x9b57
movq %r14, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9cb8
movq %r15, (%rsp)
movslq %ebx, %rax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%r14), %rdi
decq %rdi
addq %r14, %rax
incq %rax
incq %rdi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x9b71
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r12      # imm = 0x100000000
leal 0x1(%rbx), %eax
movslq %eax, %rbp
leaq (%r14,%rbp), %r15
decq %r15
shlq $0x20, %rbp
addq %rcx, %rbp
incq %r15
addq %r12, %rbp
incl %ebx
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x9ba7
callq 0x8e80
movl %eax, %edx
movl %r13d, %r13d
movb (%r15), %al
leal -0x30(%rax), %ecx
incl %ebx
addq %r12, %rbp
incq %r15
cmpb $0xa, %cl
jb 0x9bc3
cmpb $0x2c, %al
je 0x9bf1
movq %r14, %rdi
movq %rdx, %r15
callq 0xae6b
movq %r15, %rdx
testq %rax, %rax
je 0x9cb1
shlq $0x20, %rdx
orq %r13, %rdx
movq %rdx, %r13
sarq $0x20, %rbp
addq %r14, %rbp
movq %rbp, %rdi
callq 0x8e80
movl %eax, %ebp
movslq %ebx, %r15
leaq (%r14,%r15), %rax
shlq $0x20, %r15
movb (%rax), %cl
leal -0x30(%rcx), %edx
incl %ebx
addq %r12, %r15
incq %rax
cmpb $0xa, %dl
jb 0x9c17
cmpb $0x2c, %cl
je 0x9c3b
movq %r14, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9cb1
movl %ebp, %r12d
sarq $0x20, %r15
movb (%r14,%r15), %al
addb $-0x30, %al
cmpb $0x9, %al
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
ja 0x9c67
addq %r14, %r15
movq %r15, %rdi
callq 0x8e80
movl %eax, %edx
shlq $0x20, %rdx
movslq %ebx, %rax
addl $-0x2, %ebx
addq %r14, %rax
decq %rax
movb 0x1(%rax), %cl
incq %rax
addb $-0x30, %cl
incl %ebx
cmpb $0xa, %cl
jb 0x9c73
movq (%rsp), %rdi
movq %r13, %rsi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x9c8a
orq %r12, %rdx
movq %r14, %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9a34
movl $0x27, %edi
jmp 0x9cbd
movl $0x26, %edi
callq 0x8b94
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_f_color2.c
// Function: ft_recup_f_color2
int	ft_recup_f_color2(t_map *map, t_color color, char *line, int i)
{
	if (line[i] != '\0' && ft_free(line) == NULL)
		return (ft_error3(35) + 1);
	if ((color.t != 0 || color.r > 255 || color.g > 255 || color.b > 255) &&
		ft_free(line) == NULL)
		return (ft_error4(36) + 1);
	if ((color.t != 0 || color.r < 0 || color.g < 0 || color.b < 0) &&
		ft_free(line) == NULL)
		return (ft_error4(37) + 1);
	map->f_color = (color.t << 24 | color.r << 16 | color.g << 8 | color.b);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq %r8d, %rax
cmpb $0x0, (%rcx,%rax)
je 0x9d05
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9d96
movq %r15, %r13
shrq $0x20, %r13
movq %rbx, %rbp
shrq $0x20, %rbp
testl %r15d, %r15d
setne %al
movl $0x100, %ecx            # imm = 0x100
cmpl %ecx, %r13d
setge %dl
cmpl %ecx, %ebx
setge %sil
orb %dl, %sil
cmpl %ecx, %ebp
setge %cl
orb %al, %cl
orb %sil, %cl
cmpb $0x1, %cl
jne 0x9d49
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9da2
testl %r15d, %r15d
setne %al
testq %r15, %r15
sets %cl
movabsq $-0x7fffffff80000000, %rdx # imm = 0x8000000080000000
testq %rdx, %rbx
setne %dl
orb %al, %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x9d7b
movq %r12, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9da9
shll $0x18, %r15d
shll $0x10, %r13d
shll $0x8, %ebx
orl %r15d, %ebx
orl %r13d, %ebx
orl %ebp, %ebx
movl %ebx, 0x7c(%r14)
xorl %eax, %eax
jmp 0x9db5
movl $0x23, %edi
callq 0x8b6c
jmp 0x9db3
movl $0x24, %edi
jmp 0x9dae
movl $0x25, %edi
callq 0x8b94
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_f_color.c
// Function: ft_recup_f_color
int	ft_recup_f_color(t_map *map, char *line, int i)
{
	t_color	color;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8de0
movq %rax, %r13
cmpl $-0x1, 0x7c(%r15)
je 0x9df7
movq %r14, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9f58
movq %r15, (%rsp)
movslq %ebx, %rax
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
leaq (%rcx,%r14), %rdi
decq %rdi
addq %r14, %rax
incq %rax
incq %rdi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x9e11
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %r12      # imm = 0x100000000
leal 0x1(%rbx), %eax
movslq %eax, %rbp
leaq (%r14,%rbp), %r15
decq %r15
shlq $0x20, %rbp
addq %rcx, %rbp
incq %r15
addq %r12, %rbp
incl %ebx
cmpb $0x20, 0x1(%rdi)
leaq 0x1(%rdi), %rdi
je 0x9e47
callq 0x8e80
movl %eax, %edx
movl %r13d, %r13d
movb (%r15), %al
leal -0x30(%rax), %ecx
incl %ebx
addq %r12, %rbp
incq %r15
cmpb $0xa, %cl
jb 0x9e63
cmpb $0x2c, %al
je 0x9e91
movq %r14, %rdi
movq %rdx, %r15
callq 0xae6b
movq %r15, %rdx
testq %rax, %rax
je 0x9f51
shlq $0x20, %rdx
orq %r13, %rdx
movq %rdx, %r13
sarq $0x20, %rbp
addq %r14, %rbp
movq %rbp, %rdi
callq 0x8e80
movl %eax, %ebp
movslq %ebx, %r15
leaq (%r14,%r15), %rax
shlq $0x20, %r15
movb (%rax), %cl
leal -0x30(%rcx), %edx
incl %ebx
addq %r12, %r15
incq %rax
cmpb $0xa, %dl
jb 0x9eb7
cmpb $0x2c, %cl
je 0x9edb
movq %r14, %rdi
callq 0xae6b
testq %rax, %rax
je 0x9f51
movl %ebp, %r12d
sarq $0x20, %r15
movb (%r14,%r15), %al
addb $-0x30, %al
cmpb $0x9, %al
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
ja 0x9f07
addq %r14, %r15
movq %r15, %rdi
callq 0x8e80
movl %eax, %edx
shlq $0x20, %rdx
movslq %ebx, %rax
addl $-0x2, %ebx
addq %r14, %rax
decq %rax
movb 0x1(%rax), %cl
incq %rax
addb $-0x30, %cl
incl %ebx
cmpb $0xa, %cl
jb 0x9f13
movq (%rsp), %rdi
movq %r13, %rsi
incl %ebx
cmpb $0x20, (%rax)
leaq 0x1(%rax), %rax
je 0x9f2a
orq %r12, %rdx
movq %r14, %rcx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9cd4
movl $0x23, %edi
jmp 0x9f5d
movl $0x22, %edi
callq 0x8b6c
incl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_line_map.c
// Function: ft_recup_line_map
int	ft_recup_line_map(t_map *map, char *line, int i)
{
	char	*line2;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8f20
movq %rax, %r14
movslq %ebp, %rdx
leaq (%rdx,%rax), %rcx
incq %rcx
shlq $0x20, %rdx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %rdx, %rax
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %rdx, %rax
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x9fb3
sarq $0x20, %rax
cmpb $0x31, -0x1(%r14,%rax)
je 0x9fe5
movq %r14, %rdi
callq 0xae6b
testq %rax, %rax
jne 0x9fe5
movq %r15, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa03c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7ad1
cmpl $0x1, %eax
jne 0xa002
movq %r15, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa035
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa021
movq %r14, %rsi
callq 0xb14c
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xae6b
jmp 0xa025
movq %r14, 0x8(%rbx)
incl 0x14(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0xa02a
movl $0x29, %edi
callq 0x8b94
incl %eax
jmp 0xa02a
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_resolution.c
// Function: ft_recup_resolution
int	ft_recup_resolution(t_map *map, char *line, int i)
{
	if ((map->res_x != 0 || map->res_y != 0) && ft_free(line) == NULL)
		return (ft_error(6) + 1);
	while (line[++i] == ' ')
		;
	i++;
	map->res_x = ft_modif_atoi(line + i);
	while (line[i] == ' ')
		i++;
	while (line[i] > 47 && line[i] < 58)
		i++;
	if (line[i] != ' ' && ft_free(line) == NULL)
		return (ft_error(7) + 1);
	map->res_y = ft_modif_atoi(line + i);
	while (line[i] == ' ')
		i++;
	while (line[i] > 47 && line[i] < 58)
		i++;
	while (line[i] == ' ')
		i++;
	if (line[i] != '\0' && ft_free(line) == NULL)
		return (ft_error(7) + 1);
	if ((map->res_x < 150 || map->res_y < 100) && ft_free(line) == NULL)
		return (ft_error(8) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
jne 0xa069
cmpl $0x0, 0x1c(%r14)
je 0xa07a
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa159
movabsq $0x100000000, %rax      # imm = 0x100000000
movslq %ebp, %rdi
leal 0x1(%rdi), %ebp
leaq (%rdi,%rbx), %rcx
incq %rcx
shlq $0x20, %rdi
addq %rax, %rdi
incl %ebp
addq %rax, %rdi
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa098
sarq $0x20, %rdi
addq %rbx, %rdi
callq 0x8e80
movl %eax, 0x18(%r14)
movslq %ebp, %rax
leaq (%rbx,%rax), %r15
addq $-0x2, %r15
cmpb $0x20, 0x2(%r15)
leaq 0x1(%r15), %r15
je 0xa0c1
movb 0x1(%r15), %al
incq %r15
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0xa0cc
cmpb $0x20, %al
je 0xa0ec
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa160
leaq -0x2(%r15), %r12
movq %r15, %rdi
callq 0x8e80
movl %eax, 0x1c(%r14)
cmpb $0x20, 0x2(%r12)
leaq 0x1(%r12), %r12
je 0xa0fc
movb 0x1(%r12), %al
incq %r12
addb $-0x30, %al
cmpb $0xa, %al
jb 0xa109
jmp 0xa11c
incq %r12
movzbl (%r12), %eax
cmpl $0x20, %eax
je 0xa119
testl %eax, %eax
je 0xa137
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa160
cmpl $0x96, 0x18(%r14)
jl 0xa148
cmpl $0x63, 0x1c(%r14)
jg 0xa155
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa167
xorl %eax, %eax
jmp 0xa173
movl $0x6, %edi
jmp 0xa16c
movl $0x7, %edi
jmp 0xa16c
movl $0x8, %edi
callq 0x8c3c
incl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_text_east.c
// Function: ft_recup_text_east
int	ft_recup_text_east(t_map *map, char *line, int i)
{
	char	*line2;
	int		fd;

	if (map->east_text != NULL && ft_free(line) == NULL)
		return (ft_error3(24) + 1);
	line2 = NULL;
	while (line[++i] == ' ')
		;
	i += 2;
	while (line[i] == ' ')
		i++;
	if (ft_check_line2(line + i) == 1 && ft_free(line) == NULL)
		return (ft_error3(25) + 1);
	if (((line2 = ft_modif_strcpy(line + i)) == NULL) && ft_free(line) == NULL)
		return (ft_error3(26) + 1);
	map->east_text = line2;
	if ((fd = open(map->east_text, O_RDONLY)) == -1 && ft_free(line) == NULL)
		return (ft_error3(27) + 1);
	if (close(fd) == -1 && ft_free(line) == NULL)
		return (ft_error3(28) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x68(%rdi)
je 0xa1a3
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa24d
movslq %ebp, %rcx
leal 0x2(%rcx), %eax
addq %rbx, %rcx
incq %rcx
incl %eax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa1af
cltq
leaq (%rbx,%rax), %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0xa1c3
movq %r15, %rdi
callq 0x795b
cmpl $0x1, %eax
jne 0xa1e8
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa254
movq %r15, %rdi
callq 0x8ed4
movq %rax, %r15
testq %rax, %rax
jne 0xa205
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa25b
movq %r15, 0x68(%r14)
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa22c
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa262
movl %r14d, %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xa270
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
jne 0xa270
movl $0x1c, %edi
jmp 0xa267
movl $0x18, %edi
jmp 0xa267
movl $0x19, %edi
jmp 0xa267
movl $0x1a, %edi
jmp 0xa267
movl $0x1b, %edi
callq 0x8b6c
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_text_north.c
// Function: ft_recup_text_north
int	ft_recup_text_north(t_map *map, char *line, int i)
{
	char	*line2;
	int		fd;

	if (map->north_text != NULL && ft_free(line) == NULL)
		return (ft_error(10) + 1);
	line2 = NULL;
	while (line[++i] == ' ')
		;
	i += 2;
	while (line[i] == ' ')
		i++;
	if (ft_check_line2(line + i) == 1 && ft_free(line) == NULL)
		return (ft_error2(17) + 1);
	if (((line2 = ft_modif_strcpy(line + i)) == NULL) && ft_free(line) == NULL)
		return (ft_error(9) + 1);
	map->north_text = line2;
	if ((fd = open(map->north_text, O_RDONLY)) == -1 && ft_free(line) == NULL)
		return (ft_error(11) + 1);
	if (close(fd) == -1 && ft_free(line) == NULL)
		return (ft_error2(12) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x50(%rdi)
je 0xa2a7
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa351
movslq %ebp, %rcx
leal 0x2(%rcx), %eax
addq %rbx, %rcx
incq %rcx
incl %eax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa2b3
cltq
leaq (%rbx,%rax), %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0xa2c7
movq %r15, %rdi
callq 0x795b
cmpl $0x1, %eax
jne 0xa2ec
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa358
movq %r15, %rdi
callq 0x8ed4
movq %rax, %r15
testq %rax, %rax
jne 0xa309
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa364
movq %r15, 0x50(%r14)
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa330
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa36b
movl %r14d, %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xa379
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
jne 0xa379
movl $0xc, %edi
jmp 0xa35d
movl $0xa, %edi
jmp 0xa370
movl $0x11, %edi
callq 0x8b44
jmp 0xa375
movl $0x9, %edi
jmp 0xa370
movl $0xb, %edi
callq 0x8c3c
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_text_south.c
// Function: ft_recup_text_south
int	ft_recup_text_south(t_map *map, char *line, int i)
{
	char	*line2;
	int		fd;

	if (map->south_text != NULL && ft_free(line) == NULL)
		return (ft_error2(13) + 1);
	line2 = NULL;
	while (line[++i] == ' ')
		;
	i += 2;
	while (line[i] == ' ')
		i++;
	if (ft_check_line2(line + i) == 1 && ft_free(line) == NULL)
		return (ft_error2(18) + 1);
	if (((line2 = ft_modif_strcpy(line + i)) == NULL) && ft_free(line) == NULL)
		return (ft_error2(14) + 1);
	map->south_text = line2;
	if ((fd = open(map->south_text, O_RDONLY)) == -1 && ft_free(line) == NULL)
		return (ft_error2(15) + 1);
	if (close(fd) == -1 && ft_free(line) == NULL)
		return (ft_error2(16) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x58(%rdi)
je 0xa3af
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa459
movslq %ebp, %rcx
leal 0x2(%rcx), %eax
addq %rbx, %rcx
incq %rcx
incl %eax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa3bb
cltq
leaq (%rbx,%rax), %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0xa3cf
movq %r15, %rdi
callq 0x795b
cmpl $0x1, %eax
jne 0xa3f4
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa460
movq %r15, %rdi
callq 0x8ed4
movq %rax, %r15
testq %rax, %rax
jne 0xa411
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa467
movq %r15, 0x58(%r14)
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa438
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa46e
movl %r14d, %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xa47c
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
jne 0xa47c
movl $0x10, %edi
jmp 0xa473
movl $0xd, %edi
jmp 0xa473
movl $0x12, %edi
jmp 0xa473
movl $0xe, %edi
jmp 0xa473
movl $0xf, %edi
callq 0x8b44
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_text_sprite.c
// Function: ft_recup_text_sprite
int	ft_recup_text_sprite(t_map *map, char *line, int i)
{
	char	*line2;
	int		fd;

	if (map->sprite_text != NULL && ft_free(line) == NULL)
		return (ft_error3(29) + 1);
	line2 = NULL;
	while (line[++i] == ' ')
		;
	i += 2;
	while (line[i] == ' ')
		i++;
	if (ft_check_line2(line + i) == 1 && ft_free(line) == NULL)
		return (ft_error3(30) + 1);
	if (((line2 = ft_modif_strcpy(line + i)) == NULL) && ft_free(line) == NULL)
		return (ft_error3(31) + 1);
	map->sprite_text = line2;
	if ((fd = open(map->sprite_text, O_RDONLY)) == -1 && ft_free(line) == NULL)
		return (ft_error3(32) + 1);
	if (close(fd) == -1 && ft_free(line) == NULL)
		return (ft_error3(33) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x70(%rdi)
je 0xa4b3
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa55d
movslq %ebp, %rcx
leal 0x2(%rcx), %eax
addq %rbx, %rcx
incq %rcx
incl %eax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa4bf
cltq
leaq (%rbx,%rax), %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0xa4d3
movq %r15, %rdi
callq 0x795b
cmpl $0x1, %eax
jne 0xa4f8
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa564
movq %r15, %rdi
callq 0x8ed4
movq %rax, %r15
testq %rax, %rax
jne 0xa515
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa56b
movq %r15, 0x70(%r14)
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa53c
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa572
movl %r14d, %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xa580
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
jne 0xa580
movl $0x21, %edi
jmp 0xa577
movl $0x1d, %edi
jmp 0xa577
movl $0x1e, %edi
jmp 0xa577
movl $0x1f, %edi
jmp 0xa577
movl $0x20, %edi
callq 0x8b6c
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_recup_text_west.c
// Function: ft_recup_text_west
int	ft_recup_text_west(t_map *map, char *line, int i)
{
	char	*line2;
	int		fd;

	if (map->west_text != NULL && ft_free(line) == NULL)
		return (ft_error2(19) + 1);
	line2 = NULL;
	while (line[++i] == ' ')
		;
	i += 2;
	while (line[i] == ' ')
		i++;
	if (ft_check_line2(line + i) == 1 && ft_free(line) == NULL)
		return (ft_error2(20) + 1);
	if (((line2 = ft_modif_strcpy(line + i)) == NULL) && ft_free(line) == NULL)
		return (ft_error2(21) + 1);
	map->west_text = line2;
	if ((fd = open(map->west_text, O_RDONLY)) == -1 && ft_free(line) == NULL)
		return (ft_error2(22) + 1);
	if (close(fd) == -1 && ft_free(line) == NULL)
		return (ft_error2(23) + 1);
	return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x60(%rdi)
je 0xa5b7
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa661
movslq %ebp, %rcx
leal 0x2(%rcx), %eax
addq %rbx, %rcx
incq %rcx
incl %eax
cmpb $0x20, (%rcx)
leaq 0x1(%rcx), %rcx
je 0xa5c3
cltq
leaq (%rbx,%rax), %r15
decq %r15
cmpb $0x20, 0x1(%r15)
leaq 0x1(%r15), %r15
je 0xa5d7
movq %r15, %rdi
callq 0x795b
cmpl $0x1, %eax
jne 0xa5fc
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa668
movq %r15, %rdi
callq 0x8ed4
movq %rax, %r15
testq %rax, %rax
jne 0xa619
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa66f
movq %r15, 0x60(%r14)
xorl %ebp, %ebp
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0xa640
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
je 0xa676
movl %r14d, %edi
callq 0x7040
cmpl $-0x1, %eax
jne 0xa684
movq %rbx, %rdi
callq 0xae6b
testq %rax, %rax
jne 0xa684
movl $0x17, %edi
jmp 0xa67b
movl $0x13, %edi
jmp 0xa67b
movl $0x14, %edi
jmp 0xa67b
movl $0x15, %edi
jmp 0xa67b
movl $0x16, %edi
callq 0x8b44
movl %eax, %ebp
incl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_save2.c
// Function: ft_save2
void	ft_save2(t_map *map, int fd)
{
	int	file_size;
	int	offset;
	int	size;
	int	nbr_plan;
	int	end;

	end = -1;
	nbr_plan = 1;
	offset = 58;
	file_size = (map->res_y * map->res_x * 4) + 58;
	size = 40;
	write(fd, "BM", 2);
	write(fd, &file_size, 4);
	write(fd, "\0\0\0\0", 4);
	write(fd, &offset, 4);
	write(fd, &size, 4);
	write(fd, &map->res_x, 4);
	write(fd, &map->res_y, 4);
	write(fd, &nbr_plan, 2);
	write(fd, &map->mlx.img->bpp, 2);
	while (++end < 28)
		write(fd, "\0", 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movl $0x1, (%rax)
leaq 0xc(%rsp), %rax
movl $0x3a, (%rax)
leaq 0x1c(%rdi), %r12
movl 0x1c(%rdi), %eax
leaq 0x18(%rdi), %r13
imull 0x18(%rdi), %eax
leal 0x3a(,%rax,4), %eax
leaq 0x14(%rsp), %rbp
movl %eax, (%rbp)
leaq 0x10(%rsp), %r15
movl $0x28, (%r15)
leaq 0x54aa(%rip), %rsi      # 0xfb98
movl $0x2, %edx
movl %ebx, %edi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %rbp, %rsi
callq 0x73d0
leaq 0x548b(%rip), %rsi      # 0xfb9b
movl $0x4, %edx
movl %ebx, %edi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
leaq 0xc(%rsp), %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r13, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x73d0
movl $0x2, %edx
movl %ebx, %edi
leaq 0x8(%rsp), %rsi
callq 0x73d0
movq 0x90(%r14), %rsi
addq $0x1c, %rsi
movl $0x2, %edx
movl %ebx, %edi
callq 0x73d0
movl $0x1c, %ebp
leaq 0x5412(%rip), %r14      # 0xfba0
movl $0x1, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
decl %ebp
jne 0xa78e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_save.c
// Function: ft_save
void	ft_save(t_map *map)
{
	int	*addr;
	int	fd;
	int	y;
	int	x;

	fd = open("img.bmp", O_TRUNC | O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR |
			S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH);
	if (fd == -1)
		return (ft_error5(53));
	ft_save2(map, fd);
	y = map->res_y;
	addr = (int *)map->mlx.img->data;
	while (--y >= 0)
	{
		x = -1;
		while (++x < map->res_x)
			write(fd, &addr[y * map->mlx.img->size_line / 4 + x], 4);
	}
	if (close(fd) == -1)
		return (ft_error5(54));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x53dd(%rip), %rdi      # 0xfba2
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x7410
cmpl $-0x1, %eax
je 0xa869
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0xa694
movl 0x1c(%rbx), %r14d
testl %r14d, %r14d
jle 0xa84e
movq 0x90(%rbx), %rax
movq 0x30(%rax), %r15
movl %r14d, %r12d
leal -0x1(%r12), %r14d
cmpl $0x0, 0x18(%rbx)
jle 0xa848
xorl %r13d, %r13d
movq 0x90(%rbx), %rax
movl 0x18(%rax), %eax
imull %r14d, %eax
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
movslq %ecx, %rax
addq %r13, %rax
leaq (%r15,%rax,4), %rsi
movl $0x4, %edx
movl %ebp, %edi
callq 0x73d0
incq %r13
cmpl 0x18(%rbx), %r13d
jl 0xa810
cmpl $0x2, %r12d
jge 0xa7ff
movl %ebp, %edi
callq 0x7040
cmpl $-0x1, %eax
je 0xa870
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x35, %edi
jmp 0xa875
movl $0x36, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8bbc
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_split2.c
// Function: ft_split2
char	**ft_split2(t_map *map, char c)
{
	char	**tab;
	int		i;
	int		j;

	j = -1;
	i = 0;
	tab = NULL;
	if ((tab = malloc(sizeof(char *) * (map->line_map + 1))) == NULL)
		return (NULL);
	while (++j < map->line_map)
	{
		if ((tab[j] = ft_put_in_tab(map->first_map + i, c)) == NULL)
		{
			ft_free2(tab, j);
			return (NULL);
		}
		while (map->first_map[i++] != c)
			;
	}
	tab[j] = NULL;
	return (tab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movslq 0x14(%rdi), %rax
leaq 0x8(,%rax,8), %rdi
callq 0x7100
testq %rax, %rax
je 0xa91b
movq %rax, %rbx
xorl %r13d, %r13d
cmpl $0x0, 0x14(%r14)
jle 0xa906
movsbl %bpl, %eax
movl %eax, 0x4(%rsp)
xorl %r15d, %r15d
movslq %r13d, %r12
movq 0x8(%r14), %rdi
addq %r12, %rdi
movl 0x4(%rsp), %esi
callq 0x98f8
movq %rax, (%rbx,%r15,8)
testq %rax, %rax
je 0xa910
addq 0x8(%r14), %r12
leaq 0x1(%r12), %rax
incl %r13d
cmpb %bpl, (%r12)
movq %rax, %r12
jne 0xa8e6
incq %r15
movslq 0x14(%r14), %rax
cmpq %rax, %r15
jl 0xa8c6
movslq %r15d, %r13
movq $0x0, (%rbx,%r13,8)
jmp 0xa91d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8d44
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_sprite.c
// Function: ft_sprite
void	ft_sprite(t_map *map, double *z_buffer)
{
	t_sprite	*temp;

	ft_sprite_distance(map->sprite, map);
	ft_sprite_order(&map->sprite);
	ft_stock_data2(map);
	temp = map->sprite;
	while (temp)
	{
		ft_point_sprite(temp, map);
		--temp->draw_start_x;
		while (++temp->draw_start_x < temp->draw_end_x)
		{
			temp->tex_x = (int)(256 * (temp->draw_start_x - (-temp->sprite_width
			/ 2 + temp->sprite_screen_x)) * 64 / temp->sprite_width) / 256;
			if (temp->transform_y > 0 && temp->draw_start_x > 0 &&
			temp->draw_start_x < map->res_x && temp->transform_y <
			z_buffer[temp->draw_start_x])
				ft_draw_sprite(temp, map);
		}
		temp = temp->next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x158(%rdi), %r15
movq 0x158(%rdi), %rdi
movq %r14, %rsi
callq 0xaa28
movq %r15, %rdi
callq 0xaa6c
movq %r14, %rdi
callq 0xaa9c
movq 0x158(%r14), %r15
testq %r15, %r15
je 0xaa06
movq %r15, %rdi
movq %r14, %rsi
callq 0x970c
xorpd %xmm2, %xmm2
movl 0x54(%r15), %ecx
cmpl 0x58(%r15), %ecx
jge 0xa9fd
leal -0x1(%rcx), %esi
movl 0x50(%r15), %edi
movl %edi, %edx
shrl $0x1f, %edx
addl %edi, %edx
shrl %edx
movl %ecx, %eax
subl 0x40(%r15), %eax
addl %edx, %eax
shll $0xe, %eax
cltd
idivl %edi
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x8, %edx
movl %edx, 0x5c(%r15)
testl %esi, %esi
js 0xa9ec
movsd 0x38(%r15), %xmm0
ucomisd %xmm2, %xmm0
jbe 0xa9ec
cmpl 0x18(%r14), %ecx
jge 0xa9ec
movl %ecx, %eax
movsd (%rbx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xa9ec
movq %r15, %rdi
movq %r14, %rsi
callq 0x86d4
xorpd %xmm2, %xmm2
movl 0x54(%r15), %esi
leal 0x1(%rsi), %ecx
movl %ecx, 0x54(%r15)
cmpl 0x58(%r15), %ecx
jl 0xa98d
movq 0x68(%r15), %r15
jmp 0xa968
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_sprite_clear.c
// Function: ft_sprite_clear
void	ft_sprite_clear(t_sprite *sprite)
{
	t_sprite	*temp;

	temp = NULL;
	while (sprite)
	{
		temp = sprite;
		sprite = sprite->next;
		ft_free(temp);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xaa24
pushq %rbx
movq 0x68(%rdi), %rbx
callq 0xae6b
movq %rbx, %rdi
testq %rbx, %rbx
jne 0xaa12
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_sprite_distance.c
// Function: ft_sprite_distance
void	ft_sprite_distance(t_sprite *sprite, t_map *map)
{
	t_sprite	*temp;

	temp = sprite;
	while (temp)
	{
		temp->dist = ((map->player.pos_x - temp->pos_x) * (map->player.pos_x -
		temp->pos_x) + (map->player.pos_y - temp->pos_y) * (map->player.pos_y -
		temp->pos_y));
		temp = temp->next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xaa68
movsd 0x98(%rsi), %xmm0
movsd 0xa0(%rsi), %xmm1
movapd %xmm0, %xmm2
subsd 0x8(%rdi), %xmm2
movapd %xmm1, %xmm3
subsd 0x10(%rdi), %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, (%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
jne 0xaa3d
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_stock_data.c
// Function: ft_stock_data
void	ft_stock_data(t_map *map)
{
	if (map->point.side == 0 && map->ray.ray_dir_x < 0)
	{
		map->data = map->img_e->data;
		map->size_line = map->img_e->size_line;
	}
	if (map->point.side == 0 && map->ray.ray_dir_x >= 0)
	{
		map->data = map->img_w->data;
		map->size_line = map->img_w->size_line;
	}
	if (map->point.side == 1 && map->ray.ray_dir_y < 0)
	{
		map->data = map->img_n->data;
		map->size_line = map->img_n->size_line;
	}
	if (map->point.side == 1 && map->ray.ray_dir_y >= 0)
	{
		map->data = map->img_s->data;
		map->size_line = map->img_s->size_line;
	}
}

// Assembly:
movl 0x12c(%rdi), %eax
testl %eax, %eax
jne 0xab1a
xorpd %xmm0, %xmm0
ucomisd 0xe0(%rdi), %xmm0
jbe 0xaaec
movq 0x40(%rdi), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x160(%rdi)
movl 0x18(%rcx), %ecx
movl %ecx, 0x168(%rdi)
testl %eax, %eax
jne 0xab1a
movsd 0xe0(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xab1a
movq 0x38(%rdi), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x160(%rdi)
movl 0x18(%rcx), %ecx
movl %ecx, 0x168(%rdi)
cmpl $0x1, %eax
jne 0xab74
xorpd %xmm0, %xmm0
ucomisd 0xe8(%rdi), %xmm0
jbe 0xab45
movq 0x30(%rdi), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x160(%rdi)
movl 0x18(%rcx), %ecx
movl %ecx, 0x168(%rdi)
cmpl $0x1, %eax
jne 0xab74
movsd 0xe8(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xab74
movq 0x28(%rdi), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x160(%rdi)
movl 0x18(%rax), %eax
movl %eax, 0x168(%rdi)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_strcmp.c
// Function: ft_strcmp
int	ft_strcmp(char *s1, char *s2)
{
	int	i;

	i = 0;
	while (s1[i] && s2[i] && s1[i] == s2[i])
		++i;
	return (s1[i] - s2[i]);
}

// Assembly:
movb (%rdi), %al
xorl %ecx, %ecx
testb %al, %al
je 0xab8e
cmpb (%rsi,%rcx), %al
jne 0xab8e
movb 0x1(%rdi,%rcx), %al
incq %rcx
jmp 0xab7c
movsbl %al, %eax
movsbl (%rsi,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/ft_wall_hit.c
// Function: ft_wall_hit
void	ft_wall_hit(t_map *map)
{
	while (map->point.hit == 0)
	{
		if (map->point.side_dist_x < map->point.side_dist_y)
		{
			map->point.side_dist_x += map->point.delta_dist_x;
			map->point.map_x += map->point.step_x;
			map->point.side = 0;
		}
		else
		{
			map->point.side_dist_y += map->point.delta_dist_y;
			map->point.map_y += map->point.step_y;
			map->point.side = 1;
		}
		if (map->map[map->point.map_y][map->point.map_x] == '1')
			map->point.hit = 1;
	}
}

// Assembly:
movl 0x128(%rdi), %eax
testl %eax, %eax
jne 0xac3d
movq (%rdi), %rcx
movsd 0xf8(%rdi), %xmm0
movsd 0x100(%rdi), %xmm1
movl 0xf4(%rdi), %edx
movl 0xf0(%rdi), %esi
ucomisd %xmm0, %xmm1
jbe 0xabf3
addsd 0x108(%rdi), %xmm0
movsd %xmm0, 0xf8(%rdi)
addl 0x120(%rdi), %esi
movl %esi, 0xf0(%rdi)
movl $0x0, 0x12c(%rdi)
jmp 0xac19
addsd 0x110(%rdi), %xmm1
movsd %xmm1, 0x100(%rdi)
addl 0x124(%rdi), %edx
movl %edx, 0xf4(%rdi)
movl $0x1, 0x12c(%rdi)
movslq %edx, %r8
movq (%rcx,%r8,8), %r8
movslq %esi, %r9
cmpb $0x31, (%r8,%r9)
jne 0xac39
movl $0x1, 0x128(%rdi)
movl $0x1, %eax
testl %eax, %eax
je 0xabc5
retq
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/init_player2.c
// Function: init_player2
void	init_player2(t_map *map)
{
	if (map->orientation == 'N')
		map->player.dir_y = -1;
	if (map->orientation == 'N')
		map->player.plane_x = -0.66;
	if (map->orientation == 'S')
		map->player.dir_y = 1;
	if (map->orientation == 'S')
		map->player.plane_x = 0.66;
	if (map->orientation == 'E')
		map->player.dir_x = -1;
	if (map->orientation == 'E')
		map->player.plane_y = 0.66;
	if (map->orientation == 'W')
		map->player.dir_x = 1;
	if (map->orientation == 'W')
		map->player.plane_y = -0.66;
}

// Assembly:
movzbl 0x10(%rdi), %edx
movsd 0x48c8(%rip), %xmm0     # 0xfbb0
movl $0xb8, %eax
movl $0xb0, %ecx
cmpl $0x52, %edx
jg 0xb30a
movsd 0x4891(%rip), %xmm1     # 0xfb90
cmpl $0x45, %edx
je 0xb326
cmpl $0x4e, %edx
je 0xb347
retq
cmpl $0x57, %edx
je 0xb335
cmpl $0x53, %edx
jne 0xb309
movsd 0x489c(%rip), %xmm0     # 0xfbb8
movsd 0x4864(%rip), %xmm1     # 0xfb88
jmp 0xb347
movsd 0x488a(%rip), %xmm0     # 0xfbb8
movl $0xc0, %eax
jmp 0xb342
movl $0xc0, %eax
movsd 0x4846(%rip), %xmm1     # 0xfb88
movl $0xa8, %ecx
movsd %xmm1, (%rdi,%rcx)
movsd %xmm0, (%rdi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/init_player.c
// Function: init_player
void	init_player(t_map *map)
{
	map->player.dir_x = 0;
	map->player.dir_y = 0;
	map->player.plane_x = 0;
	map->player.plane_y = 0;
	init_player2(map);
	map->player.move_speed = 0.05;
	map->player.rotate_speed = 0.02;
	map->text_width = 64;
	map->text_height = 64;
	map->nbr_sprites = 0;
	map->sprite = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xa8(%rdi)
callq 0xb2dc
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0xc8(%rbx)
movabsq $0x3f947ae147ae147b, %rax # imm = 0x3F947AE147AE147B
movq %rax, 0xd0(%rbx)
movabsq $0x4000000040, %rax     # imm = 0x4000000040
movq %rax, 0x20(%rbx)
movl $0x0, 0x178(%rbx)
movq $0x0, 0x158(%rbx)
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/init_texture2.c
// Function: init_texture2
int	init_texture2(t_map *map)
{
	int	g;

	if ((map->img_e =
		mlx_xpm_file_to_image(map->mlx.mlx, map->east_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		mlx_destroy_image(map->mlx.mlx, map->img_w);
		return (1);
	}
	if ((map->img_sp =
		mlx_xpm_file_to_image(map->mlx.mlx, map->sprite_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		mlx_destroy_image(map->mlx.mlx, map->img_w);
		mlx_destroy_image(map->mlx.mlx, map->img_e);
		return (1);
	}
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
movq 0x80(%rdi), %rdi
leaq 0x4(%rsp), %rcx
movq %rcx, %rdx
callq 0xd3b0
movq %rax, 0x40(%rbx)
movq 0x80(%rbx), %rdi
testq %rax, %rax
je 0xb43c
movq 0x70(%rbx), %rsi
leaq 0x4(%rsp), %rcx
movq %rcx, %rdx
callq 0xd3b0
movq %rax, %rcx
movq %rax, 0x48(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
jne 0xb46d
leaq 0x40(%rbx), %r14
movq 0x28(%rbx), %rsi
movq 0x80(%rbx), %rdi
callq 0xedf0
movq 0x30(%rbx), %rsi
movq 0x80(%rbx), %rdi
callq 0xedf0
movq 0x38(%rbx), %rsi
movq 0x80(%rbx), %rdi
callq 0xedf0
jmp 0xb459
movq 0x28(%rbx), %rsi
callq 0xedf0
movq 0x30(%rbx), %rsi
movq 0x80(%rbx), %rdi
callq 0xedf0
leaq 0x38(%rbx), %r14
movq 0x80(%rbx), %rdi
movq (%r14), %rsi
callq 0xedf0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/init_texture.c
// Function: init_texture
int	init_texture(t_map *map)
{
	int	g;

	if ((map->img_s =
		mlx_xpm_file_to_image(map->mlx.mlx, map->south_text, &g, &g)) == NULL)
		return (1);
	if ((map->img_n =
		mlx_xpm_file_to_image(map->mlx.mlx, map->north_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		return (1);
	}
	if ((map->img_w =
		mlx_xpm_file_to_image(map->mlx.mlx, map->west_text, &g, &g)) == NULL)
	{
		mlx_destroy_image(map->mlx.mlx, map->img_s);
		mlx_destroy_image(map->mlx.mlx, map->img_n);
		return (1);
	}
	if (init_texture2(map) == 1)
		return (1);
	return (0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x58(%rdi), %rsi
movq 0x80(%rdi), %rdi
leaq 0x4(%rsp), %rcx
movq %rcx, %rdx
callq 0xd3b0
movq %rax, 0x28(%r14)
movl $0x1, %ebx
testq %rax, %rax
je 0xb51f
movq 0x50(%r14), %rsi
movq 0x80(%r14), %rdi
leaq 0x4(%rsp), %rcx
movq %rcx, %rdx
callq 0xd3b0
movq %rax, 0x30(%r14)
movq 0x80(%r14), %rdi
testq %rax, %rax
je 0xb4f9
movq 0x60(%r14), %rsi
leaq 0x4(%rsp), %rcx
movq %rcx, %rdx
callq 0xd3b0
movq %rax, 0x38(%r14)
testq %rax, %rax
je 0xb4ff
movq %r14, %rdi
callq 0xb3b8
xorl %ebx, %ebx
cmpl $0x1, %eax
sete %bl
jmp 0xb51f
movq 0x28(%r14), %rsi
jmp 0xb51a
movq 0x28(%r14), %rsi
movq 0x80(%r14), %rdi
callq 0xedf0
movq 0x30(%r14), %rsi
movq 0x80(%r14), %rdi
callq 0xedf0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/key_pressed.c
// Function: key_pressed
int	key_pressed(int keycode, t_map *map)
{
	if (keycode == 97)
		map->key.key_a = 1;
	if (keycode == 119)
		map->key.key_w = 1;
	if (keycode == 115)
		map->key.key_s = 1;
	if (keycode == 100)
		map->key.key_d = 1;
	if (keycode == 65361)
		map->key.key_left = 1;
	if (keycode == 65363)
		map->key.key_right = 1;
	if (keycode == 65307)
		ft_exit(map);
	return (0);
}

// Assembly:
cmpl $0x76, %edi
jle 0xb555
cmpl $0xff50, %edi           # imm = 0xFF50
jg 0xb570
cmpl $0x77, %edi
je 0xb598
cmpl $0xff1b, %edi           # imm = 0xFF1B
jne 0xb5ba
pushq %rax
movq %rsi, %rdi
callq 0x8c60
addq $0x8, %rsp
jmp 0xb5ba
cmpl $0x61, %edi
je 0xb58c
cmpl $0x64, %edi
je 0xb5b0
cmpl $0x73, %edi
jne 0xb5ba
movl $0x1, 0x148(%rsi)
jmp 0xb5ba
cmpl $0xff51, %edi           # imm = 0xFF51
je 0xb5a4
cmpl $0xff53, %edi           # imm = 0xFF53
jne 0xb5ba
movl $0x1, 0x150(%rsi)
jmp 0xb5ba
movl $0x1, 0x140(%rsi)
jmp 0xb5ba
movl $0x1, 0x144(%rsi)
jmp 0xb5ba
movl $0x1, 0x154(%rsi)
jmp 0xb5ba
movl $0x1, 0x14c(%rsi)
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/key_release.c
// Function: key_release
int	key_release(int keycode, t_map *map)
{
	if (keycode == 97)
		map->key.key_a = 0;
	if (keycode == 119)
		map->key.key_w = 0;
	if (keycode == 115)
		map->key.key_s = 0;
	if (keycode == 100)
		map->key.key_d = 0;
	if (keycode == 65361)
		map->key.key_left = 0;
	if (keycode == 65363)
		map->key.key_right = 0;
	if (keycode == 112)
		if (map->player.move_speed + 0.005 < 0.2)
			map->player.move_speed += 0.005;
	if (keycode == 109)
		if (map->player.move_speed - 0.005 > 0.001)
			map->player.move_speed -= 0.005;
	if (keycode == 111)
		if (map->player.rotate_speed + 0.005 < 0.2)
			map->player.rotate_speed += 0.005;
	if (keycode == 108)
		if (map->player.rotate_speed - 0.005 > 0.001)
			map->player.rotate_speed -= 0.005;
	return (0);
}

// Assembly:
cmpl $0x6b, %edi
jle 0xb616
leal -0x6c(%rdi), %eax
cmpl $0xb, %eax
ja 0xb637
leaq 0x460c(%rip), %rcx      # 0xfbe0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0xc8(%rsi), %xmm0
addsd 0x45e3(%rip), %xmm0     # 0xfbd0
ucomisd 0x45e3(%rip), %xmm0     # 0xfbd8
jbe 0xb5ff
movsd %xmm0, 0xc8(%rsi)
cmpl $0x6c, %edi
je 0xb6e2
cmpl $0x6f, %edi
je 0xb6b7
jmp 0xb71c
cmpl $0x61, %edi
je 0xb706
cmpl $0x64, %edi
jne 0xb71c
movl $0x0, 0x14c(%rsi)
jmp 0xb71c
cmpl $0xff51, %edi           # imm = 0xFF51
je 0xb712
cmpl $0xff53, %edi           # imm = 0xFF53
jne 0xb71c
movl $0x0, 0x150(%rsi)
jmp 0xb71c
movl $0x0, 0x144(%rsi)
jmp 0xb71c
movl $0x0, 0x148(%rsi)
jmp 0xb71c
movsd 0xc8(%rsi), %xmm0
addsd 0x4534(%rip), %xmm0     # 0xfbc0
movsd 0x4534(%rip), %xmm1     # 0xfbc8
ucomisd %xmm0, %xmm1
jbe 0xb6a2
movsd %xmm0, 0xc8(%rsi)
cmpl $0x6c, %edi
je 0xb6e2
cmpl $0x6f, %edi
je 0xb6b7
cmpl $0x6d, %edi
je 0xb5dd
jmp 0xb71c
movsd 0xd0(%rsi), %xmm0
addsd 0x44f9(%rip), %xmm0     # 0xfbc0
movsd 0x44f9(%rip), %xmm1     # 0xfbc8
ucomisd %xmm0, %xmm1
jbe 0xb6dd
movsd %xmm0, 0xd0(%rsi)
cmpl $0x6c, %edi
jne 0xb71c
movsd 0xd0(%rsi), %xmm0
addsd 0x44de(%rip), %xmm0     # 0xfbd0
ucomisd 0x44de(%rip), %xmm0     # 0xfbd8
jbe 0xb71c
movsd %xmm0, 0xd0(%rsi)
jmp 0xb71c
movl $0x0, 0x140(%rsi)
jmp 0xb71c
movl $0x0, 0x154(%rsi)
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/main.c
// Function: main
int	main(int argc, char **argv)
{
	t_map	*map;
	int		i;

	i = -1;
	if ((argc < 2 || argc > 3) && ft_error(0) == 0)
		return (0);
	if (ft_control_file(argv[1], ".cub") == 1 && ft_error(1) == 0)
		return (0);
	if (argc > 2 && ft_strcmp(argv[2], "--save") != 0 && ft_error(2) == 0)
		return (0);
	if ((map = map_init()) == NULL && ft_error(3) == 0)
		return (0);
	if (ft_check_map_and_recup(map, argv[1]) == 1 && ft_check_malloc(map) == 0)
		return (0);
	map->argc = argc;
	ft_cub3d(map);
	ft_check_malloc(map);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leal -0x4(%rbx), %eax
cmpl $-0x3, %eax
ja 0xb741
xorl %edi, %edi
callq 0x8c3c
testl %eax, %eax
je 0xb7da
movq 0x8(%r14), %rdi
leaq 0x44c4(%rip), %rsi      # 0xfc10
callq 0x8136
cmpl $0x1, %eax
jne 0xb764
movl $0x1, %edi
callq 0x8c3c
testl %eax, %eax
je 0xb7da
cmpl $0x3, %ebx
jl 0xb78b
movq 0x10(%r14), %rdi
leaq 0x44a1(%rip), %rsi      # 0xfc15
callq 0xab78
testl %eax, %eax
je 0xb78b
movl $0x2, %edi
callq 0x8c3c
testl %eax, %eax
je 0xb7da
callq 0xb7e4
movq %rax, %r15
testq %rax, %rax
jne 0xb7a6
movl $0x3, %edi
callq 0x8c3c
testl %eax, %eax
je 0xb7da
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x7f42
cmpl $0x1, %eax
jne 0xb7c3
movq %r15, %rdi
callq 0x7c8a
testl %eax, %eax
je 0xb7da
movl %ebx, 0x17c(%r15)
movq %r15, %rdi
callq 0x83cb
movq %r15, %rdi
callq 0x7c8a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/map_init.c
// Function: map_init
t_map	*map_init(void)
{
	t_map	*map;

	if ((map = malloc(sizeof(t_map))) == NULL)
		return (NULL);
	map->map = NULL;
	map->first_map = NULL;
	map->orientation = '0';
	map->line_map = 0;
	map->res_x = 0;
	map->res_y = 0;
	map->north_text = NULL;
	map->south_text = NULL;
	map->west_text = NULL;
	map->east_text = NULL;
	map->sprite_text = NULL;
	map->c_color = -1;
	map->f_color = -1;
	return (map);
}

// Assembly:
pushq %rax
movl $0x188, %edi            # imm = 0x188
callq 0x7100
testq %rax, %rax
je 0xb821
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movb $0x30, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x14(%rax)
movl $0x0, 0x1c(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x60(%rax)
movq %rcx, 0x70(%rax)
movq $-0x1, 0x78(%rax)
jmp 0xb823
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/raphifou15[P]cub3d/src/next_frame.c
// Function: next_frame
int	next_frame(t_map *map)
{
	int	y;

	y = -1;
	if ((map->mlx.img = mlx_new_image(map->mlx.mlx, map->res_x, map->res_y))
		== NULL)
	{
		free_img_text(map);
		mlx_destroy_window(map->mlx.mlx, map->mlx.win);
		free(map->mlx.mlx);
		ft_check_malloc(map);
		ft_error5(51);
		exit(0);
	}
	ft_raycasting(map);
	ft_move(map);
	if (map->argc != 3)
	{
		mlx_put_image_to_window(map->mlx.mlx, map->mlx.win, map->mlx.img, 0, 0);
		mlx_destroy_image(map->mlx.mlx, map->mlx.img);
	}
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
movl 0x18(%rbx), %esi
movl 0x1c(%rbx), %edx
callq 0xc4f0
movq %rax, 0x90(%rbx)
movq %rbx, %rdi
testq %rax, %rax
je 0xb8c1
callq 0x9980
movq %rbx, %rdi
callq 0x9380
cmpl $0x3, 0x17c(%rbx)
je 0xb8bd
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
movq 0x90(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xc770
movq 0x80(%rbx), %rdi
movq 0x90(%rbx), %rsi
callq 0xedf0
xorl %eax, %eax
popq %rbx
retq
callq 0x76e5
movq 0x80(%rbx), %rdi
movq 0x88(%rbx), %rsi
callq 0xe840
movq 0x80(%rbx), %rdi
callq 0x7180
movq %rbx, %rdi
callq 0x7c8a
movl $0x33, %edi
callq 0x8bbc
xorl %edi, %edi
callq 0x70a0
nop
// File: /workspace/github_c_makefile_star2_O1/dropletzhu[P]msuite/pim_listener.c
// Function: usage
void usage()
{
	printf("Usage: ./pim_linster -r rp -l length\n");
	printf(" -r rp      rp address\n");
	printf(" -l length  PIM packet size, the default packet size is 256 bytes\n");
	printf(" Version:   %s\n",version);
}

// Assembly:
pushq %rax
leaq 0xed4(%rip), %rdi       # 0x20b8
callq 0x1040
leaq 0xeed(%rip), %rdi       # 0x20dd
callq 0x1040
leaq 0xef8(%rip), %rdi       # 0x20f4
callq 0x1040
leaq 0xdfc(%rip), %rdi       # 0x2004
leaq 0xe05(%rip), %rsi       # 0x2014
xorl %eax, %eax
popq %rcx
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/rakitzis[P]rc/mkstatval.c
// Function: main
int main(void) {
	int cstatus, pstatus;
	pid_t pid;
	
	for (cstatus = 0; cstatus < 2; ++cstatus) {
		switch (pid = fork()) {
		case -1:
			perror("fork");
			return 1;
		case 0:
			_exit(cstatus);
		default:
			if (wait(&pstatus) != pid) {
				perror("wait");
				return 1;
			}
			printf("#define STATUS%d %d\n", cstatus, pstatus);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
leaq 0xe74(%rip), %rbx       # 0x2004
leaq 0x4(%rsp), %r14
leaq 0xe6d(%rip), %r13       # 0x2009
leaq 0xe6b(%rip), %r15       # 0x200e
callq 0x1070
cmpl $-0x1, %eax
je 0x11f0
movl %eax, %r12d
testl %eax, %eax
je 0x1200
movq %r14, %rdi
callq 0x1060
cmpl %r12d, %eax
jne 0x11ed
movl 0x4(%rsp), %edx
xorl %r12d, %r12d
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1040
incl %ebp
cmpl $0x1, %ebp
je 0x11a3
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rbx
movq %rbx, %rdi
callq 0x1050
movl $0x1, %r12d
jmp 0x11db
movl %ebp, %edi
callq 0x1030