LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_calculs
void	ft_calculs(t_recup *recup, int i)
{
	recup->s.spritex = recup->sxy[recup->s.order[i]].x - recup->ray.posx;
	recup->s.spritey = recup->sxy[recup->s.order[i]].y - recup->ray.posy;
	recup->s.invdet = 1.0 / (recup->ray.planx * recup->ray.diry -
			recup->ray.dirx * recup->ray.plany);
	recup->s.transformx = recup->s.invdet * (recup->ray.diry *
			recup->s.spritex - recup->ray.dirx * recup->s.spritey);
	recup->s.transformy = recup->s.invdet * (-recup->ray.plany *
			recup->s.spritex + recup->ray.planx * recup->s.spritey);
	recup->s.spritescreenx = (int)((recup->rx / 2) * (1 + recup->s.transformx
				/ recup->s.transformy));
	recup->s.spriteheight = abs((int)(recup->ry / (recup->s.transformy)));
	recup->s.drawstarty = -recup->s.spriteheight / 2 + recup->ry / 2;
	if (recup->s.drawstarty < 0)
		recup->s.drawstarty = 0;
	recup->s.drawendy = recup->s.spriteheight / 2 + recup->ry / 2;
	if (recup->s.drawendy >= recup->ry)
		recup->s.drawendy = recup->ry;
	recup->s.spritewidth = abs((int)(recup->ry / (recup->s.transformy)));
	recup->s.drawstartx = -recup->s.spritewidth / 2 + recup->s.spritescreenx;
	if (recup->s.drawstartx < 0)
		recup->s.drawstartx = 0;
	recup->s.drawendx = recup->s.spritewidth / 2 + recup->s.spritescreenx;
	if (recup->s.drawendx >= recup->rx)
		recup->s.drawendx = recup->rx;
}

