LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_murs
int		ft_murs(t_recup *recup)
{
	int i;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x48(%rsi), %rax
movslq 0xd5ac(%rip), %r14      # 0x152a8
movq $0x0, (%rax,%r14,8)
movslq 0x44(%rsi), %rdi
incq %rdi
callq 0x7100
movq 0x48(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
testq %rax, %rax
je 0x7dcb
movb (%r15), %al
xorl %r14d, %r14d
testb %al, %al
je 0x7d86
movl 0xd577(%rip), %edx      # 0x152a8
movsbl %al, %edi
movq %rbx, %rsi
movl %r14d, %ecx
callq 0x7f33
cmpl $0x1, %eax
jne 0x7d5a
movq 0x48(%rbx), %rax
movslq 0xd559(%rip), %rcx      # 0x152a8
movq (%rax,%rcx,8), %rax
movb $0x30, (%rax,%r14)
jmp 0x7d7c
movb (%r15,%r14), %al
movq 0x48(%rbx), %rcx
movslq 0xd53f(%rip), %rdx      # 0x152a8
movq (%rcx,%rdx,8), %rcx
cmpb $0x20, %al
jne 0x7d78
movb $0x31, (%rcx,%r14)
jmp 0x7d7c
movb %al, (%rcx,%r14)
movb 0x1(%r15,%r14), %al
incq %r14
jmp 0x7d27
cmpl 0x44(%rbx), %r14d
jge 0x7dac
movslq 0xd515(%rip), %rax      # 0x152a8
movl %r14d, %r14d
movq 0x48(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movb $0x31, (%rcx,%r14)
incq %r14
cmpl %r14d, 0x44(%rbx)
jg 0x7d96
movq 0x48(%rbx), %rax
movslq 0xd4f1(%rip), %rcx      # 0x152a8
movq (%rax,%rcx,8), %rax
movl %r14d, %edx
movb $0x0, (%rax,%rdx)
leal 0x1(%rcx), %eax
movl %eax, 0xd4dd(%rip)      # 0x152a8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/parsing_map.c
// Function: ft_is_map
int		ft_is_map(char *str, t_recup *recup)
{
	int i;

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7dd3
testl %eax, %eax
je 0x7ec5
cmpl $-0x1, 0xc(%rbx)
je 0x7ea2
cmpl $-0x1, 0x10(%rbx)
je 0x7ea2
cmpq $0x0, 0x18(%rbx)
je 0x7ea2
cmpq $0x0, 0x20(%rbx)
je 0x7ea2
cmpq $0x0, 0x28(%rbx)
je 0x7ea2
cmpq $0x0, 0x30(%rbx)
je 0x7ea2
cmpq $0x0, 0x38(%rbx)
jne 0x7ea9
movl $0x2, 0x74(%rbx)
movq %r14, %rdi
callq 0x9df8
cmpl 0xd3f9(%rip), %eax      # 0x152b0
jle 0x7ebf
movl %eax, 0xd3f1(%rip)      # 0x152b0
incl 0xd3e7(%rip)            # 0x152ac
movl 0xd3e1(%rip), %eax      # 0x152ac
movl %eax, 0x40(%rbx)
movl 0xd3dc(%rip), %eax      # 0x152b0
movl %eax, 0x44(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/parsing_utils.c
// Function: ft_strlen2
int		ft_strlen2(char *str)
{
	int j;
	int i;

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
movl $0x0, 0x350(%rdi)
movq $0x0, 0x358(%rdi)
movl 0x380(%rdi), %eax
addl %eax, %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl (%rdi), %xmm1
divsd %xmm1, %xmm0
addsd 0x4ce7(%rip), %xmm0     # 0xd0b8
movsd %xmm0, 0x318(%rdi)
movsd 0x2f8(%rdi), %xmm1
mulsd %xmm0, %xmm1
addsd 0x2e8(%rdi), %xmm1
movsd %xmm1, 0x308(%rdi)
mulsd 0x300(%rdi), %xmm0
addsd 0x2f0(%rdi), %xmm0
movsd %xmm0, 0x310(%rdi)
cvttsd2si 0x2d8(%rdi), %eax
movl %eax, 0x320(%rdi)
cvttsd2si 0x2e0(%rdi), %eax
movl %eax, 0x324(%rdi)
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rax, 0x370(%rdi)
movabsq $0x3fae69ad42c3c9ef, %rax # imm = 0x3FAE69AD42C3C9EF
movq %rax, 0x378(%rdi)
jmp 0xa082
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_texture
void	ft_init_texture(t_recup *recup)
{
	if (recup->ray.side == 0 && recup->ray.raydirx < 0)
		recup->t.texdir = 0;
	if (recup->ray.side == 0 && recup->ray.raydirx >= 0)
		recup->t.texdir = 1;
	if (recup->ray.side == 1 && recup->ray.raydiry < 0)
		recup->t.texdir = 2;
	if (recup->ray.side == 1 && recup->ray.raydiry >= 0)
		recup->t.texdir = 3;
	if (recup->ray.side == 0)
		recup->t.wallx = recup->ray.posy + recup->ray.perpwalldist \
						* recup->ray.raydiry;
	else
		recup->t.wallx = recup->ray.posx + recup->ray.perpwalldist \
						* recup->ray.raydirx;
	recup->t.wallx -= floor((recup->t.wallx));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x354(%rdi), %eax
testl %eax, %eax
jne 0x849a
xorpd %xmm0, %xmm0
ucomisd 0x308(%rbx), %xmm0
jbe 0x847a
movl $0x0, 0x388(%rbx)
testl %eax, %eax
jne 0x849a
movsd 0x308(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x849a
movl $0x1, 0x388(%rbx)
cmpl $0x1, %eax
jne 0x84d8
xorpd %xmm0, %xmm0
ucomisd 0x310(%rbx), %xmm0
jbe 0x84b7
movl $0x2, 0x388(%rbx)
cmpl $0x1, %eax
jne 0x84d8
movsd 0x310(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x84d8
movl $0x3, 0x388(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movsd 0x358(%rbx), %xmm0
mulsd 0x308(%rbx,%rcx,8), %xmm0
addsd 0x2d8(%rbx,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7380
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x390(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_sprite
void	ft_init_sprite(t_recup *recup)
{
	int i;
	int j;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x3b0(%rdi)
callq 0x9700
movslq 0x40(%rbx), %rax
testq %rax, %rax
jle 0x8567
movl 0x44(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
jle 0x855f
movq 0x48(%rbx), %rsi
movq (%rsi,%rdx,8), %rsi
xorl %edi, %edi
cmpb $0x32, (%rsi,%rdi)
jne 0x8557
incl 0x3b0(%rbx)
incq %rdi
cmpq %rdi, %rcx
jne 0x854b
incq %rdx
cmpq %rax, %rdx
jne 0x853d
movslq 0x3b0(%rbx), %rdi
shlq $0x4, %rdi
callq 0x7100
movq %rax, 0x418(%rbx)
testq %rax, %rax
jne 0x8592
leaq 0x4b36(%rip), %rsi      # 0xd0c0
movq %rbx, %rdi
callq 0x978c
movslq 0x3b0(%rbx), %rdi
shlq $0x2, %rdi
callq 0x7100
movq %rax, 0x3b8(%rbx)
testq %rax, %rax
jne 0x85bd
leaq 0x4b17(%rip), %rsi      # 0xd0cc
movq %rbx, %rdi
callq 0x978c
movslq 0x3b0(%rbx), %rdi
shlq $0x3, %rdi
callq 0x7100
movq %rax, 0x3c0(%rbx)
testq %rax, %rax
jne 0x85e8
leaq 0x4afc(%rip), %rsi      # 0xd0dc
movq %rbx, %rdi
callq 0x978c
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x85fd
movq %rbx, %rdi
popq %rbx
jmp 0x91a8
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_sprite2
void	ft_init_sprite2(t_recup *recup, int i, int j, int v)
{
	i = i - 1;
	while (++i < recup->nblines)
	{
		j = -1;
		while (++j < recup->sizeline)
		{
			if (recup->map[i][j] == '2')
			{
				recup->sxy[v].x = (double)i + 0.5;
				recup->sxy[v].y = (double)j + 0.5;
				v++;
			}
		}
	}
}

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

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

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

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

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

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

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

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x2b8(%rdi)
jne 0x8d49
movsd 0x2e8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x452d(%rip), %xmm0     # 0xd110
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4505(%rip), %xmm0     # 0xd110
callq 0x7430
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x44d3(%rip), %xmm0     # 0xd110
callq 0x7430
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x44ab(%rip), %xmm0     # 0xd110
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x446b(%rip), %xmm0     # 0xd110
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4443(%rip), %xmm0     # 0xd110
callq 0x7430
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x4411(%rip), %xmm0     # 0xd110
callq 0x7430
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x43f1(%rip), %xmm0     # 0xd110
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x8d56
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting_move.c
// Function: ft_rotate_left
void	ft_rotate_left(t_recup *recup, double olddirx)
{
	double oldplanex;

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

// Assembly:
cmpl $0x1, 0x2b4(%rdi)
jne 0x8f02
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0x2e8(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2f8(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x378(%rdi), %xmm0
mulsd 0x4319(%rip), %xmm0     # 0xd0b0
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x42f1(%rip), %xmm0     # 0xd0b0
callq 0x7430
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x42bf(%rip), %xmm0     # 0xd0b0
callq 0x7430
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4297(%rip), %xmm0     # 0xd0b0
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4257(%rip), %xmm0     # 0xd0b0
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x422f(%rip), %xmm0     # 0xd0b0
callq 0x7430
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x41fd(%rip), %xmm0     # 0xd0b0
callq 0x7430
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x41dd(%rip), %xmm0     # 0xd0b0
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_get_texture_adress
void	ft_get_texture_adress(t_recup *recup)
{
	recup->texture[0].addr = (int *)mlx_get_data_addr(recup->texture[0].img,
			&recup->texture[0].bits_per_pixel,
			&recup->texture[0].line_length, &recup->texture[0].endian);
	recup->texture[1].addr = (int *)mlx_get_data_addr(recup->texture[1].img,
			&recup->texture[1].bits_per_pixel,
			&recup->texture[1].line_length, &recup->texture[1].endian);
	recup->texture[2].addr = (int *)mlx_get_data_addr(recup->texture[2].img,
			&recup->texture[2].bits_per_pixel,
			&recup->texture[2].line_length, &recup->texture[2].endian);
	recup->texture[3].addr = (int *)mlx_get_data_addr(recup->texture[3].img,
			&recup->texture[3].bits_per_pixel,
			&recup->texture[3].line_length, &recup->texture[3].endian);
	recup->texture[4].addr = (int *)mlx_get_data_addr(recup->texture[4].img,
			&recup->texture[4].bits_per_pixel,
			&recup->texture[4].line_length, &recup->texture[4].endian);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
leaq 0xb8(%rbx), %rsi
leaq 0xbc(%rbx), %rdx
leaq 0xc0(%rbx), %rcx
callq 0xb040
movq %rax, 0xb0(%rbx)
movq 0x108(%rbx), %rdi
leaq 0x118(%rbx), %rsi
leaq 0x11c(%rbx), %rdx
leaq 0x120(%rbx), %rcx
callq 0xb040
movq %rax, 0x110(%rbx)
movq 0x168(%rbx), %rdi
leaq 0x178(%rbx), %rsi
leaq 0x17c(%rbx), %rdx
leaq 0x180(%rbx), %rcx
callq 0xb040
movq %rax, 0x170(%rbx)
movq 0x1c8(%rbx), %rdi
leaq 0x1d8(%rbx), %rsi
leaq 0x1dc(%rbx), %rdx
leaq 0x1e0(%rbx), %rcx
callq 0xb040
movq %rax, 0x1d0(%rbx)
movq 0x228(%rbx), %rdi
leaq 0x238(%rbx), %rsi
leaq 0x23c(%rbx), %rdx
leaq 0x240(%rbx), %rcx
callq 0xb040
movq %rax, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_get_texture
void	ft_get_texture(t_recup *recup)
{
	if (!(recup->texture[0].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->no, &(recup->texture[0].width),
					&(recup->texture[0].height))))
		ft_error(recup, "Texture SO\n");
	if (!(recup->texture[1].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->so, &(recup->texture[1].width),
					&(recup->texture[1].height))))
		ft_error(recup, "Texture NO\n");
	if (!(recup->texture[2].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->we, &(recup->texture[2].width),
					&(recup->texture[2].height))))
		ft_error(recup, "Texture EA\n");
	if (!(recup->texture[3].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->ea, &(recup->texture[3].width),
					&(recup->texture[3].height))))
		ft_error(recup, "Texture WE\n");
	if (!(recup->texture[4].img = mlx_xpm_file_to_image(recup->data.mlx_ptr,
					recup->sp, &(recup->texture[4].width),
					&(recup->texture[4].height))))
		ft_error(recup, "Texture S\n");
	ft_get_texture_adress(recup);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x278(%rdi), %rdi
movq 0x18(%rbx), %rsi
leaq 0xe0(%rbx), %rdx
leaq 0xe4(%rbx), %rcx
callq 0xbfd0
movq %rax, 0xa8(%rbx)
testq %rax, %rax
jne 0x900f
leaq 0x4111(%rip), %rsi      # 0xd118
movq %rbx, %rdi
callq 0x978c
movq 0x278(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x140(%rbx), %rdx
leaq 0x144(%rbx), %rcx
callq 0xbfd0
movq %rax, 0x108(%rbx)
testq %rax, %rax
jne 0x9048
leaq 0x40e4(%rip), %rsi      # 0xd124
movq %rbx, %rdi
callq 0x978c
movq 0x278(%rbx), %rdi
movq 0x28(%rbx), %rsi
leaq 0x1a0(%rbx), %rdx
leaq 0x1a4(%rbx), %rcx
callq 0xbfd0
movq %rax, 0x168(%rbx)
testq %rax, %rax
jne 0x9081
leaq 0x40b7(%rip), %rsi      # 0xd130
movq %rbx, %rdi
callq 0x978c
movq 0x278(%rbx), %rdi
movq 0x30(%rbx), %rsi
leaq 0x200(%rbx), %rdx
leaq 0x204(%rbx), %rcx
callq 0xbfd0
movq %rax, 0x1c8(%rbx)
testq %rax, %rax
jne 0x90ba
leaq 0x408a(%rip), %rsi      # 0xd13c
movq %rbx, %rdi
callq 0x978c
movq 0x278(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x260(%rbx), %rdx
leaq 0x264(%rbx), %rcx
callq 0xbfd0
movq %rax, 0x228(%rbx)
testq %rax, %rax
jne 0x90f3
leaq 0x405d(%rip), %rsi      # 0xd148
movq %rbx, %rdi
callq 0x978c
movq %rbx, %rdi
popq %rbx
jmp 0x8f04
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_raycasting
int		ft_raycasting(t_recup *recup)
{
	recup->ray.x = 0;
	while (recup->ray.x < recup->rx)
	{
		ft_initialisation3(recup);
		ft_stepsidedist(recup);
		ft_color_column(recup);
		recup->s.zbuffer[recup->ray.x] = recup->ray.perpwalldist;
		recup->ray.x++;
	}
	ft_sprite(recup);
	if (recup->save == 1)
		ft_save(recup);
	mlx_put_image_to_window(recup->data.mlx_ptr, recup->data.mlx_win,
			recup->data.img, 0, 0);
	ft_forward_back(recup);
	ft_left_right(recup);
	ft_rotate_right_left(recup);
	ft_swap(recup);
	return (0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x380(%rdi)
cmpl $0x0, (%rdi)
jle 0x914f
movq %rbx, %rdi
callq 0x83a0
movq %rbx, %rdi
callq 0x8674
movq %rbx, %rdi
callq 0x80cb
movsd 0x358(%rbx), %xmm0
movq 0x410(%rbx), %rax
movslq 0x380(%rbx), %rcx
movsd %xmm0, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x380(%rbx)
cmpl (%rbx), %eax
jl 0x910f
movq %rbx, %rdi
callq 0x9634
cmpl $0x1, 0x68(%rbx)
jne 0x9165
movq %rbx, %rdi
callq 0x9ab9
movq 0x278(%rbx), %rdi
movq 0x280(%rbx), %rsi
movq 0x288(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xb060
movq %rbx, %rdi
callq 0x88d0
movq %rbx, %rdi
callq 0x8a37
movq %rbx, %rdi
callq 0x8ba2
movq %rbx, %rdi
callq 0x88b2
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_mlx
int		ft_mlx(t_recup *recup)
{
	ft_initialisation2(recup);
	if (!(recup->data.mlx_ptr = mlx_init()))
		ft_error(recup, "Mlx init impossible\n");
	mlx_get_screen_size(recup->data.mlx_ptr, &recup->screenx, &recup->screeny);
	recup->rx = (recup->rx > recup->screenx) ? recup->screenx : recup->rx;
	recup->ry = (recup->ry > recup->screeny) ? recup->screeny : recup->ry;
	ft_get_texture(recup);
	recup->data.img = mlx_new_image(recup->data.mlx_ptr, recup->rx, recup->ry);
	recup->data.addr = (int *)mlx_get_data_addr(recup->data.img, &recup->data.
			bits_per_pixel, &recup->data.line_length, &recup->data.endian);
	if (recup->save == 1)
		ft_raycasting(recup);
	recup->data.mlx_win = mlx_new_window(recup->data.mlx_ptr, recup->rx,
			recup->ry, "Hello world!");
	recup->data.img2 = mlx_new_image(recup->data.mlx_ptr, recup->rx, recup->ry);
	recup->data.addr2 = (int *)mlx_get_data_addr(recup->data.img2, &recup->
			data.bits_per_pixel, &recup->data.line_length, &recup->data.endian);
	mlx_hook(recup->data.mlx_win, 33, 1L << 17, ft_exit, recup);
	mlx_hook(recup->data.mlx_win, 2, 1L << 0, ft_key_press, recup);
	mlx_loop_hook(recup->data.mlx_ptr, ft_raycasting, recup);
	mlx_hook(recup->data.mlx_win, 3, 1L << 1, ft_key_release, recup);
	mlx_loop(recup->data.mlx_ptr);
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8324
xorl %eax, %eax
callq 0xa330
movq %rax, 0x278(%rbx)
testq %rax, %rax
jne 0x91da
leaq 0x3f81(%rip), %rsi      # 0xd153
movq %rbx, %rdi
callq 0x978c
movq 0x278(%rbx), %rdi
leaq 0x6c(%rbx), %rsi
leaq 0x70(%rbx), %rdx
callq 0xc9c0
movl 0x6c(%rbx), %eax
movl (%rbx), %ecx
movl 0x4(%rbx), %edx
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %eax, (%rbx)
movl 0x70(%rbx), %eax
cmpl %eax, %edx
cmovll %edx, %eax
movl %eax, 0x4(%rbx)
movq %rbx, %rdi
callq 0x8fd2
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0xadc0
movq %rax, 0x288(%rbx)
leaq 0x298(%rbx), %r14
leaq 0x29c(%rbx), %r15
leaq 0x2a0(%rbx), %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xb040
movq %rax, 0x290(%rbx)
cmpl $0x1, 0x68(%rbx)
jne 0x9263
movq %rbx, %rdi
callq 0x90fc
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
leaq 0x3ef2(%rip), %rcx      # 0xd168
callq 0xa630
movq %rax, 0x280(%rbx)
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0xadc0
movq %rax, 0x2c8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xb040
movq %rax, 0x2d0(%rbx)
movq 0x280(%rbx), %rdi
leaq 0x5e0(%rip), %rcx       # 0x98a0
movl $0x21, %esi
movl $0x20000, %edx          # imm = 0x20000
movq %rbx, %r8
callq 0xc8e0
movq 0x280(%rbx), %rdi
leaq -0x1328(%rip), %rcx     # 0x7fb8
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0xc8e0
movq 0x278(%rbx), %rdi
leaq -0x204(%rip), %rsi      # 0x90fc
movq %rbx, %rdx
callq 0xa8a0
movq 0x280(%rbx), %rdi
leaq -0x12c0(%rip), %rcx     # 0x8056
movl $0x3, %esi
movl $0x2, %edx
movq %rbx, %r8
callq 0xc8e0
movq 0x278(%rbx), %rdi
callq 0xa7a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_dist_order2
void	ft_dist_order2(t_recup *recup)
{
	int i;

	i = -1;
	while (++i < recup->s.nbspr)
	{
		recup->s.order[i] = i;
		recup->s.dist[i] = ((recup->ray.posx - recup->sxy[i].x) *
				(recup->ray.posx - recup->sxy[i].x) + (recup->ray.posy -
					recup->sxy[i].y) * (recup->ray.posy - recup->sxy[i].y));
	}
}

// Assembly:
cmpl $0x0, 0x3b0(%rdi)
jle 0x93a8
movq 0x3b8(%rdi), %rax
movq 0x3c0(%rdi), %rcx
movq 0x418(%rdi), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movl %esi, (%rax,%rsi,4)
movsd 0x2d8(%rdi), %xmm0
movsd 0x2e0(%rdi), %xmm1
subsd -0x8(%rdx), %xmm0
subsd (%rdx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
movslq 0x3b0(%rdi), %r8
addq $0x10, %rdx
cmpq %r8, %rsi
jl 0x9368
retq
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_dist_order
void	ft_dist_order(t_recup *recup)
{
	int		i;
	int		j;
	double	tmp;

	ft_dist_order2(recup);
	i = -1;
	while (++i < recup->s.nbspr)
	{
		j = -1;
		while (++j < recup->s.nbspr - 1)
		{
			if (recup->s.dist[j] < recup->s.dist[j + 1])
			{
				tmp = recup->s.dist[j];
				recup->s.dist[j] = recup->s.dist[j + 1];
				recup->s.dist[j + 1] = tmp;
				tmp = recup->s.order[j];
				recup->s.order[j] = recup->s.order[j + 1];
				recup->s.order[j + 1] = (int)tmp;
			}
		}
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x9344
cmpl $0x0, 0x3b0(%rbx)
jle 0x941e
xorl %eax, %eax
cmpl $0x2, 0x3b0(%rbx)
jl 0x9414
movq 0x3c0(%rbx), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
movsd 0x8(%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9402
movsd %xmm1, (%rcx,%rdx,8)
movsd %xmm0, 0x8(%rcx,%rdx,8)
movq 0x3b8(%rbx), %rsi
movl (%rsi,%rdx,4), %edi
movl 0x4(%rsi,%rdx,4), %r8d
movl %r8d, (%rsi,%rdx,4)
movl %edi, 0x4(%rsi,%rdx,4)
incq %rdx
movslq 0x3b0(%rbx), %rsi
decq %rsi
cmpq %rsi, %rdx
jl 0x93cf
incl %eax
cmpl 0x3b0(%rbx), %eax
jl 0x93bd
popq %rbx
retq