LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/raycasting_init.c
// Function: ft_init_sprite
void	ft_init_sprite(t_recup *recup)
{
	int i;
	int j;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x3b0(%rdi)
callq 0x9514
movl 0x40(%rbx), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
decl %ecx
movslq %ecx, %rcx
pushq $-0x1
popq %rdx
cmpq %rcx, %rdx
je 0x83a3
incq %rdx
movl 0x44(%rbx), %esi
testl %esi, %esi
cmovlel %eax, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x8372
movq 0x48(%rbx), %r8
movq (%r8,%rdx,8), %r8
cmpb $0x32, (%r8,%rdi)
jne 0x839e
incl 0x3b0(%rbx)
incq %rdi
jmp 0x8384
movslq 0x3b0(%rbx), %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x7100
movq %rax, 0x418(%rbx)
testq %rax, %rax
jne 0x83d8
leaq 0x4d47(%rip), %rsi      # 0xd110
movq %rbx, %rdi
callq 0x95a0
movslq 0x3b0(%rbx), %r14
leaq (,%r14,4), %rdi
callq 0x7100
movq %rax, 0x3b8(%rbx)
testq %rax, %rax
jne 0x8407
leaq 0x4d24(%rip), %rsi      # 0xd11c
movq %rbx, %rdi
callq 0x95a0
movslq 0x3b0(%rbx), %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x7100
movq %rax, 0x3c0(%rbx)
testq %rax, %rax
jne 0x842e
leaq 0x4d06(%rip), %rsi      # 0xd12c
movq %rbx, %rdi
callq 0x95a0
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x8449
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8fe9
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
decl %esi
movslq 0x40(%rdi), %rax
movslq %esi, %rdx
movsd 0x4cad(%rip), %xmm0     # 0xd108
xorl %esi, %esi
movabsq $-0x1, %r8
incq %rdx
cmpq %rax, %rdx
jge 0x84d5
cvtsi2sd %edx, %xmm1
movl 0x44(%rdi), %r9d
testl %r9d, %r9d
cmovlel %esi, %r9d
addsd %xmm0, %xmm1
decl %r9d
movslq %r9d, %r9
movq %r8, %r10
movq %r10, %r11
cmpq %r11, %r9
je 0x8467
leaq 0x1(%r11), %r10
movq 0x48(%rdi), %rbx
movq (%rbx,%rdx,8), %rbx
cmpb $0x32, 0x1(%rbx,%r11)
movq %r10, %r11
jne 0x848e
movq 0x418(%rdi), %r11
movslq %ecx, %rcx
movq %rcx, %rbx
shlq $0x4, %rbx
cvtsi2sd %r10d, %xmm2
movsd %xmm1, (%r11,%rbx)
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%r11,%rbx)
incl %ecx
jmp 0x848b
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x84ff
movsd 0x2d8(%rdi), %xmm0
cvtsi2sdl 0x320(%rdi), %xmm1
subsd %xmm1, %xmm0
pushq $-0x1
popq %rax
jmp 0x851a
pushq $0x1
popq %rax
cvtsi2sdl 0x320(%rdi), %xmm0
addsd 0x4c2e(%rip), %xmm0     # 0xd140
subsd 0x2d8(%rdi), %xmm0
mulsd 0x338(%rdi), %xmm0
movl %eax, 0x348(%rdi)
movsd %xmm0, 0x328(%rdi)
xorpd %xmm0, %xmm0
ucomisd 0x310(%rdi), %xmm0
jbe 0x8557
pushq $-0x1
popq %rax
movsd 0x2e0(%rdi), %xmm0
cvtsi2sdl 0x324(%rdi), %xmm1
subsd %xmm1, %xmm0
jmp 0x8572
cvtsi2sdl 0x324(%rdi), %xmm0
addsd 0x4bd9(%rip), %xmm0     # 0xd140
subsd 0x2e0(%rdi), %xmm0
pushq $0x1
popq %rax
mulsd 0x340(%rdi), %xmm0
movl %eax, 0x34c(%rdi)
movsd %xmm0, 0x330(%rdi)
jmp 0x858d
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/raycasting_utils.c
// Function: ft_incrementray
void	ft_incrementray(t_recup *recup)
{
	while (recup->ray.hit == 0)
	{
		if (recup->ray.sidedistx < recup->ray.sidedisty)
		{
			recup->ray.sidedistx += recup->ray.deltadistx;
			recup->ray.mapx += recup->ray.stepx;
			recup->ray.side = 0;
		}
		else
		{
			recup->ray.sidedisty += recup->ray.deltadisty;
			recup->ray.mapy += recup->ray.stepy;
			recup->ray.side = 1;
		}
		if (recup->map[recup->ray.mapx][recup->ray.mapy] == '1')
			recup->ray.hit = 1;
	}
	ft_drawstartend(recup);
}