// Assembly:
movq 0x418(%rdi), %rax
movq 0x3b8(%rdi), %rcx
movslq %esi, %rdx
movslq (%rcx,%rdx,4), %rcx
shlq $0x4, %rcx
movsd (%rax,%rcx), %xmm2
subsd 0x2d8(%rdi), %xmm2
movsd %xmm2, 0x3c8(%rdi)
movsd 0x8(%rax,%rcx), %xmm0
subsd 0x2e0(%rdi), %xmm0
movsd %xmm0, 0x3d0(%rdi)
movsd 0x2f8(%rdi), %xmm3
movsd 0x2f0(%rdi), %xmm1
movsd 0x2e8(%rdi), %xmm4
movsd 0x300(%rdi), %xmm5
movapd %xmm3, %xmm6
mulsd %xmm1, %xmm6
mulsd %xmm2, %xmm1
mulsd %xmm5, %xmm2
mulsd %xmm4, %xmm5
subsd %xmm5, %xmm6
movsd 0x3c4c(%rip), %xmm5     # 0xd0f0
movapd %xmm5, %xmm7
divsd %xmm6, %xmm7
movsd %xmm7, 0x3d8(%rdi)
mulsd %xmm0, %xmm4
subsd %xmm4, %xmm1
mulsd %xmm7, %xmm1
movsd %xmm1, 0x3e0(%rdi)
mulsd %xmm3, %xmm0
subsd %xmm2, %xmm0
mulsd %xmm7, %xmm0
movsd %xmm0, 0x3e8(%rdi)
movl (%rdi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
divsd %xmm0, %xmm1
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
cvttsd2si %xmm1, %ecx
movl %ecx, 0x3f0(%rdi)
movl 0x4(%rdi), %esi
xorps %xmm1, %xmm1
cvtsi2sd %esi, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %edx
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
movl %r8d, 0x3f4(%rdi)
movl %r8d, %edx
shrl %edx
movl %esi, %r9d
shrl $0x1f, %r9d
addl %esi, %r9d
sarl %r9d
leal (%rdx,%r9), %r10d
subl %edx, %r9d
xorl %r11d, %r11d
testl %r9d, %r9d
cmovlel %r11d, %r9d
movl %r9d, 0x3fc(%rdi)
cmpl %esi, %r10d
cmovll %r10d, %esi
movl %esi, 0x400(%rdi)
movl %r8d, 0x408(%rdi)
movl %ecx, %esi
subl %edx, %esi
testl %esi, %esi
cmovlel %r11d, %esi
movl %esi, 0x3f8(%rdi)
addl %ecx, %edx
cmpl %eax, %edx
cmovgel %eax, %edx
movl %edx, 0x404(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl %esi, 0x400(%rdi)
jle 0x9633
pushq %rbx
movl %edx, %r8d
movq 0x230(%rdi), %r9
movl %esi, %r10d
shll $0x8, %r10d
movl 0x4(%rdi), %edx
shll $0x7, %edx
movl 0x3f4(%rdi), %r11d
movl %r11d, %eax
shll $0x7, %eax
subl %edx, %eax
addl %r10d, %eax
imull 0x264(%rdi), %eax
cltd
idivl %r11d
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x8, %edx
imull 0x23c(%rdi), %edx
leal 0x3(%rdx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
sarl $0x2, %eax
addl %r8d, %eax
cltq
movl (%r9,%rax,4), %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x961d
movq 0x290(%rdi), %rdx
movl 0x29c(%rdi), %r11d
imull %esi, %r11d
leal 0x3(%r11), %ebx
testl %r11d, %r11d
cmovnsl %r11d, %ebx
sarl $0x2, %ebx
addl %ecx, %ebx
movslq %ebx, %r11
movl %eax, (%rdx,%r11,4)
incl %esi
addl $0x100, %r10d           # imm = 0x100
cmpl 0x400(%rdi), %esi
jl 0x95a1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
callq 0x93a9
cmpl $0x0, 0x3b0(%rbx)
jle 0x96f8
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9420
xorpd %xmm2, %xmm2
movl 0x3f8(%rbx), %r14d
cmpl 0x404(%rbx), %r14d
jge 0x96ea
movl 0x408(%rbx), %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
shrl %eax
subl 0x3f0(%rbx), %eax
addl %r14d, %eax
imull 0x260(%rbx), %eax
shll $0x8, %eax
cltd
idivl %ecx
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
testl %r14d, %r14d
js 0x96e2
movsd 0x3e8(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x96e2
cmpl (%rbx), %r14d
jge 0x96e2
movq 0x410(%rbx), %rax
movl %r14d, %ecx
movsd (%rax,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x96e2
sarl $0x8, %edx
movl 0x3fc(%rbx), %esi
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x9583
xorpd %xmm2, %xmm2
incl %r14d
jmp 0x9664
incl %ebp
cmpl 0x3b0(%rbx), %ebp
jl 0x964f
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x7c64
cmpl $0x1, %eax
jne 0x971d
leaq 0x3a60(%rip), %rsi      # 0xd175
movq %rbx, %rdi
callq 0x978c
cmpb $0x78, 0x50(%rbx)
jne 0x9732
leaq 0x3a62(%rip), %rsi      # 0xd18c
movq %rbx, %rdi
callq 0x978c
cmpl $0x6, 0x60(%rbx)
je 0x9747
leaq 0x3a5c(%rip), %rsi      # 0xd19b
movq %rbx, %rdi
callq 0x978c
cmpl $0x1, 0x78(%rbx)
jne 0x975c
leaq 0x3a61(%rip), %rsi      # 0xd1b5
movq %rbx, %rdi
callq 0x978c
cmpl $0x1, 0x7c(%rbx)
jne 0x9771
leaq 0x3a5e(%rip), %rsi      # 0xd1c7
movq %rbx, %rdi
callq 0x978c
cmpl $0x2, 0x90(%rbx)
jne 0x978a
leaq 0x3a5e(%rip), %rsi      # 0xd1df
movq %rbx, %rdi
popq %rbx
jmp 0x978c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x64(%rdi)
leaq 0x3a5c(%rip), %rsi      # 0xd200
movl $0x6, %edx
movl $0x1, %edi
callq 0x73d0
movq %r14, %rdi
callq 0x9df8
movslq %eax, %rdx
movl $0x1, %edi
movq %r14, %rsi
callq 0x73d0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x97d9
callq 0x7190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x97e7
callq 0x7190
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x97f5
callq 0x7190
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x9803
callq 0x7190
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x9811
callq 0x7190
cmpq $0x0, 0x48(%rbx)
je 0x983a
cmpl $0x0, 0x40(%rbx)
jle 0x983a
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7190
incq %r14
movslq 0x40(%rbx), %rax
cmpq %rax, %r14
jl 0x9821
movq %rbx, %rdi
callq 0x9842
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x9854
callq 0x7190
movq 0x3b8(%rbx), %rdi
testq %rdi, %rdi
je 0x9865
callq 0x7190
movq 0x3c0(%rbx), %rdi
testq %rdi, %rdi
je 0x9876
callq 0x7190
movq 0x418(%rbx), %rdi
testq %rdi, %rdi
je 0x9887
callq 0x7190
movq 0x410(%rbx), %rdi
testq %rdi, %rdi
je 0x9898
callq 0x7190
movq %rbx, %rdi
callq 0x98a0
// File: /workspace/github_c_makefile_star2_O1/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 0x98b9
leaq 0x37eb(%rip), %rsi      # 0xd09c
movq %rbx, %rdi
callq 0x978c
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x98d1
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
je 0x98e9
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0x108(%rbx), %rsi
testq %rsi, %rsi
je 0x9901
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0x9919
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0x1c8(%rbx), %rsi
testq %rsi, %rsi
je 0x9931
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0x228(%rbx), %rsi
testq %rsi, %rsi
je 0x9949
movq 0x278(%rbx), %rdi
callq 0xc930
movq 0x280(%rbx), %rsi
testq %rsi, %rsi
je 0x9961
movq 0x278(%rbx), %rdi
callq 0xc380
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
leaq 0x3887(%rip), %rsi      # 0xd207
movl $0x2, %edx
movl %ebx, %edi
callq 0x73d0
movl (%r15), %eax
imull 0x4(%r15), %eax
leaq 0x4(%r15), %r12
leal 0x36(,%rax,4), %eax
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
xorl %ebp, %ebp
movl %ebp, (%r14)
movl $0x2, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x2, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x36, (%r14)
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x28, (%r14)
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x73d0
movl $0x1, (%r14)
movl $0x2, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
addq $0x298, %r15            # imm = 0x298
movl $0x2, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x73d0
movl %ebp, (%r14)
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
movl $0x4, %edx
movl %ebx, %edi
movq %r14, %rsi
callq 0x73d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
leaq 0x373c(%rip), %rdi      # 0xd20a
movl $0x42, %esi
xorl %eax, %eax
callq 0x7410
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x9af0
leaq 0x372e(%rip), %rsi      # 0xd216
movq %rbx, %rdi
callq 0x978c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9968
testl %r14d, %r14d
js 0x9b4d
cmpl $0x0, (%rbx)
jle 0x9b41
xorl %r15d, %r15d
movl 0x29c(%rbx), %eax
imull %r14d, %eax
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
movslq %ecx, %rsi
addq %r15, %rsi
shlq $0x2, %rsi
addq 0x290(%rbx), %rsi
movl $0x4, %edx
movl %ebp, %edi
callq 0x73d0
incq %r15
cmpl (%rbx), %r15d
jl 0x9b07
leal -0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
jg 0x9aff
leaq 0x36dc(%rip), %rdi      # 0xd230
callq 0x7110
leaq 0x36e4(%rip), %rsi      # 0xd244
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x978c
// File: /workspace/github_c_makefile_star2_O1/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 0x9b76
cmpb $0x65, -0x2(%rax)
jne 0x9bb4
cmpb $0x76, -0x3(%rax)
jne 0x9bb4
cmpb $0x61, -0x4(%rax)
jne 0x9bb4
cmpb $0x73, -0x5(%rax)
jne 0x9bb4
cmpb $0x2d, -0x6(%rax)
jne 0x9bb4
cmpb $0x2d, -0x7(%rax)
jne 0x9bb4
callq 0x9df8
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x7, %ecx
jl 0x9bb6
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq (%rsi), %rsi
xorl %r13d, %r13d
movzbl (%rsi,%r13), %eax
testl %eax, %eax
je 0x9c1c
cmpl $0xa, %eax
je 0x9c22
incq %r13
jmp 0x9c09
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
js 0x9c7e
movl %r13d, %edx
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x9e11
movq %rax, %r15
movq (%r14), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x9e8d
movq %rax, (%r14)
movq %r15, %rdi
callq 0x7190
movq %r12, %rdi
callq 0x7190
movq (%rbx), %r14
leal 0x1(%r13), %r15d
movq %r14, %rdi
callq 0x9df8
subl %r13d, %eax
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x9f48
movq %rax, (%rbx)
jmp 0x9c9e
movq (%r14), %rbx
movq %rbx, %rdi
callq 0x9e8d
movq %rax, (%r14)
movl $0x1, %ebp
testq %rbx, %rbx
je 0x9c9e
movq %rbx, %rdi
callq 0x7190
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_O1/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 0x9ce7
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x7190
movq $0x0, (%r14)
xorl %ebp, %ebp
cmpq $0x0, (%rbx)
jne 0x9cec
movl $0x1, %edi
callq 0x7100
movq %rax, (%rbx)
movb $0x0, (%rax)
jmp 0x9cec
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x2, 0x74(%rdx)
jne 0x9d3b
movq 0xb58f(%rip), %rdi      # 0x152b8
testq %rdi, %rdi
je 0x9d3b
callq 0x7190
xorl %r14d, %r14d
jmp 0x9ddb
testl %ebp, %ebp
sets %al
testq %rbx, %rbx
sete %cl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x9ddb
movq $0x0, (%rbx)
cmpq $0x0, 0xb555(%rip)      # 0x152b8
je 0x9d78
leaq 0xb54c(%rip), %rsi      # 0x152b8
movq %rbx, %rdi
callq 0x9bf2
testl %eax, %eax
je 0x9dd5
cmpq $0x0, 0xb538(%rip)      # 0x152b8
jne 0x9d98
movl $0x1001, %edi           # imm = 0x1001
callq 0x7100
movq %rax, 0xb525(%rip)      # 0x152b8
testq %rax, %rax
je 0x9ddb
leaq 0xb519(%rip), %r14      # 0x152b8
movq 0xb512(%rip), %rsi      # 0x152b8
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x70e0
testl %eax, %eax
jle 0x9de3
movq 0xb4fb(%rip), %rcx      # 0x152b8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9bf2
testl %eax, %eax
jne 0x9d9f
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb4ce(%rip), %rsi      # 0x152b8
movl %eax, %edi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x9caf
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x1(%rdx), %rdi
callq 0x7100
testq %r15, %r15
je 0x9e42
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r15, %rdx
incl %ecx
cmpb $0x0, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x9e35
jmp 0x9e44
xorl %ecx, %ecx
cmpl %r14d, %ecx
jbe 0x9e81
movl %r14d, %ecx
movb (%r15,%rcx), %dl
testb %dl, %dl
sete %cl
testq %rbx, %rbx
sete %sil
orb %cl, %sil
jne 0x9e81
incl %r14d
xorl %ecx, %ecx
movq %rcx, %rsi
movb %dl, (%rax,%rcx)
incq %rcx
addl %r14d, %esi
movb (%r15,%rsi), %dl
testb %dl, %dl
je 0x9e83
cmpq %rbx, %rcx
jb 0x9e66
jmp 0x9e83
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x9eb4
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%r14,%rcx)
movq %rax, %rcx
jne 0x9ea3
jmp 0x9eb6
xorl %eax, %eax
testq %rbx, %rbx
je 0x9ed2
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rbx,%rdx)
movq %rcx, %rdx
jne 0x9ec2
jmp 0x9ed4
xorl %ecx, %ecx
addl %ecx, %eax
incl %eax
movslq %eax, %rdi
callq 0x7100
xorl %ecx, %ecx
testq %rax, %rax
je 0x9f09
testq %r14, %r14
je 0x9f10
xorl %edx, %edx
movb (%r14,%rdx), %sil
testb %sil, %sil
je 0x9f0d
leaq 0x1(%rdx), %rcx
movb %sil, (%rax,%rdx)
movq %rcx, %rdx
testq %r14, %r14
jne 0x9eee
jmp 0x9f10
xorl %eax, %eax
jmp 0x9f40
movq %rdx, %rcx
testq %rbx, %rbx
je 0x9f3a
movl %ecx, %edx
movq %rbx, %rsi
movb (%rsi), %dil
testb %dil, %dil
je 0x9f37
leaq 0x1(%rdx), %rcx
incq %rsi
movb %dil, (%rax,%rdx)
movq %rcx, %rdx
testq %rbx, %rbx
jne 0x9f1a
jmp 0x9f3a
movq %rdx, %rcx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14d
movl %esi, %ebp
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9e8d
testl %r14d, %r14d
jle 0x9f97
cmpb $0x0, (%rax)
je 0x9f97
movl %r14d, %ecx
movslq %ebp, %rsi
movq %rax, %rdx
addq %rsi, %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movb %dil, (%rbx,%rsi)
leaq 0x1(%rsi), %r15
cmpq %rcx, %r15
jae 0x9f97
cmpb $0x0, 0x1(%rax,%rsi)
movq %r15, %rsi
jne 0x9f7c
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_O1/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:
movb 0x50(%rdi), %al
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
cmpb $0x4e, %al
jne 0xa016
movq %rcx, 0x2e8(%rdi)
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
cmpb $0x53, %al
jne 0xa02b
movq %rdx, 0x2e8(%rdi)
cmpb $0x45, %al
jne 0xa036
movq %rdx, 0x2f0(%rdi)
cmpb $0x57, %al
jne 0xa041
movq %rcx, 0x2f0(%rdi)
movabsq $0x3fe51eb851eb851f, %rcx # imm = 0x3FE51EB851EB851F
cmpb $0x4e, %al
jne 0xa056
movq %rcx, 0x300(%rdi)
movabsq $-0x401ae147ae147ae1, %rdx # imm = 0xBFE51EB851EB851F
cmpb $0x53, %al
jne 0xa06b
movq %rdx, 0x300(%rdi)
cmpb $0x45, %al
jne 0xa076
movq %rcx, 0x2f8(%rdi)
cmpb $0x57, %al
jne 0xa081
movq %rdx, 0x2f8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movsd 0x310(%rdi), %xmm0
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
xorpd %xmm1, %xmm1
jne 0xa09e
jnp 0xa0e8
movsd 0x308(%rbx), %xmm2
ucomisd %xmm1, %xmm2
jne 0xa0b8
jp 0xa0b8
movsd 0x303a(%rip), %xmm1     # 0xd0f0
jmp 0xa0e8
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm0
addsd 0x3024(%rip), %xmm0     # 0xd0f0
ucomisd %xmm1, %xmm0
jb 0xa0db
xorps %xmm1, %xmm1
sqrtsd %xmm0, %xmm1
jmp 0xa0e8
callq 0x73f0
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm1
movsd %xmm1, 0x338(%rbx)
movsd 0x308(%rbx), %xmm0
ucomisd %xmm3, %xmm0
jne 0xa100
jnp 0xa14a
movsd 0x310(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0xa11e
jp 0xa11e
movsd 0x2fd4(%rip), %xmm3     # 0xd0f0
jmp 0xa14a
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
divsd %xmm2, %xmm0
addsd 0x2fbe(%rip), %xmm0     # 0xd0f0
ucomisd %xmm1, %xmm0
jb 0xa141
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0xa14a
callq 0x73f0
movapd %xmm0, %xmm3
movsd %xmm3, 0x340(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq $-0x1, %rcx
cmpb $0x2c, 0x1(%rdi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0xa15f
leaq (%rdi,%rcx), %rax
decq %rcx
incq %rcx
cmpb $0x20, 0x1(%rax)
leaq 0x1(%rax), %rax
je 0xa171
movb (%rax), %dl
addb $-0x30, %dl
incq %rax
incq %rcx
cmpb $0xa, %dl
jb 0xa17e
movl %ecx, %ecx
movb (%rdi,%rcx), %dl
leal -0x3a(%rdx), %ecx
cmpb $-0xb, %cl
ja 0xa1c3
movl $0x1, %ecx
cmpb $0x2c, %dl
je 0xa1ae
movzbl %dl, %edx
testl %edx, %edx
jne 0xa1b0
jmp 0xa1be
incl %ecx
movb (%rax), %dl
leal -0x3a(%rdx), %esi
incq %rax
cmpb $-0xa, %sil
jb 0xa1a0
cmpl $0x2, %ecx
je 0xa1ca
movl $0x2, 0x74(%rbx)
callq 0x9bb8
cmpl $0x2, %eax
je 0xa1db
movl $0x2, 0x74(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x160a7(%rip), %rax     # 0x1e594
movl (%rax), %eax
leaq 0x160a2(%rip), %rcx     # 0x1e598
movl (%rcx), %ecx
movl $0x0, 0x16f1e(%rip)     # 0x1f420
movw $0x0, 0x16f19(%rip)     # 0x1f424
movl %eax, 0x16f17(%rip)     # 0x1f428
movl %ecx, 0x16f15(%rip)     # 0x1f42c
movq $0x0, 0x16f0e(%rip) # 0x1f430
movb $0x0, 0x16f0f(%rip)     # 0x1f438
movq 0x16f30(%rip), %rdi     # 0x1f460
movslq 0x16ecd(%rip), %rbx     # 0x1f404
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60a0
leaq 0x1603c(%rip), %rax     # 0x1e588
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x856e
movq 0x16f07(%rip), %rdx     # 0x1f460
movl 0x16ea5(%rip), %esi     # 0x1f404
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x855f
movl $0x0, 0x16ecc(%rip)     # 0x1f444
movl 0x16e82(%rip), %eax     # 0x1f400
decl %eax
movl %eax, 0x16ec2(%rip)     # 0x1f448
movl $0x41, 0x16ebc(%rip)    # 0x1f44c
movq $0x3030303, 0x16eb9(%rip) # imm = 0x3030303
movl $0x1, %ebx
leaq 0x191e9(%rip), %r14     # 0x21790
movb 0x16e8b(%rip), %dl      # 0x1f438
movl 0x16e4d(%rip), %ecx     # 0x1f400
movl %edx, %eax
andb $-0x2, %al
movb %al, 0x16e7b(%rip)      # 0x1f438
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x85d7
movl 0x16e77(%rip), %esi     # 0x1f448
movl 0x16e6d(%rip), %eax     # 0x1f444
movl 0x16e27(%rip), %edx     # 0x1f404
decl %edx
movl %esi, %edi
sarl $0x1f, %edi
andl %esi, %edi
movl %edx, %esi
sarl $0x1f, %esi
andl %edx, %esi
testl %eax, %eax
cmovgl %eax, %edi
movl %esi, 0x16e38(%rip)     # 0x1f430
movl %edi, 0x16e36(%rip)     # 0x1f434
movl 0x16e48(%rip), %eax     # 0x1f44c
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0x16e04(%rip), %xmm0    # 0x1f420
movups %xmm0, (%r14,%rsi)
movups 0x16e04(%rip), %xmm0    # 0x1f42c
movups %xmm0, 0xc(%r14,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x872d
callq 0x889b
decl %ebx
je 0x85a7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/st.c
// Function: tdumpline
void
tdumpline(int n)
{
	char buf[UTF_SIZ];
	Glyph *bp, *end;

	bp = &term.line[n][0];
	end = &bp[MIN(tlinelen(n), term.col) - 1];
	if (bp != end || bp->u != ' ') {
		for ( ; bp <= end; ++bp)
			tprinter(buf, utf8encode(bp->u, buf));
	}
	tprinter("\n", 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x16600(%rip), %rax     # 0x1f408
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x7642
movl 0x165ea(%rip), %ecx     # 0x1f404
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r15
addq $-0x10, %r15
cmpq %r15, %r14
je 0x8e37
jbe 0x8e3d
jmp 0x8e61
cmpl $0x20, (%r14)
je 0x8e61
leaq 0xc(%rsp), %rbx
movl (%r14), %edi
movq %rbx, %rsi
callq 0x7094
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8d9c
addq $0x10, %r14
cmpq %r15, %r14
jbe 0x8e42
leaq 0x67be(%rip), %rdi      # 0xf626
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8d9c
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/x.c
// Function: setsel
void
setsel(char *str, Time t)
{
	if (!str)
		return;

	free(xsel.primary);
	xsel.primary = str;

	XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
	if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)
		selclear();
	clipcopy(NULL);
}

// Assembly:
testq %rdi, %rdi
je 0xaeb6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x16c04(%rip), %rdi     # 0x21a68
callq 0x6360
movq %r14, 0x16bf8(%rip)     # 0x21a68
movq 0x16a71(%rip), %rdi     # 0x218e8
movq 0x16a7a(%rip), %rdx     # 0x218f8
movl $0x1, %esi
movq %rbx, %rcx
callq 0x6680
movq 0x16a56(%rip), %rdi     # 0x218e8
movl $0x1, %esi
callq 0x69c0
cmpq 0x16a55(%rip), %rax     # 0x218f8
je 0xaeaa
callq 0x71d0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xadea
retq
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/x.c
// Function: xsetcursor
int
xsetcursor(int cursor)
{
	if (!BETWEEN(cursor, 0, 8)) /* 7-8: st extensions */
		return 1;
	win.cursor = cursor;
	cursorblinks = win.cursor == 0 || win.cursor == 1 ||
	               win.cursor == 3 || win.cursor == 5 ||
	               win.cursor == 7;
	return 0;
}

// Assembly:
movl $0x1, %eax
cmpl $0x8, %edi
ja 0xc2b7
movl %edi, 0x15774(%rip)     # 0x21a0c
cmpl $0x6, %edi
jae 0xc2a7
movl $0x2b, %ecx
btl %edi, %ecx
jb 0xc2af
xorl %eax, %eax
cmpl $0x7, %edi
sete %al
movl %eax, 0x15763(%rip)     # 0x21a18
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/hb.c
// Function: hbunloadfonts
void
hbunloadfonts()
{
	for (int i = 0; i < hbfontslen; i++) {
		hb_font_destroy(hbfontcache[i].font);
		XftUnlockFace(hbfontcache[i].match);
	}

	if (hbfontcache != NULL) {
		free(hbfontcache);
		hbfontcache = NULL;
	}
	hbfontslen = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x13255(%rip)     # 0x21ad0
jle 0xe8b6
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x1324f(%rip), %rax     # 0x21ad8
movq 0x8(%rax,%rbx), %rdi
callq 0x6880
movq 0x1323e(%rip), %rax     # 0x21ad8
movq (%rax,%rbx), %rdi
callq 0x6950
incq %r14
movslq 0x13223(%rip), %rax     # 0x21ad0
addq $0x10, %rbx
cmpq %rax, %r14
jl 0xe882
movq 0x1321b(%rip), %rdi     # 0x21ad8
testq %rdi, %rdi
je 0xe8d2
callq 0x6360
movq $0x0, 0x13206(%rip) # 0x21ad8
movl $0x0, 0x131f4(%rip)     # 0x21ad0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/hb.c
// Function: hbfindfont
hb_font_t *
hbfindfont(XftFont *match)
{
	for (int i = 0; i < hbfontslen; i++) {
		if (hbfontcache[i].match == match)
			return hbfontcache[i].font;
	}

	/* Font not found in cache, caching it now. */
	hbfontcache = realloc(hbfontcache, sizeof(HbFontMatch) * (hbfontslen + 1));
	FT_Face face = XftLockFace(match);
	hb_font_t *font = hb_ft_font_create(face, NULL);
	if (font == NULL)
		die("Failed to load Harfbuzz font.");

	hbfontcache[hbfontslen].match = match;
	hbfontcache[hbfontslen].font = font;
	hbfontslen += 1;

	return font;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x131de(%rip), %rsi     # 0x21ad0
testq %rsi, %rsi
setg %al
jle 0xe93a
movq 0x131d7(%rip), %rcx     # 0x21ad8
cmpq %rbx, (%rcx)
je 0xe92b
movl $0x1, %eax
cmpq %rax, %rsi
je 0xe934
leaq 0x10(%rcx), %rdx
incq %rax
cmpq %rbx, 0x10(%rcx)
movq %rdx, %rcx
jne 0xe90b
decq %rax
cmpq %rsi, %rax
setb %al
jmp 0xe92e
movq %rcx, %rdx
movq 0x8(%rdx), %r14
jmp 0xe93a
cmpq %rsi, %rax
setb %al
testb %al, %al
jne 0xe9a5
movq 0x13193(%rip), %rdi     # 0x21ad8
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x6900
movq %rax, 0x1317f(%rip)     # 0x21ad8
movq %rbx, %rdi
callq 0x63a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x66f0
movq %rax, %r14
testq %rax, %rax
jne 0xe981
leaq 0x1b7e(%rip), %rdi      # 0x104f8
xorl %eax, %eax
callq 0x6fa6
movq 0x13150(%rip), %rax     # 0x21ad8
movslq 0x13141(%rip), %rcx     # 0x21ad0
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movq %rbx, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
movl %edx, 0x1312b(%rip)     # 0x21ad0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/spacifici[P]st/src/hb.c
// Function: hbtransformsegment
void
hbtransformsegment(XftFont *xfont, const Glyph *string, hb_codepoint_t *codepoints, int start, int length)
{
	hb_font_t *font = hbfindfont(xfont);
	if (font == NULL)
		return;

	Rune rune;
	ushort mode = USHRT_MAX;
	hb_buffer_t *buffer = hb_buffer_create();
	hb_buffer_set_direction(buffer, HB_DIRECTION_LTR);

	/* Fill buffer with codepoints. */
	for (int i = start; i < (start+length); i++) {
		rune = string[i].u;
		mode = string[i].mode;
		if (mode & ATTR_WDUMMY)
			rune = 0x0020;
		hb_buffer_add_codepoints(buffer, &rune, 1, 0, 1);
	}

	/* Shape the segment. */
	hb_shape(font, buffer, NULL, 0);

	/* Get new glyph info. */
	hb_glyph_info_t *info = hb_buffer_get_glyph_infos(buffer, NULL);

	/* Write new codepoints. */
	for (int i = 0; i < length; i++) {
		hb_codepoint_t gid = info[i].codepoint;
		codepoints[start+i] = gid;
	}

	/* Cleanup. */
	hb_buffer_destroy(buffer);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r13
callq 0xe8e4
testq %rax, %rax
je 0xec99
movq %rax, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
callq 0x6790
movq %rax, %rbx
movq %rax, %rdi
movl $0x4, %esi
callq 0x66c0
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
testl %r14d, %r14d
jle 0xec4a
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
addl %r12d, %eax
movslq %eax, %r14
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %rbp
addq $0x4, %rbp
movl $0x20, %r15d
leaq 0x4(%rsp), %r13
movl -0x4(%rbp), %eax
movl %eax, 0x4(%rsp)
btl $0xa, (%rbp)
cmovbl %r15d, %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x6280
incq %r12
addq $0x10, %rbp
cmpq %r14, %r12
jl 0xec12
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6420
movq 0x10(%rsp), %rcx
testl %ecx, %ecx
jle 0xec91
movl %ecx, %ecx
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rsi
leaq (%rdx,%rsi,4), %rdx
xorl %esi, %esi
movl (%rax), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
addq $0x14, %rax
cmpq %rsi, %rcx
jne 0xec80
movq %rbx, %rdi
callq 0x6530
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/pwrite2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);

	assert(fd >= 0);

	while (1) {
		assert(pwrite(fd, buf, BUFLEN, 0) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x245e(%rip), %rdi      # 0x5180
movl $0x2, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2d8b
movl %eax, %ebp
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %eax, %edi
xorl %ecx, %ecx
callq 0x2200
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2d6c
movq %rsp, %r14
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2200
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2d50
leaq 0x5a0(%rip), %rdi       # 0x3313
leaq 0x506(%rip), %rsi       # 0x3280
leaq 0x55f(%rip), %rcx       # 0x32e0
movl $0x21, %edx
callq 0x2130
leaq 0x4e6(%rip), %rdi       # 0x3278
leaq 0x4e7(%rip), %rsi       # 0x3280
leaq 0x540(%rip), %rcx       # 0x32e0
movl $0x1e, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct sock_addr ** sas;
	int s;
	struct wire_requestqueue * Q;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_kvlds %s\n", "<socketname>");
		exit(1);
	}

	/* Resolve the socket address and connect. */
	if ((sas = sock_resolve(argv[1])) == NULL) {
		warnp("Error resolving socket address: %s", argv[1]);
		exit(1);
	}
	if (sas[0] == NULL) {
		warn0("No addresses found for %s", argv[1]);
		exit(1);
	}
	if ((s = sock_connect(sas)) == -1)
		exit(1);

	/* Create a request queue. */
	if ((Q = wire_requestqueue_init(s)) == NULL) {
		warnp("Cannot create packet write queue");
		exit(1);
	}

	/* Test creating 10000000 key-value pairs. */
	if (createmany(Q, 10000000))
		exit(1);

	/* Free the request queue. */
	wire_requestqueue_destroy(Q);
	wire_requestqueue_free(Q);

	/* Free socket addresses. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x2547
callq 0x4e20
cmpl $0x2, %ebx
jne 0x257b
movq 0x8(%r14), %rdi
callq 0x3df8
testq %rax, %rax
jne 0x259f
callq 0x2090
cmpl $0x0, (%rax)
movq 0x8(%r14), %rsi
jne 0x25ca
leaq 0x7ab8(%rip), %rdi      # 0xa027
xorl %eax, %eax
callq 0x4fbf
jmp 0x2691
movq 0xda76(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x7a78(%rip), %rsi      # 0xa004
leaq 0x7a87(%rip), %rdx      # 0xa01a
xorl %eax, %eax
callq 0x21b0
jmp 0x2691
movq %rax, %rbx
cmpq $0x0, (%rax)
jne 0x25e6
movq 0x8(%r14), %rsi
leaq 0x7a97(%rip), %rdi      # 0xa04a
xorl %eax, %eax
callq 0x4fbf
callq 0x2090
movl $0x0, (%rax)
jmp 0x2691
movq %rax, %rbx
leaq 0x7a53(%rip), %rdi      # 0xa027
xorl %eax, %eax
callq 0x4ea0
movl $0x0, (%rbx)
jmp 0x2691
movq %rbx, %rdi
callq 0x4715
cmpl $-0x1, %eax
je 0x2691
movl %eax, %edi
callq 0x66f0
testq %rax, %rax
jne 0x2621
callq 0x2090
cmpl $0x0, (%rax)
jne 0x269b
leaq 0x7a4c(%rip), %rdi      # 0xa064
xorl %eax, %eax
callq 0x4fbf
jmp 0x2691
movq %rax, %r14
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq $0x989680, 0x18(%rsp)   # imm = 0x989680
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
callq 0x50e4
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2691
leaq 0x8(%rsp), %rdi
callq 0x26e6
testl %eax, %eax
jne 0x2691
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x2a4d
orl -0x4(%r15), %eax
je 0x26b1
callq 0x2090
cmpl $0x0, (%rax)
jne 0x26da
leaq 0x79f6(%rip), %rdi      # 0xa085
jmp 0x2618
movl $0x1, %edi
callq 0x2290
movq %rax, %rbx
leaq 0x79bf(%rip), %rdi      # 0xa064
xorl %eax, %eax
callq 0x4ea0
jmp 0x25db
movq 0x30(%rsp), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x6db5
movq %r14, %rdi
callq 0x6dc9
movq %rbx, %rdi
callq 0x450f
xorl %edi, %edi
callq 0x2290
movq %rax, %rbx
leaq 0x79a1(%rip), %rdi      # 0xa085
jmp 0x26a5
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/perftests/kvldsperf/main.c
// Function: sendbatch
static int
sendbatch(struct createmany_state * C)
{

	while ((C->Nsent < C->Nmax) && (C->Nip < 4096)) {
		/* Construct the key/value. */
		be64enc(C->key->buf, C->Nsent);

		/* Send the request. */
		if (proto_kvlds_request_set(C->Q, C->key, C->key,
		    callback_done, C))
			goto err0;
		C->Nsent += 1;
		C->Nip += 1;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
xorl %ebx, %ebx
cmpq 0x10(%rdi), %rax
jae 0x274b
movq %rdi, %r14
leaq 0x52(%rip), %r15        # 0x2753
cmpq $0xfff, 0x18(%r14)      # imm = 0xFFF
ja 0x274b
bswapq %rax
movq 0x28(%r14), %rcx
movq %rax, 0x1(%rcx)
movq (%r14), %rdi
movq 0x28(%r14), %rdx
movq %rdx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x5315
testl %eax, %eax
jne 0x2746
movq 0x8(%r14), %rax
incq %rax
movq %rax, 0x8(%r14)
incq 0x18(%r14)
cmpq 0x10(%r14), %rax
jb 0x2701
jmp 0x274b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ranbenbasat[P]RHHH/randhhh1D.c
// Function: init
void init(double SSepsilon, double prob) {
	int i;
	SSepsval = SSepsilon;
	srand(SEED);
#ifdef PROB
	ignoreProb = 1 - prob;
	logIgnoreProb = log(ignoreProb);
	minusQuantity = log(RAND_MAX) / logIgnoreProb;
	nrIgnore = log((float)rand()) / logIgnoreProb - minusQuantity;
#endif
	for (i = 0; i < NUM_COUNTERS; i++)
		counters[i] = LCU_Init(max(SSepsilon, twototheminus(leveleps[i])));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, (%rsp)
movsd %xmm0, 0x4e0e(%rip)     # 0x6170
movl $0xd5d, %edi            # imm = 0xD5D
callq 0x1110
xorl %ebx, %ebx
leaq 0x4dcb(%rip), %r14      # 0x6140
movsd 0x2c93(%rip), %xmm1     # 0x4010
leaq 0x4dfc(%rip), %r15      # 0x6180
movl (%r14,%rbx,4), %eax
movsd 0x2c78(%rip), %xmm0     # 0x4008
testl %eax, %eax
jle 0x13a9
incl %eax
movsd 0x2c6a(%rip), %xmm0     # 0x4008
mulsd %xmm1, %xmm0
decl %eax
cmpl $0x1, %eax
jg 0x139e
movapd %xmm0, %xmm1
movapd (%rsp), %xmm3
cmplesd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
callq 0x1cc8
movsd 0x2c35(%rip), %xmm1     # 0x4010
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq $0x5, %rbx
jne 0x1384
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ranbenbasat[P]RHHH/randhhh1D.c
// Function: cmpHH
int cmpHH(const void * lhs, const void * rhs) {
	if (((const HeavyHitter*) lhs)->item > ((const HeavyHitter*) rhs)->item) return 1;
	if (((const HeavyHitter*) lhs)->item < ((const HeavyHitter*) rhs)->item) return -1;
	if (((const HeavyHitter*) lhs)->mask > ((const HeavyHitter*) rhs)->mask) return 1;
	if (((const HeavyHitter*) lhs)->mask < ((const HeavyHitter*) rhs)->mask) return -1;
	if (((const HeavyHitter*) lhs)->upper != ((const HeavyHitter*) rhs)->upper) return ((const HeavyHitter*) lhs)->upper - ((const HeavyHitter*) rhs)->upper;
	return ((const HeavyHitter*) lhs)->lower - ((const HeavyHitter*) rhs)->lower;
}

// Assembly:
movl (%rsi), %ecx
movl $0x1, %eax
cmpl %ecx, (%rdi)
jbe 0x146a
retq
jae 0x1472
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl 0x4(%rsi), %ecx
cmpl %ecx, 0x4(%rdi)
jg 0x1469
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jl 0x1469
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
jne 0x1469
movl 0xc(%rdi), %eax
subl 0xc(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_InsertIntoHashtable
void LCU_InsertIntoHashtable(LCU_type *lcu, LCUITEM *newi, int i, LCLitem_t newitem){
	newi->nexti=lcu->hashtable[i];
	newi->item=newitem; // overwrite the old item
	newi->hash=i;
	newi->previousi=NULL;
	// insert item into the hashtable
	if (lcu->hashtable[i])
		lcu->hashtable[i]->previousi=newi;
	lcu->hashtable[i]=newi;
}

// Assembly:
movq 0x40(%rdi), %rax
movslq %edx, %rdx
movq (%rax,%rdx,8), %rdi
movq %rdi, 0x20(%rsi)
movl %ecx, (%rsi)
movl %edx, 0x4(%rsi)
movq $0x0, 0x18(%rsi)
movq (%rax,%rdx,8), %rcx
testq %rcx, %rcx
je 0x1ed2
movq %rsi, 0x18(%rcx)
movq %rsi, (%rax,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O1/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_GetNewCounter
LCUITEM * LCU_GetNewCounter(LCU_type * lcu) {
	LCUITEM * newi;
	int j;

	newi=lcu->root->items;  // take a counter from the first group
	// but currently it remains in the same group

	newi->nexting->previousing=newi->previousing;
	newi->previousing->nexting=newi->nexting;
	// unhook the new item from the linked list in the hash table	    

	// need to remove this item from the hashtable
	j = newi->hash;
	if (lcu->hashtable[j]==newi)
		lcu->hashtable[j]=newi->nexti;

	if (newi->nexti!=NULL)
		newi->nexti->previousi=newi->previousi;
	if (newi->previousi!=NULL)
		newi->previousi->nexti=newi->nexti;

	return (newi);
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rdx
movq %rdx, 0x30(%rcx)
movq 0x30(%rax), %rdx
movq %rcx, 0x28(%rdx)
movslq 0x4(%rax), %rcx
movq 0x40(%rdi), %rdx
cmpq %rax, (%rdx,%rcx,8)
jne 0x1f23
movq 0x20(%rax), %rsi
movq %rsi, (%rdx,%rcx,8)
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x1f34
movq 0x18(%rax), %rdx
movq %rdx, 0x18(%rcx)
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x1f41
movq %rcx, 0x20(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PutInNewGroup
void LCU_PutInNewGroup(LCU_type * lcu, LCUITEM *newi, LCUGROUP * tmpg){ 
	LCUGROUP * oldgroup;

	oldgroup=newi->parentg;  
	// put item in the tmpg group
	newi->parentg=tmpg;

	if (newi->nexting!=newi) // if the group does not have size 1
	{ // remove the item from its current group
		newi->nexting->previousing=newi->previousing;
		newi->previousing->nexting=newi->nexting;
		oldgroup->items=oldgroup->items->nexting;
	}
	else { // group will be empty
		if (oldgroup->nextg!=NULL) // there is another group
			oldgroup->nextg->previousg=oldgroup->previousg;
		if (lcu->root==oldgroup) // this is the first group
			lcu->root=oldgroup->nextg;
		else
			oldgroup->previousg->nextg=oldgroup->nextg;
		lcu->freegroups[--lcu->gpt]=oldgroup;
		// if we have created an empty group, remove it 
	}	
	newi->nexting=tmpg->items;
	newi->previousing=tmpg->items->previousing;
	newi->previousing->nexting=newi;
	newi->nexting->previousing=newi;
}

// Assembly:
movq 0x10(%rsi), %rax
movq 0x28(%rsi), %rcx
movq %rdx, 0x10(%rsi)
cmpq %rsi, %rcx
je 0x1f71
movq 0x30(%rsi), %rdi
movq %rdi, 0x30(%rcx)
movq 0x30(%rsi), %rdi
movq %rcx, 0x28(%rdi)
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1fae
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x1f82
movq 0x10(%rax), %r8
movq %r8, 0x10(%rcx)
cmpq %rax, 0x20(%rdi)
je 0x1f92
movq 0x10(%rax), %r8
addq $0x18, %r8
jmp 0x1f96
leaq 0x20(%rdi), %r8
movq %rcx, (%r8)
movq 0x38(%rdi), %rcx
movslq 0x4(%rdi), %r8
leaq -0x1(%r8), %r9
movl %r9d, 0x4(%rdi)
movq %rax, -0x8(%rcx,%r8,8)
movq 0x8(%rdx), %rax
movq %rax, 0x28(%rsi)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rsi)
movq %rsi, 0x28(%rax)
movq 0x28(%rsi), %rax
movq %rsi, 0x30(%rax)
retq