LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/raycasting.c
// Function: ft_raycasting
int		ft_raycasting(t_recup *recup)
{
	recup->ray.x = 0;
	while (recup->ray.x < recup->rx)
	{
		ft_initialisation3(recup);
		ft_stepsidedist(recup);
		ft_color_column(recup);
		recup->s.zbuffer[recup->ray.x] = recup->ray.perpwalldist;
		recup->ray.x++;
	}
	ft_sprite(recup);
	if (recup->save == 1)
		ft_save(recup);
	mlx_put_image_to_window(recup->data.mlx_ptr, recup->data.mlx_win,
			recup->data.img, 0, 0);
	ft_forward_back(recup);
	ft_left_right(recup);
	ft_rotate_right_left(recup);
	ft_swap(recup);
	return (0);
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x82f4
xorl %eax, %eax
callq 0xa270
movq %rax, 0x278(%rbx)
testq %rax, %rax
jne 0x9149
leaq 0x4069(%rip), %rsi      # 0xd1a3
movq %rbx, %rdi
callq 0x970c
movq 0x278(%rbx), %rax
leaq 0x6c(%rbx), %rsi
leaq 0x70(%rbx), %rdx
movq %rax, %rdi
callq 0xc900
movq (%rbx), %xmm0
movq 0x6c(%rbx), %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm2, %xmm0
pandn %xmm1, %xmm2
por %xmm0, %xmm2
movq %xmm2, (%rbx)
movq %rbx, %rdi
callq 0x8f3a
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0xad00
movq %rax, 0x288(%rbx)
leaq 0x298(%rbx), %r14
leaq 0x29c(%rbx), %r15
leaq 0x2a0(%rbx), %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xaf80
movq %rax, 0x290(%rbx)
cmpl $0x1, 0x68(%rbx)
jne 0x91d5
movq %rbx, %rdi
callq 0x9064
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
leaq 0x3fd0(%rip), %rcx      # 0xd1b8
callq 0xa570
movq %rax, 0x280(%rbx)
movq 0x278(%rbx), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
callq 0xad00
movq %rax, 0x2c8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xaf80
movq %rax, 0x2d0(%rbx)
movq 0x280(%rbx), %rdi
leaq 0x5ee(%rip), %rcx       # 0x9820
movl $0x21, %esi
movl $0x20000, %edx          # imm = 0x20000
movq %rbx, %r8
callq 0xc820
movq 0x280(%rbx), %rdi
leaq -0x12c2(%rip), %rcx     # 0x7f90
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0xc820
movq 0x278(%rbx), %rdi
leaq -0x20e(%rip), %rsi      # 0x9064
movq %rbx, %rdx
callq 0xa7e0
movq 0x280(%rbx), %rdi
leaq -0x125a(%rip), %rcx     # 0x802e
movl $0x3, %esi
movl $0x2, %edx
movq %rbx, %r8
callq 0xc820
movq 0x278(%rbx), %rdi
callq 0xa6e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/iciamyplant[P]Cub3d-Linux/src/sprites.c
// Function: ft_dist_order2
void	ft_dist_order2(t_recup *recup)
{
	int i;

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

// Assembly:
cmpl $0x0, 0x3b0(%rdi)
jle 0x9318
movq 0x3b8(%rdi), %rax
movq 0x3c0(%rdi), %rcx
movq 0x418(%rdi), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movl %esi, (%rax,%rsi,4)
movsd 0x2d8(%rdi), %xmm0
movsd 0x2e0(%rdi), %xmm1
subsd -0x8(%rdx), %xmm0
subsd (%rdx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
movslq 0x3b0(%rdi), %r8
addq $0x10, %rdx
cmpq %r8, %rsi
jl 0x92d8
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x92b4
movl 0x3b0(%rbx), %ecx
testl %ecx, %ecx
jle 0x9389
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x9383
movq 0x3c0(%rbx), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd 0x8(%rdx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9375
movsd %xmm1, (%rdx,%rsi,8)
movsd %xmm0, 0x8(%rdx,%rsi,8)
movq 0x3b8(%rbx), %rcx
movl (%rcx,%rsi,4), %edi
movl 0x4(%rcx,%rsi,4), %r8d
movl %r8d, (%rcx,%rsi,4)
movl %edi, 0x4(%rcx,%rsi,4)
movl 0x3b0(%rbx), %ecx
incq %rsi
leal -0x1(%rcx), %edi
movslq %edi, %rdi
cmpq %rdi, %rsi
jl 0x933c
incl %eax
cmpl %ecx, %eax
jl 0x932e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x400(%rdi), %r11d
cmpl %esi, %r11d
jle 0x95a9
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), %ebx
movl %ebx, %eax
shll $0x7, %eax
subl %edx, %eax
addl %r10d, %eax
imull 0x264(%rdi), %eax
cltd
idivl %ebx
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 0x9596
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)
movl 0x400(%rdi), %r11d
incl %esi
addl $0x100, %r10d           # imm = 0x100
cmpl %r11d, %esi
jl 0x9516
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9319
cmpl $0x0, 0x3b0(%rbx)
jle 0x967a
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x938b
xorpd %xmm2, %xmm2
movl 0x3f8(%rbx), %r14d
movl 0x404(%rbx), %ecx
cmpl %ecx, %r14d
jge 0x966c
movl 0x408(%rbx), %esi
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
shrl %eax
subl 0x3f0(%rbx), %eax
addl %r14d, %eax
imull 0x260(%rbx), %eax
shll $0x8, %eax
cltd
idivl %esi
leal 0xff(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
testl %r14d, %r14d
js 0x9664
movsd 0x3e8(%rbx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x9664
cmpl (%rbx), %r14d
jge 0x9664
movq 0x410(%rbx), %rax
movl %r14d, %esi
movsd (%rax,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9664
sarl $0x8, %edx
movl 0x3fc(%rbx), %esi
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x94f4
xorpd %xmm2, %xmm2
movl 0x404(%rbx), %ecx
incl %r14d
jmp 0x95e0
incl %ebp
cmpl 0x3b0(%rbx), %ebp
jl 0x95c5
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x7c2c
cmpl $0x1, %eax
jne 0x969d
leaq 0x3b30(%rip), %rsi      # 0xd1c5
movq %rbx, %rdi
callq 0x970c
cmpb $0x78, 0x50(%rbx)
jne 0x96b2
leaq 0x3b32(%rip), %rsi      # 0xd1dc
movq %rbx, %rdi
callq 0x970c
cmpl $0x6, 0x60(%rbx)
je 0x96c7
leaq 0x3b2c(%rip), %rsi      # 0xd1eb
movq %rbx, %rdi
callq 0x970c
cmpl $0x1, 0x78(%rbx)
jne 0x96dc
leaq 0x3b31(%rip), %rsi      # 0xd205
movq %rbx, %rdi
callq 0x970c
cmpl $0x1, 0x7c(%rbx)
jne 0x96f1
leaq 0x3b2e(%rip), %rsi      # 0xd217
movq %rbx, %rdi
callq 0x970c
cmpl $0x2, 0x90(%rbx)
jne 0x970a
leaq 0x3b2e(%rip), %rsi      # 0xd22f
movq %rbx, %rdi
popq %rbx
jmp 0x970c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b2c(%rip), %rsi      # 0xd250
movl $0x6, %edx
movl $0x1, %edi
callq 0x73d0
movq %r14, %rdi
callq 0x9d78
movslq %eax, %rdx
movl $0x1, %edi
movq %r14, %rsi
callq 0x73d0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9759
callq 0x7190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9767
callq 0x7190
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x9775
callq 0x7190
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x9783
callq 0x7190
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x9791
callq 0x7190
cmpq $0x0, 0x48(%rbx)
je 0x97ba
cmpl $0x0, 0x40(%rbx)
jle 0x97ba
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x7190
incq %r14
movslq 0x40(%rbx), %rax
cmpq %rax, %r14
jl 0x97a1
movq %rbx, %rdi
callq 0x97c2
// File: /workspace/github_c_makefile_star2_O3/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 0x97d4
callq 0x7190
movq 0x3b8(%rbx), %rdi
testq %rdi, %rdi
je 0x97e5
callq 0x7190
movq 0x3c0(%rbx), %rdi
testq %rdi, %rdi
je 0x97f6
callq 0x7190
movq 0x418(%rbx), %rdi
testq %rdi, %rdi
je 0x9807
callq 0x7190
movq 0x410(%rbx), %rdi
testq %rdi, %rdi
je 0x9818
callq 0x7190
movq %rbx, %rdi
callq 0x9820
// File: /workspace/github_c_makefile_star2_O3/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 0x9839
leaq 0x3893(%rip), %rsi      # 0xd0c4
movq %rbx, %rdi
callq 0x970c
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x9851
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0xa8(%rbx), %rsi
testq %rsi, %rsi
je 0x9869
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0x108(%rbx), %rsi
testq %rsi, %rsi
je 0x9881
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0x168(%rbx), %rsi
testq %rsi, %rsi
je 0x9899
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0x1c8(%rbx), %rsi
testq %rsi, %rsi
je 0x98b1
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0x228(%rbx), %rsi
testq %rsi, %rsi
je 0x98c9
movq 0x278(%rbx), %rdi
callq 0xc870
movq 0x280(%rbx), %rsi
testq %rsi, %rsi
je 0x98e1
movq 0x278(%rbx), %rdi
callq 0xc2c0
xorl %edi, %edi
callq 0x70a0
// File: /workspace/github_c_makefile_star2_O3/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 0x380c(%rip), %rdi      # 0xd25a
movl $0x42, %esi
xorl %eax, %eax
callq 0x7400
movl %eax, %ebp
movl %eax, %esi
cmpl $-0x1, %eax
jne 0x9a77
leaq 0x37fc(%rip), %rsi      # 0xd266
movq %rbx, %rdi
callq 0x970c
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x98e8
testl %r14d, %r14d
js 0x9ad5
movl (%rbx), %eax
testl %eax, %eax
jle 0x9ac9
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
movl (%rbx), %eax
incq %r15
cmpl %eax, %r15d
jl 0x9a8d
leal -0x1(%r14), %ecx
testl %r14d, %r14d
movl %ecx, %r14d
jg 0x9a86
leaq 0x37a4(%rip), %rdi      # 0xd280
callq 0x7110
leaq 0x37ac(%rip), %rsi      # 0xd294
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x970c
// File: /workspace/github_c_makefile_star2_O3/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 0x9afe
cmpb $0x65, -0x2(%rax)
jne 0x9b3c
cmpb $0x76, -0x3(%rax)
jne 0x9b3c
cmpb $0x61, -0x4(%rax)
jne 0x9b3c
cmpb $0x73, -0x5(%rax)
jne 0x9b3c
cmpb $0x2d, -0x6(%rax)
jne 0x9b3c
cmpb $0x2d, -0x7(%rax)
jne 0x9b3c
callq 0x9d78
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x7, %ecx
jl 0x9b3e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9bfb
cmpl $0xa, %eax
je 0x9ba4
incq %r13
jmp 0x9b91
movl %r13d, %edx
xorl %ebp, %ebp
movq %rsi, %rdi
xorl %esi, %esi
callq 0x9d91
movq %rax, %r15
movq (%r14), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x9e09
movq %rax, (%r14)
movq %r15, %rdi
callq 0x7190
movq %r12, %rdi
callq 0x7190
movq (%rbx), %r14
leal 0x1(%r13), %r15d
movq %r14, %rdi
callq 0x9d78
subl %r13d, %eax
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x9eb4
movq %rax, (%rbx)
jmp 0x9c1b
movq (%r14), %rbx
movq %rbx, %rdi
callq 0x9e09
movq %rax, (%r14)
movl $0x1, %ebp
testq %rbx, %rbx
je 0x9c1b
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_O3/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 0x9c64
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rdi
callq 0x7190
movq $0x0, (%r14)
xorl %ebp, %ebp
cmpq $0x0, (%rbx)
jne 0x9c69
movl $0x1, %edi
callq 0x7100
movq %rax, (%rbx)
movb $0x0, (%rax)
jmp 0x9c69
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9cb8
movq 0xb612(%rip), %rdi      # 0x152b8
testq %rdi, %rdi
je 0x9cb8
callq 0x7190
xorl %r14d, %r14d
jmp 0x9d58
testl %ebp, %ebp
sets %al
testq %rbx, %rbx
sete %cl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
orb %al, %cl
jne 0x9d58
movq $0x0, (%rbx)
cmpq $0x0, 0xb5d8(%rip)      # 0x152b8
je 0x9cff
leaq 0xb5cf(%rip), %rsi      # 0x152b8
movq %rbx, %rdi
callq 0x9b7a
testl %eax, %eax
je 0x9d52
cmpq $0x0, 0xb5bb(%rip)      # 0x152b8
jne 0x9d15
movl $0x1001, %edi           # imm = 0x1001
callq 0x7100
movq %rax, 0xb5a8(%rip)      # 0x152b8
testq %rax, %rax
je 0x9d58
leaq 0xb59c(%rip), %r14      # 0x152b8
movq 0xb595(%rip), %rsi      # 0x152b8
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x70e0
testl %eax, %eax
jle 0x9d60
movq 0xb57e(%rip), %rcx      # 0x152b8
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b7a
testl %eax, %eax
jne 0x9d1c
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb551(%rip), %rsi      # 0x152b8
movl %eax, %edi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x9c2c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x9dfd
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r15, %rdx
incl %ecx
cmpb $0x0, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x9db5
cmpl %r14d, %ecx
jbe 0x9dfd
movl %r14d, %ecx
movb (%r15,%rcx), %dl
testb %dl, %dl
sete %cl
testq %rbx, %rbx
sete %sil
orb %cl, %sil
jne 0x9dfd
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 0x9dff
cmpq %rbx, %rcx
jb 0x9de2
jmp 0x9dff
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e30
movq $-0x1, %rcx
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%r14,%rcx)
movq %rax, %rcx
jne 0x9e1f
jmp 0x9e32
xorl %eax, %eax
testq %rbx, %rbx
je 0x9e4e
movq $-0x1, %rdx
leaq 0x1(%rdx), %rcx
cmpb $0x0, 0x1(%rbx,%rdx)
movq %rcx, %rdx
jne 0x9e3e
jmp 0x9e50
xorl %ecx, %ecx
addl %ecx, %eax
incl %eax
movslq %eax, %rdi
callq 0x7100
testq %rax, %rax
je 0x9eac
xorl %ecx, %ecx
testq %r14, %r14
je 0x9e80
movb (%r14), %dl
testb %dl, %dl
je 0x9e80
xorl %ecx, %ecx
movb %dl, (%rax,%rcx)
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x9e71
testq %rbx, %rbx
je 0x9ea6
movb (%rbx), %dl
testb %dl, %dl
je 0x9ea6
movl %ecx, %edi
incq %rbx
movq %rax, %rsi
addq %rdi, %rsi
movb %dl, (%rsi)
movb (%rbx), %dl
incq %rbx
incl %ecx
incq %rsi
testb %dl, %dl
jne 0x9e96
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9e09
testl %r14d, %r14d
jle 0x9f03
cmpb $0x0, (%rax)
je 0x9f03
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 0x9f03
cmpb $0x0, 0x1(%rax,%rsi)
movq %r15, %rsi
jne 0x9ee8
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_O3/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 0xa010
jp 0xa010
movq $0x0, 0x338(%rdi)
movsd 0x308(%rdi), %xmm0
ucomisd %xmm2, %xmm0
jne 0xa066
jnp 0xa06e
jmp 0xa066
movsd 0x308(%rdi), %xmm1
ucomisd %xmm2, %xmm1
jne 0xa02a
jp 0xa02a
movsd 0x3118(%rip), %xmm2     # 0xd140
jmp 0xa04a
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
divsd %xmm3, %xmm2
addsd 0x30fa(%rip), %xmm2     # 0xd140
sqrtsd %xmm2, %xmm2
movsd %xmm2, 0x338(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0xa05e
jnp 0xa06e
ucomisd %xmm2, %xmm0
jne 0xa077
jp 0xa077
movsd 0x30d2(%rip), %xmm2     # 0xd140
movsd %xmm2, 0x340(%rdi)
retq
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
divsd %xmm0, %xmm1
addsd 0x30b5(%rip), %xmm1     # 0xd140
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
jmp 0xa06e
// File: /workspace/github_c_makefile_star2_O3/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 0xa09f
leaq (%rdi,%rcx), %rax
decq %rcx
incq %rcx
cmpb $0x20, 0x1(%rax)
leaq 0x1(%rax), %rax
je 0xa0b1
movb (%rax), %dl
addb $-0x30, %dl
incq %rax
incq %rcx
cmpb $0xa, %dl
jb 0xa0be
movl %ecx, %ecx
movb (%rdi,%rcx), %dl
leal -0x3a(%rdx), %ecx
cmpb $-0xb, %cl
ja 0xa103
movl $0x1, %ecx
cmpb $0x2c, %dl
je 0xa0ee
movzbl %dl, %edx
testl %edx, %edx
jne 0xa0f0
jmp 0xa0fe
incl %ecx
movb (%rax), %dl
leal -0x3a(%rdx), %esi
incq %rax
cmpb $-0xa, %sil
jb 0xa0e0
cmpl $0x2, %ecx
je 0xa10a
movl $0x2, 0x74(%rbx)
callq 0x9b40
cmpl $0x2, %eax
je 0xa11b
movl $0x2, 0x74(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
leaq 0x15f7a(%rip), %rax     # 0x1e584
movl (%rax), %eax
leaq 0x15f75(%rip), %rcx     # 0x1e588
movl (%rcx), %ecx
movl $0x0, 0x16df1(%rip)     # 0x1f410
movw $0x0, 0x16dec(%rip)     # 0x1f414
movl %eax, 0x16dea(%rip)     # 0x1f418
movl %ecx, 0x16de8(%rip)     # 0x1f41c
movq $0x0, 0x16de1(%rip) # 0x1f420
movb $0x0, 0x16de2(%rip)     # 0x1f428
movq 0x16e03(%rip), %rdi     # 0x1f450
movslq 0x16da0(%rip), %rbx     # 0x1f3f4
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60a0
leaq 0x15f0f(%rip), %rax     # 0x1e578
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x868b
movq 0x16dda(%rip), %rdx     # 0x1f450
movl 0x16d78(%rip), %esi     # 0x1f3f4
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x867c
movl $0x0, 0x16d9f(%rip)     # 0x1f434
movl 0x16d55(%rip), %eax     # 0x1f3f0
decl %eax
movl %eax, 0x16d95(%rip)     # 0x1f438
movl $0x41, 0x16d8f(%rip)    # 0x1f43c
movq $0x3030303, 0x16d8c(%rip) # imm = 0x3030303
movb $0x1, %bpl
leaq 0x190be(%rip), %rbx     # 0x21780
movb 0x16d60(%rip), %dl      # 0x1f428
movl 0x16d22(%rip), %ecx     # 0x1f3f0
movl %edx, %eax
andb $-0x2, %al
movb %al, 0x16d50(%rip)      # 0x1f428
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x86f2
movl 0x16d4c(%rip), %esi     # 0x1f438
movl 0x16d42(%rip), %eax     # 0x1f434
movl 0x16cfc(%rip), %edx     # 0x1f3f4
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, 0x16d0d(%rip)     # 0x1f420
movl %edi, 0x16d0b(%rip)     # 0x1f424
movl 0x16d1d(%rip), %eax     # 0x1f43c
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0x16cd9(%rip), %xmm0    # 0x1f410
movups %xmm0, (%rbx,%rsi)
movups 0x16cda(%rip), %xmm0    # 0x1f41c
movups %xmm0, 0xc(%rbx,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x884c
callq 0x89ba
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x86c2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x162f3(%rip), %rax     # 0x1f3f8
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x772d
movl 0x162dd(%rip), %ecx     # 0x1f3f4
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r15
addq $-0x10, %r15
cmpq %r15, %r14
je 0x9134
jbe 0x913a
jmp 0x915e
cmpl $0x20, (%r14)
je 0x915e
leaq 0xc(%rsp), %rbx
movl (%r14), %edi
movq %rbx, %rsi
callq 0x7084
movq %rbx, %rdi
movq %rax, %rsi
callq 0x909e
addq $0x10, %r14
cmpq %r15, %r14
jbe 0x913f
leaq 0x64ef(%rip), %rdi      # 0xf654
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x909e
// File: /workspace/github_c_makefile_star2_O3/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 0xb1b6
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x168f4(%rip), %rdi     # 0x21a58
callq 0x6360
movq %r14, 0x168e8(%rip)     # 0x21a58
movq 0x16761(%rip), %rdi     # 0x218d8
movq 0x1676a(%rip), %rdx     # 0x218e8
movl $0x1, %esi
movq %rbx, %rcx
callq 0x6680
movq 0x16746(%rip), %rdi     # 0x218d8
movl $0x1, %esi
callq 0x69b0
cmpq 0x16745(%rip), %rax     # 0x218e8
je 0xb1aa
callq 0x71c0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb0ea
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc5a1
movl %edi, 0x1547a(%rip)     # 0x219fc
cmpl $0x6, %edi
jae 0xc591
movl $0x2b, %ecx
btl %edi, %ecx
jb 0xc599
xorl %eax, %eax
cmpl $0x7, %edi
sete %al
movl %eax, 0x15469(%rip)     # 0x21a08
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x12f4d(%rip)     # 0x21ac0
jle 0xebae
xorl %ebx, %ebx
xorl %r14d, %r14d
movq 0x12f47(%rip), %rax     # 0x21ac8
movq 0x8(%rax,%rbx), %rdi
callq 0x6870
movq 0x12f36(%rip), %rax     # 0x21ac8
movq (%rax,%rbx), %rdi
callq 0x6940
incq %r14
movslq 0x12f1b(%rip), %rax     # 0x21ac0
addq $0x10, %rbx
cmpq %rax, %r14
jl 0xeb7a
movq 0x12f13(%rip), %rdi     # 0x21ac8
testq %rdi, %rdi
je 0xebca
callq 0x6360
movq $0x0, 0x12efe(%rip) # 0x21ac8
movl $0x0, 0x12eec(%rip)     # 0x21ac0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12ed6(%rip), %rsi     # 0x21ac0
movq 0x12ed7(%rip), %rdi     # 0x21ac8
testq %rsi, %rsi
jle 0xec0e
movq %rsi, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
cmpq %rbx, (%rdi,%rcx)
je 0xec70
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xebff
shlq $0x4, %rsi
addq $0x10, %rsi
callq 0x68f0
movq %rax, 0x12ea6(%rip)     # 0x21ac8
movq %rbx, %rdi
callq 0x63a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x66e0
movq %rax, %r14
testq %rax, %rax
jne 0xec4a
leaq 0x18d5(%rip), %rdi      # 0x10518
xorl %eax, %eax
callq 0x6f96
movq 0x12e77(%rip), %rax     # 0x21ac8
movslq 0x12e68(%rip), %rcx     # 0x21ac0
leal 0x1(%rcx), %edx
shlq $0x4, %rcx
movq %rbx, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
movl %edx, 0x12e52(%rip)     # 0x21ac0
jmp 0xec75
movq 0x8(%rdi,%rcx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xebdc
testq %rax, %rax
je 0xef6e
movq %rax, %r12
movq %rbx, 0x20(%rsp)
callq 0x6780
movq %rax, %rbx
movq %rax, %rdi
movl $0x4, %esi
callq 0x66c0
movslq %ebp, %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
testl %r14d, %r14d
jle 0xef21
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %r15
addl %r15d, %eax
movslq %eax, %r14
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %rbp
addq $0x4, %rbp
leaq 0xc(%rsp), %r13
btl $0xa, (%rbp)
movl $0x20, %eax
jb 0xeef9
movl -0x4(%rbp), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x6280
incq %r15
addq $0x10, %rbp
cmpq %r14, %r15
jl 0xeeea
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x61c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6420
movq 0x18(%rsp), %rcx
testl %ecx, %ecx
jle 0xef66
movl %ecx, %ecx
movq 0x20(%rsp), %rdx
movq 0x10(%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 0xef55
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_O3/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 0x23be(%rip), %rdi      # 0x5180
movl $0x2, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2e2b
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 0x2e0c
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 0x2df0
leaq 0x530(%rip), %rdi       # 0x3343
leaq 0x496(%rip), %rsi       # 0x32b0
leaq 0x4ef(%rip), %rcx       # 0x3310
movl $0x21, %edx
callq 0x2130
leaq 0x476(%rip), %rdi       # 0x32a8
leaq 0x477(%rip), %rsi       # 0x32b0
leaq 0x4d0(%rip), %rcx       # 0x3310
movl $0x1e, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/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 0x4e34
cmpl $0x2, %ebx
jne 0x257b
movq 0x8(%r14), %rdi
callq 0x3e30
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 0x4fd3
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 0x4fd3
callq 0x2090
movl $0x0, (%rax)
jmp 0x2691
movq %rax, %rbx
leaq 0x7a53(%rip), %rdi      # 0xa027
xorl %eax, %eax
callq 0x4eb4
movl $0x0, (%rbx)
jmp 0x2691
movq %rbx, %rdi
callq 0x4748
cmpl $-0x1, %eax
je 0x2691
movl %eax, %edi
callq 0x66f4
testq %rax, %rax
jne 0x2621
callq 0x2090
cmpl $0x0, (%rax)
jne 0x269b
leaq 0x7a4c(%rip), %rdi      # 0xa064
xorl %eax, %eax
callq 0x4fd3
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 0x50f8
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 0x2a49
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 0x4eb4
jmp 0x25db
movq 0x30(%rsp), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x6de5
movq %r14, %rdi
callq 0x6df9
movq %rbx, %rdi
callq 0x4542
xorl %edi, %edi
callq 0x2290
movq %rax, %rbx
leaq 0x79a1(%rip), %rdi      # 0xa085
jmp 0x26a5
// File: /workspace/github_c_makefile_star2_O3/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 0x2755
movq %rdi, %r14
movq 0x18(%rdi), %rcx
leaq 0x58(%rip), %r15        # 0x275d
cmpq $0xfff, %rcx            # imm = 0xFFF
ja 0x2755
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 0x5325
testl %eax, %eax
jne 0x2750
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
incq %rax
movq %rax, 0x8(%r14)
incq %rcx
movq %rcx, 0x18(%r14)
cmpq 0x10(%r14), %rax
jb 0x2705
jmp 0x2755
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x3e0e(%rip)     # 0x5160
movl $0xd5d, %edi            # imm = 0xD5D
callq 0x1100
xorl %ebx, %ebx
leaq 0x3dcb(%rip), %r14      # 0x5130
movsd 0x1ca3(%rip), %xmm1     # 0x3010
leaq 0x3dfc(%rip), %r15      # 0x5170
movl (%r14,%rbx,4), %eax
movsd 0x1c88(%rip), %xmm0     # 0x3008
testl %eax, %eax
jle 0x1399
incl %eax
movsd 0x1c7a(%rip), %xmm0     # 0x3008
mulsd %xmm1, %xmm0
decl %eax
cmpl $0x1, %eax
ja 0x138e
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 0x1c80
movsd 0x1c45(%rip), %xmm1     # 0x3010
movq %rax, (%r15,%rbx,8)
incq %rbx
cmpq $0x5, %rbx
jne 0x1374
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x145a
retq
jae 0x1462
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl 0x4(%rsi), %ecx
cmpl %ecx, 0x4(%rdi)
jg 0x1459
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jl 0x1459
movl 0x8(%rdi), %eax
subl 0x8(%rsi), %eax
jne 0x1459
movl 0xc(%rdi), %eax
subl 0xc(%rsi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1e4f
movq %rsi, 0x18(%rcx)
movq %rsi, (%rax,%rdx,8)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ede
movq 0x30(%rsi), %rdi
movq %rdi, 0x30(%rcx)
movq %rcx, 0x28(%rdi)
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x1f1b
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x1eef
movq 0x10(%rax), %r8
movq %r8, 0x10(%rcx)
cmpq %rax, 0x20(%rdi)
je 0x1eff
movq 0x10(%rax), %r8
addq $0x18, %r8
jmp 0x1f03
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
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_IncrementCounter
void LCU_IncrementCounter(LCU_type * lcu, LCUITEM *newi)
{
	LCUGROUP *oldgroup;

	oldgroup=newi->parentg;
	if ((oldgroup->nextg!=NULL) && 
		(oldgroup->nextg->count - oldgroup->count==1))
		LCU_PutInNewGroup(lcu, newi,oldgroup->nextg);
	// if the next group exists
	else { // need to create a new group with a differential of one
		if (newi->nexting==newi) // if there is only one item in the group...
			newi->parentg->count++;
		else      
			LCU_AddNewGroupAfter(lcu,newi,oldgroup);
	}
}

// Assembly:
movq 0x10(%rsi), %rdx
movq 0x18(%rdx), %rax
testq %rax, %rax
je 0x1fb2
movl (%rax), %ecx
subl (%rdx), %ecx
cmpl $0x1, %ecx
jne 0x1fb2
movq %rax, %rdx
jmp 0x1eb3
cmpq %rsi, 0x28(%rsi)
je 0x1fbd
jmp 0x1f38
incl (%rdx)
retq