// Assembly:
cmpl $0x0, 0x350(%rdi)
sete %al
testb $0x1, %al
je 0x8641
movsd 0x328(%rdi), %xmm0
movsd 0x330(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x85e6
addsd 0x338(%rdi), %xmm0
movsd %xmm0, 0x328(%rdi)
movl 0x320(%rdi), %ecx
movl 0x324(%rdi), %eax
addl 0x348(%rdi), %ecx
movl %ecx, 0x320(%rdi)
andl $0x0, 0x354(%rdi)
jmp 0x8618
addsd 0x340(%rdi), %xmm1
movsd %xmm1, 0x330(%rdi)
movl 0x320(%rdi), %ecx
movl 0x324(%rdi), %eax
addl 0x34c(%rdi), %eax
movl %eax, 0x324(%rdi)
movl $0x1, 0x354(%rdi)
movq 0x48(%rdi), %rdx
movslq %ecx, %rcx
movq (%rdx,%rcx,8), %rcx
cltq
cmpb $0x31, (%rcx,%rax)
setne %al
jne 0x8597
movl $0x1, 0x350(%rdi)
jmp 0x8597
// File: /workspace/github_c_makefile_star2_O2/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 0x8664
leaq 0x324(%rdi), %rdx
leaq 0x2e0(%rdi), %rcx
movl $0x310, %eax            # imm = 0x310
movl $0x34c, %esi            # imm = 0x34C
jmp 0x867c
leaq 0x2d8(%rdi), %rcx
leaq 0x320(%rdi), %rdx
movl $0x308, %eax            # imm = 0x308
movl $0x348, %esi            # imm = 0x348
cvtsi2sdl (%rdx), %xmm0
subsd (%rcx), %xmm0
cvtsi2sdl (%rdi,%rsi), %xmm1
movsd 0x4aaf(%rip), %xmm2     # 0xd140
subsd %xmm1, %xmm2
mulsd 0x4a6b(%rip), %xmm2     # 0xd108
addsd %xmm0, %xmm2
divsd (%rdi,%rax), %xmm2
movsd %xmm2, 0x358(%rdi)
movl 0x4(%rdi), %ecx
cvtsi2sd %ecx, %xmm0
divsd %xmm2, %xmm0
cvttsd2si %xmm0, %esi
movl %esi, 0x360(%rdi)
pushq $-0x2
popq %r8
movl %esi, %eax
cltd
idivl %r8d
movl %eax, %r8d
pushq $0x2
popq %r10
movl %ecx, %eax
cltd
idivl %r10d
movl %eax, %r9d
addl %eax, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovgl %r8d, %eax
movl %eax, 0x364(%rdi)
movl %esi, %eax
cltd
idivl %r10d
addl %r9d, %eax
leal -0x1(%rcx), %edx
testl %eax, %eax
movl %eax, %esi
cmovsl %edx, %esi
cmpl %ecx, %eax
cmovgel %edx, %esi
movl %esi, 0x368(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x87c9
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 0x8791
addsd %xmm3, %xmm2
movsd %xmm2, 0x2d8(%rdi)
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
mulsd 0x2f0(%rdi), %xmm0
movapd %xmm0, %xmm2
addsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x87c9
addsd %xmm1, %xmm0
movsd %xmm0, 0x2e0(%rdi)
cmpl $0x1, 0x2a8(%rdi)
jne 0x888a
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 0x883e
xorpd 0x4922(%rip), %xmm3     # 0xd150
mulsd %xmm0, %xmm3
addsd %xmm3, %xmm2
movsd %xmm2, 0x2d8(%rdi)
cvttsd2si %xmm2, %ecx
movslq %ecx, %rcx
movsd 0x2f0(%rdi), %xmm2
movapd %xmm0, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm3
movapd %xmm1, %xmm4
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x888a
xorpd 0x48d6(%rip), %xmm2     # 0xd150
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x2e0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x893c
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 0x88f8
mulsd %xmm0, %xmm4
addsd %xmm4, %xmm3
movsd %xmm3, 0x2d8(%rdi)
cvttsd2si %xmm3, %ecx
movslq %ecx, %rcx
movsd 0x2e8(%rdi), %xmm3
mulsd %xmm3, %xmm2
movapd %xmm1, %xmm4
subsd %xmm2, %xmm4
cvttsd2si %xmm4, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x893c
xorpd 0x4824(%rip), %xmm3     # 0xd150
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x2e0(%rdi)
cmpl $0x1, 0x2ac(%rdi)
jne 0x89ed
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 0x89b5
xorpd 0x47ab(%rip), %xmm4     # 0xd150
mulsd %xmm0, %xmm4
addsd %xmm4, %xmm3
movsd %xmm3, 0x2d8(%rdi)
cvttsd2si %xmm3, %ecx
movslq %ecx, %rcx
movsd 0x2e8(%rdi), %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edx
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
cmpb $0x30, (%rax,%rcx)
jne 0x89ed
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, 0x2e0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8b95
movsd 0x2e8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4731(%rip), %xmm0     # 0xd160
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4709(%rip), %xmm0     # 0xd160
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x46d7(%rip), %xmm0     # 0xd160
callq 0x7420
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x46af(%rip), %xmm0     # 0xd160
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x466f(%rip), %xmm0     # 0xd160
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4647(%rip), %xmm0     # 0xd160
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x4615(%rip), %xmm0     # 0xd160
callq 0x7420
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x45f5(%rip), %xmm0     # 0xd160
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x8ba2
// File: /workspace/github_c_makefile_star2_O2/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 0x8d4e
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 0x4525(%rip), %xmm0     # 0xd108
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x44fd(%rip), %xmm0     # 0xd108
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2e8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x44cb(%rip), %xmm0     # 0xd108
callq 0x7420
movsd %xmm0, (%rsp)
movsd 0x2f0(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x44a3(%rip), %xmm0     # 0xd108
callq 0x7140
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x2f0(%rbx)
movsd 0x2f8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x4463(%rip), %xmm0     # 0xd108
callq 0x7140
movsd %xmm0, (%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x378(%rbx), %xmm0
mulsd 0x443b(%rip), %xmm0     # 0xd108
callq 0x7420
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x2f8(%rbx)
movsd 0x378(%rbx), %xmm0
mulsd 0x4409(%rip), %xmm0     # 0xd108
callq 0x7420
movsd %xmm0, 0x8(%rsp)
movsd 0x300(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x43e9(%rip), %xmm0     # 0xd108
mulsd 0x378(%rbx), %xmm0
callq 0x7140
mulsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x300(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xbca0
movq %rax, 0xa8(%rbx)
testq %rax, %rax
jne 0x8e5b
leaq 0x4315(%rip), %rsi      # 0xd168
movq %rbx, %rdi
callq 0x95a0
movq 0x278(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x140(%rbx), %rdx
leaq 0x144(%rbx), %rcx
callq 0xbca0
movq %rax, 0x108(%rbx)
testq %rax, %rax
jne 0x8e94
leaq 0x42e8(%rip), %rsi      # 0xd174
movq %rbx, %rdi
callq 0x95a0
movq 0x278(%rbx), %rdi
movq 0x28(%rbx), %rsi
leaq 0x1a0(%rbx), %rdx
leaq 0x1a4(%rbx), %rcx
callq 0xbca0
movq %rax, 0x168(%rbx)
testq %rax, %rax
jne 0x8ecd
leaq 0x42bb(%rip), %rsi      # 0xd180
movq %rbx, %rdi
callq 0x95a0
movq 0x278(%rbx), %rdi
movq 0x30(%rbx), %rsi
leaq 0x200(%rbx), %rdx
leaq 0x204(%rbx), %rcx
callq 0xbca0
movq %rax, 0x1c8(%rbx)
testq %rax, %rax
jne 0x8f06
leaq 0x428e(%rip), %rsi      # 0xd18c
movq %rbx, %rdi
callq 0x95a0
movq 0x278(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x260(%rbx), %rdx
leaq 0x264(%rbx), %rcx
callq 0xbca0
movq %rax, 0x228(%rbx)
testq %rax, %rax
jne 0x8f3f
leaq 0x4261(%rip), %rsi      # 0xd198
movq %rbx, %rdi
callq 0x95a0
movq %rbx, %rdi
popq %rbx
jmp 0x8d50
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
movl %eax, 0x380(%rbx)
cmpl (%rbx), %eax
jge 0x8f90
movq %rbx, %rdi
callq 0x8215
movq %rbx, %rdi
callq 0x84d8
movq %rbx, %rdi
callq 0x7fa3
movsd 0x358(%rbx), %xmm0
movq 0x410(%rbx), %rax
movslq 0x380(%rbx), %rcx
movsd %xmm0, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
jmp 0x8f4e
movq %rbx, %rdi
callq 0x9453
cmpl $0x1, 0x68(%rbx)
jne 0x8fa6
movq %rbx, %rdi
callq 0x9881
movq 0x278(%rbx), %rdi
movq 0x280(%rbx), %rsi
movq 0x288(%rbx), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xad30
movq %rbx, %rdi
callq 0x872c
movq %rbx, %rdi
callq 0x888b
movq %rbx, %rdi
callq 0x89ee
movq %rbx, %rdi
callq 0x870e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x8
popq %rax
xorl %ecx, %ecx
movslq 0x3b0(%rdi), %rdx
cmpq %rdx, %rcx
jge 0x91e2
movq 0x3b8(%rdi), %rdx
movl %ecx, (%rdx,%rcx,4)
movq 0x418(%rdi), %rdx
movsd 0x2d8(%rdi), %xmm0
movsd 0x2e0(%rdi), %xmm1
subsd -0x8(%rdx,%rax), %xmm0
subsd (%rdx,%rax), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0x3c0(%rdi), %rdx
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
addq $0x10, %rax
jmp 0x9189
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9184
movl 0x3b0(%rbx), %edx
pushq $-0x1
popq %rax
pushq $-0x1
popq %rcx
incl %eax
cmpl %edx, %eax
jge 0x925d
movq %rcx, %rsi
movq %rsi, %rdi
leaq 0x1(%rdi), %rsi
leal -0x1(%rdx), %r8d
movslq %r8d, %r8
cmpq %r8, %rsi
jge 0x91f8
movq 0x3c0(%rbx), %r8
movsd 0x8(%r8,%rdi,8), %xmm0
movsd 0x10(%r8,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
movq %rsi, %rdi
jbe 0x9204
movsd %xmm1, (%r8,%rsi,8)
movsd %xmm0, 0x8(%r8,%rsi,8)
movq 0x3b8(%rbx), %rdx
movq (%rdx,%rsi,4), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, (%rdx,%rsi,4)
movl 0x3b0(%rbx), %edx
jmp 0x9201
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_draw_spr
void	ft_draw_spr(t_recup *recup, int y, int texx, int stripe)
{
	int		d;
	int		texy;

	while (y < recup->s.drawendy)
	{
		d = (y) * 256 - recup->ry * 128 + recup->s.spriteheight * 128;
		texy = ((d * recup->texture[4].height) / recup->s.spriteheight) / 256;
		if (recup->texture[4].addr[texy * recup->texture[4].line_length / 4 +
				texx] != -16777216)
		{
			recup->data.addr[y * recup->data.line_length / 4 + stripe] =
				recup->texture[4].addr[texy * recup->texture[4].line_length /
				4 + texx];
		}
		y++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
movl %edx, %r8d
movl %esi, %r9d
shll $0x8, %r9d
movl $0x100, %r10d           # imm = 0x100
movl $0x4, %r11d
cmpl 0x400(%rdi), %esi
jge 0x944f
movl 0x4(%rdi), %edx
shll $0x7, %edx
movl 0x3f4(%rdi), %ebx
movl %ebx, %eax
shll $0x7, %eax
subl %edx, %eax
addl %r9d, %eax
imull 0x264(%rdi), %eax
cltd
idivl %ebx
cltd
idivl %r10d
movq 0x230(%rdi), %rbx
imull 0x23c(%rdi), %eax
cltd
idivl %r11d
addl %r8d, %eax
cltq
movl (%rbx,%rax,4), %ebx
cmpl $0xff000000, %ebx       # imm = 0xFF000000
je 0x9444
movq 0x290(%rdi), %r14
movl 0x29c(%rdi), %eax
imull %esi, %eax
cltd
idivl %r11d
addl %ecx, %eax
cltq
movl %ebx, (%r14,%rax,4)
incl %esi
addl $0x100, %r9d            # imm = 0x100
jmp 0x93da
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_sprite
void	ft_sprite(t_recup *recup)
{
	int i;
	int y;
	int stripe;
	int texx;

	i = -1;
	ft_dist_order(recup);
	while (++i < recup->s.nbspr)
	{
		ft_calculs(recup, i);
		stripe = recup->s.drawstartx;
		while (stripe < recup->s.drawendx)
		{
			texx = (int)(256 * (stripe - (-recup->s.spritewidth / 2 +
							recup->s.spritescreenx)) * recup->texture[4].width
					/ recup->s.spritewidth) / 256;
			if (recup->s.transformy > 0 && stripe >= 0 && stripe < recup->rx
					&& recup->s.transformy < recup->s.zbuffer[stripe])
			{
				y = recup->s.drawstarty;
				ft_draw_spr(recup, y, texx, stripe);
			}
			stripe++;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x91e3
pushq $-0x1
popq %rbp
pushq $0x2
popq %r15
movl $0x100, %r12d           # imm = 0x100
incl %ebp
cmpl 0x3b0(%rbx), %ebp
jge 0x950b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x925f
xorpd %xmm2, %xmm2
movl 0x3f8(%rbx), %r14d
cmpl 0x404(%rbx), %r14d
jge 0x9470
movl 0x408(%rbx), %ecx
movl %ecx, %eax
cltd
idivl %r15d
subl 0x3f0(%rbx), %eax
addl %r14d, %eax
imull 0x260(%rbx), %eax
shll $0x8, %eax
cltd
idivl %ecx
cltd
idivl %r12d
testl %r14d, %r14d
js 0x9506
movsd 0x3e8(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x9506
cmpl (%rbx), %r14d
jge 0x9506
movq 0x410(%rbx), %rcx
movl %r14d, %edx
movsd (%rcx,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9506
movl 0x3fc(%rbx), %esi
movq %rbx, %rdi
movl %eax, %edx
movl %r14d, %ecx
callq 0x93c1
xorpd %xmm2, %xmm2
incl %r14d
jmp 0x9493
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/errors.c
// Function: ft_verify_errors
void	ft_verify_errors(t_recup *recup)
{
	if (ft_murs(recup) == 1)
		ft_error(recup, "Map non entouree de 1\n");
	if (recup->depart == 'x')
		ft_error(recup, "Pas de joueur\n");
	if (recup->indicateur2 != 6)
		ft_error(recup, "Mauvaises donnees F ou C\n");
	if (recup->multijoueurs == 1)
		ft_error(recup, "Plus d'un joueur\n");
	if (recup->lignevide == 1)
		ft_error(recup, "Ligne vide dans la map\n");
	if (recup->wrongcharmap == 2)
		ft_error(recup, "Caractere incorrect dans la map\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7b9c
cmpl $0x1, %eax
jne 0x9531
leaq 0x3c9c(%rip), %rsi      # 0xd1c5
movq %rbx, %rdi
callq 0x95a0
cmpb $0x78, 0x50(%rbx)
jne 0x9546
leaq 0x3c9e(%rip), %rsi      # 0xd1dc
movq %rbx, %rdi
callq 0x95a0
cmpl $0x6, 0x60(%rbx)
je 0x955b
leaq 0x3c98(%rip), %rsi      # 0xd1eb
movq %rbx, %rdi
callq 0x95a0
cmpl $0x1, 0x78(%rbx)
jne 0x9570
leaq 0x3c9d(%rip), %rsi      # 0xd205
movq %rbx, %rdi
callq 0x95a0
cmpl $0x1, 0x7c(%rbx)
jne 0x9585
leaq 0x3c9a(%rip), %rsi      # 0xd217
movq %rbx, %rdi
callq 0x95a0
cmpl $0x2, 0x90(%rbx)
jne 0x959e
leaq 0x3c9a(%rip), %rsi      # 0xd22f
movq %rbx, %rdi
popq %rbx
jmp 0x95a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/errors.c
// Function: ft_error
void	ft_error(t_recup *recup, char *str)
{
	int i;

	i = -1;
	recup->indicateur3 = 1;
	write(1, "Error\n", 6);
	write(1, str, ft_strlen(str));
	if (recup->no)
		free(recup->no);
	if (recup->so)
		free(recup->so);
	if (recup->we)
		free(recup->we);
	if (recup->ea)
		free(recup->ea);
	if (recup->sp)
		free(recup->sp);
	if (recup->map)
	{
		while (++i < recup->nblines)
			free(recup->map[i]);
	}
	ft_error2(recup);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x64(%rdi)
leaq 0x3c98(%rip), %rsi      # 0xd250
pushq $0x1
popq %rbp
pushq $0x6
popq %rdx
movl %ebp, %edi
callq 0x73d0
movq %r14, %rdi
callq 0x9b98
movslq %eax, %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x73d0
movq 0x18(%rbx), %rdi
callq 0x7190
movq 0x20(%rbx), %rdi
callq 0x7190
movq 0x28(%rbx), %rdi
callq 0x7190
movq 0x30(%rbx), %rdi
callq 0x7190
movq 0x38(%rbx), %rdi
callq 0x7190
cmpq $0x0, 0x48(%rbx)
jne 0x9616
movq %rbx, %rdi
callq 0x9634
xorl %r14d, %r14d
movslq 0x40(%rbx), %rax
cmpq %rax, %r14
jge 0x960e
movq 0x48(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7190
incq %r14
jmp 0x9619
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/errors.c
// Function: ft_error2
void	ft_error2(t_recup *recup)
{
	if (recup->map)
		free(recup->map);
	if (recup->s.order)
		free(recup->s.order);
	if (recup->s.dist)
		free(recup->s.dist);
	if (recup->sxy)
		free(recup->sxy);
	if (recup->s.zbuffer)
		free(recup->s.zbuffer);
	ft_exit(recup);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x7190
movq 0x3b8(%rbx), %rdi
callq 0x7190
movq 0x3c0(%rbx), %rdi
callq 0x7190
movq 0x418(%rbx), %rdi
callq 0x7190
movq 0x410(%rbx), %rdi
callq 0x7190
movq %rbx, %rdi
callq 0x9679
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/errors.c
// Function: ft_exit
int		ft_exit(t_recup *recup)
{
	if (recup->indicateur3 == 0)
		ft_error(recup, "Non jrigole\n");
	if (recup->data.img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->data.img);
	if (recup->texture[0].img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->texture[0].img);
	if (recup->texture[1].img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->texture[1].img);
	if (recup->texture[2].img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->texture[2].img);
	if (recup->texture[3].img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->texture[3].img);
	if (recup->texture[4].img)
		mlx_destroy_image(recup->data.mlx_ptr, recup->texture[4].img);
	if (recup->data.mlx_win)
		mlx_destroy_window(recup->data.mlx_ptr, recup->data.mlx_win);
	exit(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x64(%rdi)
jne 0x9692
leaq 0x3a3a(%rip), %rsi      # 0xd0c4
movq %rbx, %rdi
callq 0x95a0
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x96aa
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
je 0x96c2
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0x108(%rbx), %rsi
testq %rsi, %rsi
je 0x96da
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0x96f2
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0x1c8(%rbx), %rsi
testq %rsi, %rsi
je 0x970a
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0x228(%rbx), %rsi
testq %rsi, %rsi
je 0x9722
movq 0x278(%rbx), %rdi
callq 0xc600
movq 0x280(%rbx), %rsi
testq %rsi, %rsi
je 0x973a
movq 0x278(%rbx), %rdi
callq 0xc050
xorl %edi, %edi
callq 0x70a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/save.c
// Function: ft_header
void	ft_header(t_recup *recup, int fd)
{
	int	tmp;

	write(fd, "BM", 2);
	tmp = 14 + 40 + 4 * recup->rx * recup->ry;
	write(fd, &tmp, 4);
	tmp = 0;
	write(fd, &tmp, 2);
	write(fd, &tmp, 2);
	tmp = 54;
	write(fd, &tmp, 4);
	tmp = 40;
	write(fd, &tmp, 4);
	write(fd, &recup->rx, 4);
	write(fd, &recup->ry, 4);
	tmp = 1;
	write(fd, &tmp, 2);
	write(fd, &recup->data.bits_per_pixel, 2);
	tmp = 0;
	write(fd, &tmp, 4);
	write(fd, &tmp, 4);
	write(fd, &tmp, 4);
	write(fd, &tmp, 4);
	write(fd, &tmp, 4);
	write(fd, &tmp, 4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
leaq 0x3afc(%rip), %rsi      # 0xd257
pushq $0x2
popq %r13
movl %ebx, %edi
movq %r13, %rdx
callq 0x73d0
movl (%r12), %eax
imull 0x4(%r12), %eax
leaq 0x4(%r12), %rbp
leal 0x36(,%rax,4), %eax
leaq 0x4(%rsp), %r14
movl %eax, (%r14)
pushq $0x4
popq %r15
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
andl $0x0, (%r14)
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x73d0
movl $0x36, (%r14)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl $0x28, (%r14)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x73d0
movl $0x1, (%r14)
movl %ebx, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x73d0
addq $0x298, %r12            # imm = 0x298
movl %ebx, %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x73d0
andl $0x0, (%r14)
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x73d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/save.c
// Function: ft_save
void	ft_save(t_recup *recup)
{
	int	fd;
	int	x;
	int	y;

	y = recup->ry;
	if ((fd = open("./image.bmp", O_CREAT | O_RDWR)) == -1)
		ft_error(recup, "Impossible de creer .bmp\n");
	ft_header(recup, fd);
	while (y >= 0)
	{
		x = 0;
		while (x < recup->rx)
		{
			write(fd, &recup->data.addr[y * recup->data.line_length / 4 + x],
				4);
			x++;
		}
		y--;
	}
	system("chmod 777 image.bmp");
	ft_error(recup, "Non jrigole --save ok\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %r15d
leaq 0x39c0(%rip), %rdi      # 0xd25a
pushq $0x42
popq %rsi
xorl %eax, %eax
callq 0x7400
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x98ba
leaq 0x39b4(%rip), %rsi      # 0xd266
movq %rbx, %rdi
callq 0x95a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9744
pushq $0x4
popq %r12
pushq $0x4
popq %r14
testl %r15d, %r15d
js 0x990c
xorl %r13d, %r13d
cmpl (%rbx), %r13d
jge 0x9907
movl 0x29c(%rbx), %eax
imull %r15d, %eax
cltd
idivl %r12d
movslq %eax, %rsi
addq %r13, %rsi
shlq $0x2, %rsi
addq 0x290(%rbx), %rsi
movl %ebp, %edi
movq %r14, %rdx
callq 0x73d0
incq %r13
jmp 0x98d4
decl %r15d
jmp 0x98cc
leaq 0x396d(%rip), %rdi      # 0xd280
callq 0x7110
leaq 0x3975(%rip), %rsi      # 0xd294
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x95a0
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/save.c
// Function: ft_check_save
int		ft_check_save(char *str)
{
	int	i;

	i = 0;
	while (str[i])
		i++;
	if (str[i - 1] == 'e' && str[i - 2] == 'v' && str[i - 3] == 'a' &&
		str[i - 4] == 's' && str[i - 5] == '-' && str[i - 6] == '-'
		&& ft_strlen(str) < 7)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rax
movq %rdi, %rax
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x9939
cmpb $0x65, -0x2(%rax)
jne 0x9975
cmpb $0x76, -0x3(%rax)
jne 0x9975
cmpb $0x61, -0x4(%rax)
jne 0x9975
cmpb $0x73, -0x5(%rax)
jne 0x9975
cmpb $0x2d, -0x6(%rax)
jne 0x9975
cmpb $0x2d, -0x7(%rax)
jne 0x9975
callq 0x9b98
cmpl $0x7, %eax
jge 0x9975
pushq $0x1
popq %rax
jmp 0x9977
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line.c
// Function: ft_copy
int		ft_copy(char **line, char **buff)
{
	int		start;
	char	*temp;
	char	*line_temp;

	if ((start = ft_check(*buff)) >= 0)
	{
		temp = ft_substr(*buff, 0, start);
		line_temp = *line;
		*line = ft_strjoin(*line, temp);
		free(temp);
		free(line_temp);
		*buff = ft_subbuff(*buff, start + 1, (ft_strlen(*buff) - start));
		return (0);
	}
	else
	{
		temp = NULL;
		if (*line)
			temp = *line;
		*line = ft_strjoin(*line, *buff);
		if (temp)
			free(temp);
		return (1);
	}
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
movq %r12, %rdi
callq 0x9994
testl %eax, %eax
js 0x9a25
movl %eax, %r14d
movl %eax, %edx
xorl %ebp, %ebp
movq %r12, %rdi
xorl %esi, %esi
callq 0x9baf
movq %rax, %r12
movq (%r15), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x9c06
movq %rax, (%r15)
movq %r12, %rdi
callq 0x7190
movq %r13, %rdi
callq 0x7190
movq (%rbx), %r15
leal 0x1(%r14), %r12d
movq %r15, %rdi
callq 0x9b98
subl %r14d, %eax
movq %r15, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x9c72
movq %rax, (%rbx)
jmp 0x9a41
movq (%r15), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9c06
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x7190
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line.c
// Function: ft_eof
int		ft_eof(int ret, char **buff, char **line)
{
	if (ret == -1)
		return (-1);
	free(*buff);
	*buff = NULL;
	if (*line == NULL)
	{
		*line = malloc(sizeof(char) * 1);
		*line[0] = 0;
	}
	return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0x9a85
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x7190
andq $0x0, (%r14)
xorl %ebp, %ebp
cmpq $0x0, (%rbx)
jne 0x9a88
pushq $0x1
popq %rdi
callq 0x7100
movq %rax, (%rbx)
movb $0x0, (%rax)
jmp 0x9a88
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line.c
// Function: get_next_line
int		get_next_line(int fd, char **line, t_recup *recup)
{
	static char	*buff = NULL;
	int			ret;

	if (ft_free_buff(&buff, recup) == 1)
		return (0);
	if (fd < 0 || BUFFER_SIZE <= 0 || !line)
		return (-1);
	*line = NULL;
	ret = 1;
	if (buff)
		ret = ft_copy(line, &buff);
	if (ret == 0)
		return (1);
	if (!buff)
		if (!(buff = malloc(sizeof(char) * BUFFER_SIZE + 1)))
			return (-1);
	while ((ret = read(fd, buff, BUFFER_SIZE)) > 0)
	{
		buff[ret] = '\0';
		if (!ft_copy(line, &buff))
			return (1);
	}
	if (ret <= 0)
		return (ft_eof(ret, &buff, line));
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xb7f9(%rip), %rdi      # 0x152b8
movq %rdx, %rsi
callq 0x9a8f
xorl %r14d, %r14d
testl %eax, %eax
jne 0x9b6e
testl %ebp, %ebp
sets %al
testq %rbx, %rbx
sete %cl
pushq $-0x1
popq %r14
orb %al, %cl
jne 0x9b6e
andq $0x0, (%rbx)
cmpq $0x0, 0xb7c3(%rip)      # 0x152b8
pushq $0x1
popq %r15
je 0x9b18
leaq 0xb7b6(%rip), %rsi      # 0x152b8
movq %rbx, %rdi
callq 0x99ac
testl %eax, %eax
je 0x9b6b
cmpq $0x0, 0xb7a2(%rip)      # 0x152b8
jne 0x9b2e
movl $0x1001, %edi           # imm = 0x1001
callq 0x7100
movq %rax, 0xb78f(%rip)      # 0x152b8
testq %rax, %rax
je 0x9b6e
leaq 0xb783(%rip), %r14      # 0x152b8
movq 0xb77c(%rip), %rsi      # 0x152b8
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x70e0
testl %eax, %eax
jle 0x9b7c
movq 0xb765(%rip), %rcx      # 0x152b8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x99ac
testl %eax, %eax
jne 0x9b35
movl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb735(%rip), %rsi      # 0x152b8
movl %eax, %edi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9a52
nop
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line_utils.c
// Function: ft_substr
char		*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*str;
	size_t	i;

	i = 0;
	str = malloc(sizeof(char) * (len + 1));
	if (start < (unsigned int)ft_strlen((char *)s))
	{
		while (s[start] != '\0' && i < len)
		{
			str[i] = s[start];
			i++;
			start++;
		}
	}
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
callq 0x7100
movq %rax, %rbx
movq %r15, %rdi
callq 0x9b98
cmpl %ebp, %eax
jbe 0x9bf2
movl %ebp, %ecx
xorl %eax, %eax
leal (%rcx,%rax), %edx
movb (%r15,%rdx), %dl
testb %dl, %dl
je 0x9bf4
cmpq %r14, %rax
jae 0x9bf4
movb %dl, (%rbx,%rax)
incq %rax
jmp 0x9bda
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line_utils.c
// Function: ft_strjoin
char		*ft_strjoin(char *s1, char *s2)
{
	char	*str;
	int		i;
	int		j;

	if (!(str = malloc(sizeof(char) * (ft_strlen(s1) + ft_strlen(s2) + 1))))
		return (NULL);
	i = 0;
	while (s1 && s1[i])
	{
		str[i] = s1[i];
		i++;
	}
	j = 0;
	while (s2 && s2[j])
	{
		str[i] = s2[j];
		j++;
		i++;
	}
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9b98
movl %eax, %r15d
movq %rbx, %rdi
callq 0x9b98
addl %r15d, %eax
incl %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0x9c6c
xorl %ecx, %ecx
testq %r14, %r14
je 0x9c4a
movb (%r14,%rcx), %dl
testb %dl, %dl
je 0x9c4a
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x9c35
movq %rbx, %rdx
testq %rbx, %rbx
je 0x9c66
movb (%rdx), %sil
testb %sil, %sil
je 0x9c66
movb %sil, (%rax,%rcx)
incq %rcx
incq %rdx
jmp 0x9c4d
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/get_next_line_utils.c
// Function: ft_subbuff
char		*ft_subbuff(char *buff, int start, int len)
{
	int		i;
	char	*str;

	str = NULL;
	str = ft_strjoin(str, buff);
	i = 0;
	while (str[i] != '\0' && i < len)
	{
		buff[i] = str[start];
		i++;
		start++;
	}
	buff[i] = 0;
	free(str);
	return (buff);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9c06
movslq %r14d, %rcx
movslq %ebp, %rdx
addq %rax, %rcx
cmpq %rdx, %r15
jge 0x9cb0
cmpb $0x0, (%rax,%r15)
je 0x9cb0
movb (%rcx,%r15), %sil
movb %sil, (%rbx,%r15)
incq %r15
jmp 0x9c97
movb $0x0, (%rbx,%r15)
movq %rax, %rdi
callq 0x7190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/init.c
// Function: ft_init_dir
void	ft_init_dir(t_recup *recup)
{
	if (recup->depart == 'N')
		recup->ray.dirx = -1;
	if (recup->depart == 'S')
		recup->ray.dirx = 1;
	if (recup->depart == 'E')
		recup->ray.diry = 1;
	if (recup->depart == 'W')
		recup->ray.diry = -1;
	if (recup->depart == 'N')
		recup->ray.plany = 0.66;
	if (recup->depart == 'S')
		recup->ray.plany = -0.66;
	if (recup->depart == 'E')
		recup->ray.planx = 0.66;
	if (recup->depart == 'W')
		recup->ray.planx = -0.66;
}

// Assembly:
movzbl 0x50(%rdi), %edx
movsd 0x3419(%rip), %xmm0     # 0xd140
cmpl $0x45, %edx
je 0x9d6e
movsd 0x357c(%rip), %xmm1     # 0xd2b0
cmpl $0x57, %edx
je 0x9d5f
movl $0x300, %eax            # imm = 0x300
movl $0x2e8, %ecx            # imm = 0x2E8
cmpl $0x53, %edx
je 0x9d80
cmpl $0x4e, %edx
jne 0x9d8a
movsd 0x3563(%rip), %xmm1     # 0xd2b8
movsd 0x33a3(%rip), %xmm0     # 0xd100
jmp 0x9d80
movl $0x2f8, %eax            # imm = 0x2F8
movsd 0x3394(%rip), %xmm0     # 0xd100
jmp 0x9d7b
movsd 0x3542(%rip), %xmm1     # 0xd2b8
movl $0x2f8, %eax            # imm = 0x2F8
movl $0x2f0, %ecx            # imm = 0x2F0
movsd %xmm0, (%rdi,%rcx)
movsd %xmm1, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/init.c
// Function: ft_init_more3
void	ft_init_more3(t_recup *recup)
{
	if (recup->ray.raydiry == 0)
		recup->ray.deltadistx = 0;
	else if (recup->ray.raydirx == 0)
		recup->ray.deltadistx = 1;
	else
		recup->ray.deltadistx = sqrt(1 + (recup->ray.raydiry
			* recup->ray.raydiry) / (recup->ray.raydirx *
			recup->ray.raydirx));
	if (recup->ray.raydirx == 0)
		recup->ray.deltadisty = 0;
	else if (recup->ray.raydiry == 0)
		recup->ray.deltadisty = 1;
	else
		recup->ray.deltadisty = sqrt(1 + (recup->ray.raydirx *
			recup->ray.raydirx) / (recup->ray.raydiry *
			recup->ray.raydiry));
}

// Assembly:
movsd 0x310(%rdi), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x9db9
jp 0x9db9
andq $0x0, 0x338(%rdi)
movsd 0x308(%rdi), %xmm0
ucomisd %xmm2, %xmm0
jne 0x9e0f
jnp 0x9e17
jmp 0x9e0f
movsd 0x308(%rdi), %xmm1
ucomisd %xmm2, %xmm1
jne 0x9dd3
jp 0x9dd3
movsd 0x336f(%rip), %xmm2     # 0xd140
jmp 0x9df3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
divsd %xmm3, %xmm2
addsd 0x3351(%rip), %xmm2     # 0xd140
sqrtsd %xmm2, %xmm2
movsd %xmm2, 0x338(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x9e07
jnp 0x9e17
ucomisd %xmm2, %xmm0
jne 0x9e20
jp 0x9e20
movsd 0x3329(%rip), %xmm2     # 0xd140
movsd %xmm2, 0x340(%rdi)
retq
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm1
addsd 0x330c(%rip), %xmm1     # 0xd140
sqrtsd %xmm1, %xmm2
jmp 0x9e17
// File: /workspace/github_c_makefile_star2_O2/iciamyplant[P]Cub3d-Linux/src/init.c
// Function: ft_atoi3_check
void	ft_atoi3_check(const char *str, t_recup *recup)
{
	int i;
	int j;

	i = 0;
	j = 0;
	while (str[i] != ',')
		i++;
	if (str[i] == ',')
		j = 1;
	i++;
	while (str[i] == ' ')
		i++;
	while (str[i] >= '0' && str[i] <= '9')
		i++;
	while ((str[i] < '0' || str[i] > '9') && str[i])
	{
		if (str[i] == ',')
			j++;
		i++;
	}
	if (j != 2)
		recup->erreur = 2;
	if (ft_nb_virgule(str) != 2)
		recup->erreur = 2;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq -0x1(%rdi), %rax
cmpb $0x2c, 0x1(%rax)
leaq 0x1(%rax), %rax
jne 0x9e42
cmpb $0x20, 0x1(%rax)
leaq 0x1(%rax), %rax
je 0x9e4c
movb (%rax), %dl
leal -0x30(%rdx), %ecx
incq %rax
cmpb $0xa, %cl
jb 0x9e56
pushq $0x1
popq %rcx
leal -0x3a(%rdx), %esi
cmpb $-0xb, %sil
ja 0x9e86
cmpb $0x2c, %dl
je 0x9e7d
movzbl %dl, %edx
testl %edx, %edx
jne 0x9e7f
jmp 0x9e86
incl %ecx
movb (%rax), %dl
incq %rax
jmp 0x9e66
cmpl $0x2, %ecx
je 0x9e92
movl $0x2, 0x74(%rbx)
callq 0x9979
cmpl $0x2, %eax
je 0x9ea3
movl $0x2, 0x74(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/spacifici[P]st/src/st.c
// Function: treset
void
treset(void)
{
	uint i;

	term.c = (TCursor){{
		.mode = ATTR_NULL,
		.fg = defaultcs,
		.bg = defaultrcs
	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};

	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
	for (i = tabspaces; i < term.col; i += tabspaces)
		term.tabs[i] = 1;
	term.top = 0;
	term.bot = term.row - 1;
	term.mode = MODE_WRAP|MODE_UTF8;
	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
	term.charset = 0;

	for (i = 0; i < 2; i++) {
		tmoveto(0, 0);
		tcursor(CURSOR_SAVE);
		tclearregion(0, 0, term.col-1, term.row-1);
		tswapscreen();
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x165b7(%rip), %rax     # 0x1e584
movl (%rax), %eax
leaq 0x165b2(%rip), %rcx     # 0x1e588
movl (%rcx), %ecx
andl $0x0, 0x17431(%rip)     # 0x1f410
andw $0x0, 0x1742d(%rip)     # 0x1f414
movl %eax, 0x1742b(%rip)     # 0x1f418
movl %ecx, 0x17429(%rip)     # 0x1f41c
andq $0x0, 0x17425(%rip)     # 0x1f420
movb $0x0, 0x17426(%rip)     # 0x1f428
movq 0x17447(%rip), %rbx     # 0x1f450
movslq 0x173e4(%rip), %rdx     # 0x1f3f4
shlq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60a0
leaq 0x16553(%rip), %rax     # 0x1e578
movl (%rax), %ecx
movl 0x173c7(%rip), %edx     # 0x1f3f4
cmpl %edx, %ecx
jae 0x803e
movl %ecx, %esi
movl $0x1, (%rbx,%rsi,4)
addl (%rax), %ecx
jmp 0x802d
andl $0x0, 0x173ef(%rip)     # 0x1f434
movl 0x173a5(%rip), %eax     # 0x1f3f0
decl %eax
movl %eax, 0x173e5(%rip)     # 0x1f438
movl $0x41, 0x173df(%rip)    # 0x1f43c
movq $0x3030303, 0x173dc(%rip) # imm = 0x3030303
pushq $0x2
popq %rbx
leaq 0x1970e(%rip), %r14     # 0x21780
subl $0x1, %ebx
jb 0x80c9
xorl %edi, %edi
xorl %esi, %esi
callq 0x8182
movl 0x173b6(%rip), %eax     # 0x1f43c
shrl $0x2, %eax
andl $0x1, %eax
imulq $0x1c, %rax, %rax
movups 0x17385(%rip), %xmm0    # 0x1f41c
movups %xmm0, 0xc(%rax,%r14)
movups 0x1736c(%rip), %xmm0    # 0x1f410
movups %xmm0, (%rax,%r14)
movl 0x17345(%rip), %edx     # 0x1f3f4
decl %edx
movl 0x17339(%rip), %ecx     # 0x1f3f0
decl %ecx
xorl %edi, %edi
xorl %esi, %esi
callq 0x81ed
callq 0x8312
jmp 0x8072
addq $0x8, %rsp
popq %rbx
popq %r14
retq