LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/strategy.c
// Function: angle_opmine_mode
unsigned char	angle_opmine_mode(t_game *game)
{
	if (over(game, &game->contact, E_ADV, 3) == FALSE
			&& over(game, &game->contact, E_MINE, 5) == FALSE)
	{
		if (over(game, &game->good_contact, E_ADV, 3) == TRUE
				|| over(game, &game->good_contact, E_MINE, 5) == TRUE)
			return (TRUE);
		if (game->nearest_adv.x <= game->board.size.x / 2
			|| game->core_adv.x > game->core_mine.x)
		{
			if (delta(&game->contact, &game->angle_opmine)
					<= delta(&game->good_contact, &game->angle_opmine))
				return (TRUE);
		}
		else
		{
			if (delta(&game->contact, &game->angle_opmine)
					< delta(&game->good_contact, &game->angle_opmine))
				return (TRUE);
		}
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c(%rdi), %r14
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rsi
callq 0x2034
testl %eax, %eax
jne 0x1c1c
pushq $0x3
popq %rdx
pushq $0x5
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2034
testl %eax, %eax
je 0x1c2b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x94(%rbx), %r15
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2034
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1c1e
pushq $0x3
popq %rdx
pushq $0x5
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2034
cmpl $0x1, %eax
je 0x1c1e
movl 0x8(%rbx), %eax
movl 0x40(%rbx), %ecx
pushq $0x2
popq %rsi
cltd
idivl %esi
cmpl %eax, %ecx
jle 0x1c79
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1c9d
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a92
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a92
cmpl %eax, %r14d
jg 0x1c1c
jmp 0x1c1e
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a92
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a92
cmpl %eax, %r14d
jge 0x1c1c
jmp 0x1c1e
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/strategy.c
// Function: angle_opadv_mode
unsigned char	angle_opadv_mode(t_game *game)
{
	if (over(game, &game->contact, E_ADV, 3) == FALSE
			&& over(game, &game->contact, E_MINE, 5) == FALSE)
	{
		if (over(game, &game->good_contact, E_ADV, 3) == TRUE
				|| over(game, &game->good_contact, E_MINE, 5) == TRUE)
			return (TRUE);
		if (game->nearest_adv.x <= game->board.size.x / 2
			|| game->core_adv.x > game->core_mine.x)
		{
			if (delta(&game->contact, &game->angle_opadv)
					<= delta(&game->good_contact, &game->angle_opadv))
				return (TRUE);
		}
		else
		{
			if (delta(&game->contact, &game->angle_opadv)
					< delta(&game->good_contact, &game->angle_opadv))
				return (TRUE);
		}
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c(%rdi), %r14
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
movq %r14, %rsi
callq 0x2034
testl %eax, %eax
jne 0x1d00
pushq $0x3
popq %rdx
pushq $0x5
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2034
testl %eax, %eax
je 0x1d0f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x94(%rbx), %r15
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2034
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1d02
pushq $0x3
popq %rdx
pushq $0x5
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2034
cmpl $0x1, %eax
je 0x1d02
movl 0x8(%rbx), %eax
movl 0x40(%rbx), %ecx
pushq $0x2
popq %rsi
cltd
idivl %esi
cmpl %eax, %ecx
jle 0x1d5d
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1d81
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a92
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a92
cmpl %eax, %r14d
jg 0x1d00
jmp 0x1d02
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a92
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a92
cmpl %eax, %r14d
jge 0x1d00
jmp 0x1d02
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/strategy.c
// Function: glue_mode
unsigned char	glue_mode(t_game *game)
{
	if (game->nearest_adv.x > game->board.size.x / 2)
	{
		if (delta(&game->contact, &game->last_adv)
				<= delta(&game->good_contact, &game->last_adv))
			return (TRUE);
	}
	else if (delta(&game->contact, &game->last_adv)
			< delta(&game->good_contact, &game->last_adv))
		return (TRUE);
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl 0x40(%rdi), %r12d
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
addq $0x8c, %rdi
leaq 0x38(%r14), %r15
movq %r15, %rsi
callq 0x1a92
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a92
movl %eax, %ecx
movb $0x1, %al
cmpl %ebp, %r12d
jle 0x1dfc
cmpl %ecx, %ebx
jg 0x1e00
jmp 0x1e02
cmpl %ecx, %ebx
jl 0x1e02
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/strategy.c
// Function: attack_mode
unsigned char	attack_mode(t_game *game)
{
	if (game->nearest_adv.x > game->board.size.x / 2)
	{
		if (delta(&game->contact, &game->nearest_adv)
				<= delta(&game->good_contact, &game->nearest_adv))
			return (TRUE);
	}
	else if (delta(&game->contact, &game->nearest_adv)
			< delta(&game->good_contact, &game->nearest_adv))
		return (TRUE);
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %r15
movl 0x8(%rdi), %eax
movl 0x40(%rdi), %r12d
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
addq $0x8c, %rdi
movq %r15, %rsi
callq 0x1a92
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a92
movl %eax, %ecx
movb $0x1, %al
cmpl %ebp, %r12d
jle 0x1e5b
cmpl %ecx, %ebx
jg 0x1e5f
jmp 0x1e61
cmpl %ecx, %ebx
jl 0x1e61
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/select_strategy.c
// Function: check_angles
unsigned char	check_angles(t_game *game)
{
	if (game->better_angle == E_NO_ANGLE)
		return (FALSE);
	if (game->better_angle == E_ANGLE_TARGET
		&& scanner(game, &game->angle_target, E_MINE, 2) == FALSE
		&& scanner(game, &game->angle_target, E_ADV, 1) == FALSE
		&& over(game, &game->angle_target, E_EMPTY, 6) == TRUE)
		game->mode = E_ANGLE_TARGET;
	else if (game->better_angle == E_ANGLE_OPMINE
		&& scanner(game, &game->angle_opmine, E_MINE, 2) == FALSE
		&& scanner(game, &game->angle_opmine, E_ADV, 1) == FALSE
		&& over(game, &game->angle_opmine, E_EMPTY, 3) == TRUE)
		game->mode = E_ANGLE_OPMINE;
	else if (game->better_angle == E_ANGLE_OPADV
		&& scanner(game, &game->angle_opadv, E_MINE, 2) == FALSE
		&& scanner(game, &game->angle_opadv, E_ADV, 1) == FALSE
		&& over(game, &game->angle_opadv, E_EMPTY, 6) == TRUE)
		game->mode = E_ANGLE_OPADV;
	else
		return (FALSE);
	return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x88(%rdi), %eax
cmpl $0x5, %eax
je 0x1f7d
movq %rdi, %rbx
testl %eax, %eax
jne 0x1ef9
leaq 0x60(%rbx), %r14
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
jne 0x1ef3
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x20c0
testl %eax, %eax
jne 0x1ef3
xorl %ebp, %ebp
pushq $0x6
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2034
cmpl $0x1, %eax
je 0x1fa6
movl 0x88(%rbx), %eax
cmpl $0x1, %eax
jne 0x1f42
leaq 0x78(%rbx), %r14
pushq $0x3
popq %rdx
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
jne 0x1f42
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x20c0
testl %eax, %eax
jne 0x1f42
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2034
cmpl $0x1, %eax
je 0x1fa6
cmpl $0x2, 0x88(%rbx)
jne 0x1f7d
leaq 0x80(%rbx), %r15
pushq $0x3
popq %rdx
pushq $0x2
popq %rbp
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x20c0
testl %eax, %eax
jne 0x1f7d
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movl %ecx, %edx
callq 0x20c0
testl %eax, %eax
je 0x1f8e
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
pushq $0x6
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2034
cmpl $0x1, %eax
jne 0x1f80
movl %ebp, 0x2c(%rbx)
movb $0x1, %r14b
jmp 0x1f80
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/select_strategy.c
// Function: select_strategy
void			select_strategy(t_game *game)
{
	if ((scanner(game, &game->last_adv, E_MINE, 3) == TRUE
		|| delta(&game->angle_mine, &game->last_adv)
		< delta(&game->angle_mine, &game->last_mine))
		&& game->board.size.x * game->board.size.y > 500
		&& over(game, &game->last_adv, E_EMPTY, 2) == TRUE)
		game->mode = E_GLUE;
	else if (check_angles(game) == FALSE)
		game->mode = E_ATTACK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
pushq $0x3
popq %rbp
movq %r14, %rsi
movl %ebp, %edx
movl %ebp, %ecx
callq 0x20c0
cmpl $0x1, %eax
je 0x1ff4
leaq 0x70(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a92
movl %eax, %r12d
leaq 0x48(%rbx), %rsi
movq %r15, %rdi
callq 0x1a92
cmpl %eax, %r12d
jge 0x201c
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
cmpl $0x1f5, %eax            # imm = 0x1F5
jl 0x201c
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2034
cmpl $0x1, %eax
jne 0x201c
pushq $0x4
popq %rbp
jmp 0x2028
movq %rbx, %rdi
callq 0x1e8e
testb %al, %al
jne 0x202b
movl %ebp, 0x2c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools.c
// Function: over
int			over(t_game *game, t_point *target, enum e_state state, int zone)
{
	int		x;
	int		y;
	int		max_x;
	int		max_y;
	int		over;

	over = 0;
	x = target->x - zone < 0 ? 0 : target->x - zone;
	max_x = target->x + zone > game->board.size.x
			? game->board.size.x : target->x + zone;
	max_y = target->y + zone > game->board.size.y
			? game->board.size.y : target->y + zone;
	while (x < max_x)
	{
		y = target->y - zone < 0 ? 0 : target->y - zone;
		while (y < max_y)
		{
			if (game->board.mx[x][y] == state)
				over++;
			y++;
		}
		x++;
	}
	return (over > (zone * zone) / 2 + (zone * zone) / 3 ? TRUE : FALSE);
}

// Assembly:
pushq %rbp
pushq %rbx
movl %ecx, %eax
movl (%rsi), %r10d
movl 0x4(%rsi), %ecx
movl %r10d, %r8d
subl %eax, %r8d
xorl %esi, %esi
testl %r8d, %r8d
cmovlel %esi, %r8d
addl %eax, %r10d
movl 0x8(%rdi), %r9d
movl 0xc(%rdi), %r11d
cmpl %r9d, %r10d
cmovgel %r9d, %r10d
leal (%rcx,%rax), %r9d
cmpl %r11d, %r9d
cmovll %r9d, %r11d
subl %eax, %ecx
testl %ecx, %ecx
cmovlel %esi, %ecx
movslq %r11d, %r9
movslq %r10d, %r10
cmpq %r10, %r8
jge 0x20a2
movq %rcx, %r11
cmpq %r9, %r11
jge 0x209d
movq 0x10(%rdi), %rbx
movq (%rbx,%r8,8), %rbx
xorl %ebp, %ebp
cmpl %edx, (%rbx,%r11,4)
sete %bpl
addl %ebp, %esi
incq %r11
jmp 0x207f
incq %r8
jmp 0x2077
imull %eax, %eax
movl %eax, %ecx
shrl %ecx
movl $0x3, %edi
xorl %edx, %edx
divl %edi
addl %ecx, %eax
xorl %ecx, %ecx
cmpl %eax, %esi
setg %cl
movl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools.c
// Function: scanner
int			scanner(t_game *game, t_point *target, enum e_state state, int zone)
{
	int		x;
	int		y;
	int		max_x;
	int		max_y;

	x = target->x - zone < 0 ? 0 : target->x - zone;
	max_x = target->x + zone > game->board.size.x
			? game->board.size.x : target->x + zone;
	max_y = target->y + zone > game->board.size.y
			? game->board.size.y : target->y + zone;
	while (x < max_x)
	{
		y = target->y - zone < 0 ? 0 : target->y - zone;
		while (y < max_y)
		{
			if (game->board.mx[x][y] == state)
				return (TRUE);
			y++;
		}
		x++;
	}
	return (FALSE);
}

// Assembly:
pushq %r14
pushq %rbx
movl (%rsi), %r9d
movl 0x4(%rsi), %esi
movl %r9d, %r8d
subl %ecx, %r8d
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
addl %ecx, %r9d
movl 0x8(%rdi), %r10d
movl 0xc(%rdi), %r11d
cmpl %r10d, %r9d
cmovgel %r10d, %r9d
leal (%rsi,%rcx), %r10d
cmpl %r11d, %r10d
cmovll %r10d, %r11d
subl %ecx, %esi
testl %esi, %esi
cmovlel %eax, %esi
movslq %r11d, %rcx
movslq %r9d, %r10
movl $0x1, %r9d
cmpq %r10, %r8
jge 0x2134
movq %rsi, %r11
cmpq %rcx, %r11
jge 0x212c
movq 0x10(%rdi), %rbx
movq (%rbx,%r8,8), %rbx
leaq 0x1(%r11), %r14
cmpl %edx, (%rbx,%r11,4)
movq %r14, %r11
jne 0x2110
jmp 0x2131
incq %r8
jmp 0x2108
movl %r9d, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools.c
// Function: get_angle
void		get_angle(t_game *game)
{
	game->angle_adv = choose_angle(game, &game->core_adv);
	game->angle_mine = choose_angle(game, &game->core_mine);
	game->angle_target.x = game->angle_mine.x == 0 ? game->board.size.x - 1 : 0;
	game->angle_target.y = game->angle_mine.y == 0 ? game->board.size.y - 1 : 0;
	game->angle_opmine.x = game->angle_target.x;
	game->angle_opmine.y = game->angle_target.y == 0
						? game->board.size.y - 1 : 0;
	game->angle_opadv.x = game->angle_target.x == 0
						? game->board.size.x - 1 : 0;
	game->angle_opadv.y = game->angle_target.y;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x50(%rdi), %rsi
callq 0x21a6
movq %rax, 0x68(%rbx)
leaq 0x58(%rbx), %rsi
movq %rbx, %rdi
callq 0x21a6
movq %rax, 0x70(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
jne 0x2164
movl 0x8(%rbx), %ecx
decl %ecx
movl %ecx, 0x60(%rbx)
shrq $0x20, %rax
jne 0x217c
movl 0xc(%rbx), %eax
decl %eax
movl %eax, 0x64(%rbx)
movl %ecx, 0x78(%rbx)
xorl %edx, %edx
jmp 0x218a
andl $0x0, 0x64(%rbx)
movl %ecx, 0x78(%rbx)
movl 0xc(%rbx), %edx
decl %edx
xorl %eax, %eax
movl %edx, 0x7c(%rbx)
xorl %edx, %edx
testl %ecx, %ecx
jne 0x2198
movl 0x8(%rbx), %edx
decl %edx
movl %edx, 0x80(%rbx)
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools.c
// Function: choose_angle
t_point		choose_angle(t_game *game, t_point *ref)
{
	t_point	win1;
	t_point	win2;
	t_point	p1;
	t_point	p2;
	t_point ret;

	ft_bzero(&p1, sizeof(t_point));
	p2.x = game->board.size.x - 1;
	p2.y = game->board.size.y - 1;
	win1 = (delta(ref, &p1) < delta(ref, &p2)) ? p1 : p2;
	p1.x = 0;
	p1.y = game->board.size.y - 1;
	p2.x = game->board.size.x - 1;
	p2.y = 0;
	win2 = (delta(ref, &p1) < delta(ref, &p2)) ? p1 : p2;
	ret = (delta(ref, &win1) < delta(ref, &win2)) ? win1 : win2;
	return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x10(%rsp), %r14
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2698
movq 0x8(%r13), %xmm0
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
leaq 0x8(%rsp), %r15
movq %xmm1, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a92
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a92
cmpl %eax, %ebp
movq %r15, %rax
cmovlq %r14, %rax
movq (%rax), %rax
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
andl $0x0, (%r14)
movl 0xc(%r13), %eax
decl %eax
movl %eax, 0x4(%r14)
movl 0x8(%r13), %eax
decl %eax
movl %eax, (%r15)
andl $0x0, 0x4(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a92
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a92
cmpl %eax, %ebp
cmovlq %r14, %r15
movq (%r15), %rax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a92
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a92
cmpl %eax, %ebp
cmovlq %r12, %r14
movq (%r14), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools.c
// Function: chose_better_angle
void		chose_better_angle(t_game *game)
{
	int	delta_mine;
	int	delta_adv;
	int	delta_target;
	int	modulo;

	if (game->board.size.x * game->board.size.y < 500)
	{
		delta_mine = get_better(game, &game->angle_opmine, farest_delta);
		delta_adv = get_better(game, &game->angle_opadv, farest_delta);
		delta_target = get_better(game, &game->angle_target, farest_delta);
		if (delta_mine > delta_adv && delta_mine > delta_target)
			game->better_angle = E_ANGLE_OPMINE;
		else if (delta_adv > delta_mine && delta_mine > delta_target)
			game->better_angle = E_ANGLE_OPADV;
		else
			game->better_angle = E_ANGLE_TARGET;
		return ;
	}
	modulo = game->turn < 30 ? 2 : 3;
	if (game->turn > 30 && game->turn % modulo == 0)
		game->better_angle = E_ANGLE_TARGET;
	else if (game->turn % modulo == 1)
		game->better_angle = E_ANGLE_OPMINE;
	else
		game->better_angle = E_ANGLE_OPADV;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %eax
imull 0x8(%rdi), %eax
cmpl $0x1f3, %eax            # imm = 0x1F3
jg 0x22fe
leaq 0x78(%rbx), %rsi
leaq 0x113(%rip), %r15       # 0x23ba
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23fb
movl %eax, %ebp
leaq 0x80(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23fb
movl %eax, %r14d
leaq 0x60(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x23fb
cmpl %r14d, %ebp
setg %cl
cmpl %eax, %ebp
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x2335
cmpl %eax, %ebp
setg %al
cmpl %ebp, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2316
jmp 0x2341
movl 0xa4(%rbx), %ecx
pushq $0x3
popq %rsi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
cmpl $0x1f, %ecx
jl 0x231f
testl %edx, %edx
jne 0x231f
andl $0x0, 0x88(%rbx)
jmp 0x234b
xorl %esi, %esi
cmpl $0x1e, %ecx
setl %sil
xorl $0x3, %esi
movl %ecx, %eax
cltd
idivl %esi
cmpl $0x1, %edx
jne 0x2341
movl $0x1, 0x88(%rbx)
jmp 0x234b
movl $0x2, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools2.c
// Function: get_nearest
int			get_nearest(t_game *game, t_point *pos, t_point *ok, t_point *ref)
{
	if (((ok->x == 0 && ok->y == 0) || delta(pos, ref) <= delta(ok, ref))
		&& over(game, pos, E_EMPTY, 2) == TRUE)
		return (TRUE);
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, (%rdx)
jne 0x2379
cmpl $0x0, 0x4(%r12)
je 0x2395
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a92
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a92
cmpl %eax, %ebp
jg 0x23af
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2034
cmpl $0x1, %eax
jne 0x23af
pushq $0x1
popq %rax
jmp 0x23b1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools2.c
// Function: get_better
int			get_better(t_game *game, t_point *ref,
				int (*f)(t_game *, t_point *, t_point *ok, t_point *ref))
{
	t_point pos;
	t_point ok;
	int		d;

	pos.x = -1;
	d = 0;
	ft_bzero(&ok, sizeof(t_point));
	while (++pos.x < game->board.size.x)
	{
		pos.y = -1;
		while (++pos.y < game->board.size.y)
		{
			if (game->board.mx[pos.x][pos.y] == E_MINE
					|| game->board.mx[pos.x][pos.y] == E_LAST_MINE)
			{
				if (f(game, &pos, &ok, ref) == TRUE)
				{
					ok = pos;
					d = delta(&pos, ref);
				}
			}
		}
	}
	return (d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x2698
xorl %ebp, %ebp
pushq $-0x1
popq %rax
leaq 0x8(%rsp), %r13
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x8(%r15), %eax
jge 0x2497
pushq $-0x1
popq %rax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%r15), %eax
jge 0x2491
movq 0x10(%r15), %rcx
movslq 0x8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cltq
movl (%rcx,%rax,4), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x248b
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *%rbx
cmpl $0x1, %eax
jne 0x248b
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x1a92
movl %eax, %ebp
movl 0xc(%rsp), %eax
jmp 0x243b
movl 0x8(%rsp), %eax
jmp 0x242c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/srcs/tools2.c
// Function: nearest
t_point		nearest(t_game *game)
{
	t_point	pos;
	t_point ok;
	int		delta;

	ft_bzero(&ok, sizeof(t_point));
	delta = 0;
	pos.x = -1;
	while (++pos.x < game->board.size.x)
	{
		pos.y = -1;
		while (++pos.y < game->board.size.y)
		{
			if (game->board.mx[pos.x][pos.y] == E_ADV
					|| game->board.mx[pos.x][pos.y] == E_LAST_ADV)
			{
				if ((ok.x == 0 && ok.y == 0)
					|| get_better(game, &pos, get_nearest) <= delta)
				{
					ok = pos;
					delta = get_better(game, &pos, get_nearest);
				}
			}
		}
	}
	return (ok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
callq 0x2698
xorl %ebp, %ebp
pushq $-0x1
popq %r12
leaq -0x179(%rip), %r14      # 0x2358
movq %rsp, %r15
movl %r12d, %eax
incl %eax
movl %eax, (%rsp)
cmpl 0x8(%rbx), %eax
jge 0x2547
movl %r12d, %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl 0xc(%rbx), %eax
jge 0x2542
movq 0x10(%rbx), %rcx
movslq (%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cltq
movl (%rcx,%rax,4), %eax
decl %eax
cmpl $0x1, %eax
ja 0x253c
movl 0xc(%rsp), %eax
orl 0x8(%rsp), %eax
je 0x2523
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x23fb
cmpl %ebp, %eax
jg 0x253c
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x23fb
movl %eax, %ebp
movl 0x4(%rsp), %eax
jmp 0x24e4
movl (%rsp), %eax
jmp 0x24d7
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/libft/srcs/string/ft_strnequ.c
// Function: ft_strnequ
int	ft_strnequ(char const *s1, char const *s2, size_t n)
{
	if (!s1 && !s2)
		return (1);
	else if (!s1 || !s2)
		return (0);
	while ((*s1 || *s2) && n--)
	{
		if (ft_isalpha(*s1))
			ft_toupper(*s1);
		if (ft_isalpha(*s2))
			ft_toupper(*s2);
		if (*s1++ != *s2++)
			return (0);
	}
	return (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $0x1
popq %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x25df
movq %rsi, %r15
movq %rdi, %r12
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x25dd
movq %rdx, %r14
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
testl %edi, %edi
jne 0x259c
cmpb $0x0, (%r15,%r13)
je 0x25df
cmpq %r13, %r14
je 0x25df
callq 0x267c
testl %eax, %eax
je 0x25b4
movsbl (%r12,%r13), %edi
callq 0x266c
movsbl (%r15,%r13), %edi
callq 0x267c
testl %eax, %eax
je 0x25cc
movsbl (%r15,%r13), %edi
callq 0x266c
movb (%r12,%r13), %al
leaq 0x1(%r13), %rcx
cmpb (%r15,%r13), %al
movq %rcx, %r13
je 0x258c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/libft/srcs/string/ft_strstr.c
// Function: ft_strstr
char	*ft_strstr(const char *haystack, const char *needle)
{
	size_t		i;
	size_t		j;
	size_t		k;

	i = 0;
	j = 0;
	while (haystack[i])
	{
		j = 0;
		k = i;
		while (needle[j] == haystack[k] && needle[j])
		{
			j++;
			k++;
		}
		if (!needle[j])
			return ((char *)(haystack + i));
		i++;
	}
	return ((haystack[i] == needle[j]) ? ((char *)(haystack + i)) : NULL);
}

// Assembly:
leaq 0x1(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
movb (%rdi,%rax), %r8b
testb %r8b, %r8b
je 0x2623
xorl %edx, %edx
movb (%rsi,%rdx), %r9b
testb %r9b, %r9b
je 0x2616
cmpb %r8b, %r9b
jne 0x2616
movb (%rcx,%rdx), %r8b
incq %rdx
jmp 0x25ff
testb %r9b, %r9b
je 0x2631
incq %rax
incq %rcx
jmp 0x25f4
addq %rax, %rdi
xorl %eax, %eax
cmpb $0x0, (%rsi,%rdx)
cmoveq %rdi, %rax
retq
addq %rax, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/libft/srcs/conversion/ft_atoi.c
// Function: ft_atoi
int		ft_atoi(const char *str)
{
	int			nbr;
	size_t		i;

	nbr = 0;
	i = 0;
	while (*str == ' ' || (*str >= 9 && *str <= 13))
		str++;
	if (*str == '-' || *str == '+')
		i++;
	while (str[i] >= '0' && str[i] <= '9')
		nbr = nbr * 10 + str[i++] - '0';
	return (str[0] == '-' ? -nbr : nbr);
}

// Assembly:
movabsq $0x100003e00, %rax      # imm = 0x100003E00
movzbl (%rdi), %ecx
cmpq $0x20, %rcx
ja 0x2706
btq %rcx, %rax
jae 0x2706
incq %rdi
jmp 0x26f2
leal -0x2b(%rcx), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %rdi
xorl %edx, %edx
movzbl (%rdi), %eax
leal -0x30(%rax), %esi
cmpb $0x9, %sil
ja 0x272c
imull $0xa, %edx, %edx
addl %eax, %edx
addl $-0x30, %edx
incq %rdi
jmp 0x2713
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ffoissey[P]filler_42/libft/srcs/ft_printf/ft_dprintf.c
// Function: ft_dprintf
int			ft_dprintf(int fd, const char *format, ...)
{
	char	*out;
	int		len;
	va_list	args;
	t_flag	flag;

	flag.null = 0;
	if (!format || !*format)
		return (0);
	out = NULL;
	va_start(args, format);
	len = ft_loop_args((char *)format, &args, &out, &flag);
	va_end(args);
	ft_strdel(&flag.str);
	if (len != -1)
	{
		len = ft_strlen_null(out, flag.null);
		write(fd, out, len);
	}
	ft_strdel(&out);
	return (len);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdx, 0x90(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0xa8(%rsp)
testb %al, %al
je 0x2e87
movaps %xmm0, 0xb0(%rsp)
movaps %xmm1, 0xc0(%rsp)
movaps %xmm2, 0xd0(%rsp)
movaps %xmm3, 0xe0(%rsp)
movaps %xmm4, 0xf0(%rsp)
movaps %xmm5, 0x100(%rsp)
movaps %xmm6, 0x110(%rsp)
movaps %xmm7, 0x120(%rsp)
andl $0x0, 0x74(%rsp)
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x2f28
cmpb $0x0, (%rsi)
je 0x2f28
movl %edi, %ebx
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movabsq $0x3000000010, %rcx     # imm = 0x3000000010
leaq 0x10(%rsp), %rax
movq %rcx, (%rax)
leaq 0x150(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x80(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x30(%rsp), %r14
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x2968
movl %eax, %ebp
movq %r14, %rdi
callq 0x2650
cmpl $-0x1, %ebp
je 0x2f1a
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0x369c
movq %rax, %r14
movq 0x8(%rsp), %rsi
movslq %r14d, %rdx
movl %ebx, %edi
callq 0x1040
jmp 0x2f1e
pushq $-0x1
popq %r14
leaq 0x8(%rsp), %rdi
callq 0x2650
movl %r14d, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::create_gtrie()
void CmdLine::create_gtrie() {

  // Check motif size
  if (motif_size<MIN_MOTIF_SIZE || motif_size>MAX_MOTIF_SIZE)
    Error::msg("Invalid subgraph size (%d <= SIZE <= %d)", MIN_MOTIF_SIZE, MAX_MOTIF_SIZE);

  // Create the g-trie
  printf("Creating G-Trie\n");
  gt_original = new GTrie();
  Timer::start(0);
  gt_original->readSubgraphs(motif_size, dir, subgraphs_file);
  Timer::stop(0);
  printf("Creation time: %.2f\n", Timer::elapsed(0));
  printf("Nr %d-subgraphs in g-trie: %d\n", motif_size, gt_original->countGraphs()); 
  printf("Compression rate = %.2f%%\n\n", gt_original->compressionRate()*100);

  // Write g-trie to file
  gt_original->writeToFile(output_file);
  printf("G-Trie written to file \"%s\"\n", output_file);

  delete gt_original;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x16fae(%rip), %eax     # 0x19724
addl $-0x33, %eax
cmpl $-0x31, %eax
ja 0x2792
leaq 0xd8ab(%rip), %rdi      # 0x10030
pushq $0x3
popq %rsi
pushq $0x32
popq %rdx
xorl %eax, %eax
callq 0x7c64
leaq 0xe32d(%rip), %rdi      # 0x10ac6
callq 0x2340
pushq $0x8
popq %rdi
callq 0x2200
movq %rax, %rbx
movq %rax, %rdi
callq 0x9640
movq %rbx, 0x16fc0(%rip)     # 0x19778
xorl %edi, %edi
callq 0xaa6c
movq 0x16fb2(%rip), %rdi     # 0x19778
movl 0x16f58(%rip), %esi     # 0x19724
movzbl 0x16f4d(%rip), %edx     # 0x19720
leaq 0x16346(%rip), %rcx     # 0x18b20
callq 0x981c
xorl %edi, %edi
callq 0xaa8c
xorl %edi, %edi
callq 0xaaac
leaq 0xd865(%rip), %rdi      # 0x10059
movb $0x1, %al
callq 0x2060
movl 0x16f23(%rip), %ebx     # 0x19724
movq 0x16f70(%rip), %rdi     # 0x19778
callq 0x9b94
leaq 0xd85a(%rip), %rdi      # 0x1006e
movl %ebx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2060
movq 0x16f52(%rip), %rdi     # 0x19778
callq 0x99c4
mulsd 0xd7d5(%rip), %xmm0     # 0x10008
leaq 0xd853(%rip), %rdi      # 0x1008d
movb $0x1, %al
callq 0x2060
movq 0x16f30(%rip), %rdi     # 0x19778
leaq 0x166d1(%rip), %rbx     # 0x18f20
movq %rbx, %rsi
callq 0x9b9c
leaq 0xd84b(%rip), %rdi      # 0x100a9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2060
movq 0x16f09(%rip), %rbx     # 0x19778
testq %rbx, %rbx
je 0x287c
movq %rbx, %rdi
callq 0x9688
pushq $0x8
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2210
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x2210
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::run_subgraphs(Graph*, GraphTree*)
void CmdLine::run_subgraphs(Graph *g, GraphTree *sg) {
  printf("Creating G-Trie\n");
  gt_original = new GTrie();
  Timer::start(0);
  gt_original->readSubgraphs(motif_size, dir, subgraphs_file);
  Timer::stop(0);
  printf("Creation time: %.2f\n", Timer::elapsed(0));
  printf("Compression rate = %.2f%%\n\n", gt_original->compressionRate()*100);

  gt_original->census(g);
  gt_original->populateGraphTree(sg, motif_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe202(%rip), %rdi      # 0x10ac6
callq 0x2340
pushq $0x8
popq %rdi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
callq 0x9640
movq %r15, 0x16e95(%rip)     # 0x19778
xorl %edi, %edi
callq 0xaa6c
movq 0x16e87(%rip), %rdi     # 0x19778
movl 0x16e2d(%rip), %esi     # 0x19724
movzbl 0x16e22(%rip), %edx     # 0x19720
leaq 0x1621b(%rip), %rcx     # 0x18b20
callq 0x981c
xorl %edi, %edi
callq 0xaa8c
xorl %edi, %edi
callq 0xaaac
leaq 0xd73a(%rip), %rdi      # 0x10059
movb $0x1, %al
callq 0x2060
movq 0x16e4b(%rip), %rdi     # 0x19778
callq 0x99c4
mulsd 0xd6ce(%rip), %xmm0     # 0x10008
leaq 0xd74c(%rip), %rdi      # 0x1008d
movb $0x1, %al
callq 0x2060
movq 0x16e29(%rip), %rdi     # 0x19778
movq %r14, %rsi
callq 0x9a0e
movq 0x16e1a(%rip), %rdi     # 0x19778
movl 0x16dc0(%rip), %edx     # 0x19724
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9c5a
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::run_gtrie(Graph*, GraphTree*)
void CmdLine::run_gtrie(Graph *g, GraphTree *sg) {
  printf("Reading G-Trie\n");
  gt_original = new GTrie();
  Timer::start(0);
  gt_original->readFromFile(gtrie_file);
  Timer::stop(0);
  printf("Creation time: %.2f\n", Timer::elapsed(0));
  printf("Compression rate = %.2f%%\n\n", gt_original->compressionRate()*100);

  gt_original->census(g);
  gt_original->populateGraphTree(sg, motif_size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xe13c(%rip), %rdi      # 0x10ad6
callq 0x2340
pushq $0x8
popq %rdi
callq 0x2200
movq %rax, %r15
movq %rax, %rdi
callq 0x9640
movq %r15, 0x16dbf(%rip)     # 0x19778
xorl %edi, %edi
callq 0xaa6c
movq 0x16db1(%rip), %rdi     # 0x19778
leaq 0x15d52(%rip), %rsi     # 0x18720
callq 0x9bfc
xorl %edi, %edi
callq 0xaa8c
xorl %edi, %edi
callq 0xaaac
leaq 0xd671(%rip), %rdi      # 0x10059
movb $0x1, %al
callq 0x2060
movq 0x16d82(%rip), %rdi     # 0x19778
callq 0x99c4
mulsd 0xd605(%rip), %xmm0     # 0x10008
leaq 0xd683(%rip), %rdi      # 0x1008d
movb $0x1, %al
callq 0x2060
movq 0x16d60(%rip), %rdi     # 0x19778
movq %r14, %rsi
callq 0x9a0e
movq 0x16d51(%rip), %rdi     # 0x19778
movl 0x16cf7(%rip), %edx     # 0x19724
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9c5a
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::compare_results(void const*, void const*)
int CmdLine::compare_results(const void *a, const void *b) {
  ResultType *r1 = (ResultType *)a;
  ResultType *r2 = (ResultType *)b;

  if (r1->z_score > r2->z_score) return -1;
  if (r1->z_score < r2->z_score) return +1;
  if (r1->f_original > r2->f_original) return -1;
  if (r1->f_original < r2->f_original) return +1;
  return 0;
}

// Assembly:
movsd 0x20(%rdi), %xmm0
movsd 0x20(%rsi), %xmm1
pushq $-0x1
popq %rax
ucomisd %xmm1, %xmm0
jbe 0x2a64
retq
ucomisd %xmm0, %xmm1
jbe 0x2a6e
pushq $0x1
popq %rax
retq
movl 0x8(%rsi), %ecx
cmpl %ecx, 0x8(%rdi)
jg 0x2a63
setl %al
movzbl %al, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::prepare_files()
void CmdLine::prepare_files() {

  // Check output format
  if (output == NOOUTPUT)
    Error::msg("No valid output format specified");    

  if (!strcmp(output_file,  DEFAULT_RESULTS)) {
    if (output == TEXT) strcat(output_file, ".txt");
    else if (output == HTML) strcat(output_file, ".html");
  }

  f_output = fopen(output_file, "w");
  if (f_output==NULL)
    Error::msg("Unable to open output file \"%s\"", output_file);    

  if (occurrences) {
    f_occ = fopen(occ_file, "w");
    if (f_occ==NULL)
      Error::msg("Unable to open occurrences file \"%s\"", occ_file);
  }
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x16cca(%rip)     # 0x19750
jne 0x2a96
leaq 0xd637(%rip), %rdi      # 0x100c6
xorl %eax, %eax
callq 0x7c64
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
cmpq %rax, 0x16479(%rip)     # 0x18f20
jne 0x2af3
movl 0x16ca1(%rip), %eax     # 0x19750
cmpl $0x2, %eax
je 0x2ad6
cmpl $0x1, %eax
jne 0x2af3
leaq 0x16460(%rip), %rbx     # 0x18f20
movq %rbx, %rdi
callq 0x20e0
movl $0x7478742e, (%rax,%rbx) # imm = 0x7478742E
movb $0x0, 0x4(%rax,%rbx)
jmp 0x2af3
leaq 0x16443(%rip), %rbx     # 0x18f20
movq %rbx, %rdi
callq 0x20e0
movl $0x6d74682e, (%rax,%rbx) # imm = 0x6D74682E
movw $0x6c, 0x4(%rax,%rbx)
leaq 0x16426(%rip), %rdi     # 0x18f20
leaq 0xd5f1(%rip), %rsi      # 0x100f2
callq 0x2270
movq %rax, 0x16c53(%rip)     # 0x19760
testq %rax, %rax
jne 0x2b27
leaq 0xd5db(%rip), %rdi      # 0x100f4
leaq 0x16400(%rip), %rsi     # 0x18f20
xorl %eax, %eax
callq 0x7c64
cmpb $0x1, 0x16bf3(%rip)     # 0x19721
jne 0x2b4f
leaq 0x167e9(%rip), %rdi     # 0x19320
leaq 0xd5b4(%rip), %rsi      # 0x100f2
callq 0x2270
movq %rax, 0x16c1e(%rip)     # 0x19768
testq %rax, %rax
je 0x2b51
popq %rbx
retq
leaq 0xd5bc(%rip), %rdi      # 0x10114
leaq 0x167c1(%rip), %rsi     # 0x19320
xorl %eax, %eax
popq %rbx
jmp 0x7c64
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::compute_original()
void CmdLine::compute_original() {

  // Print method description
  if (method == ESU)
    printf("Method:     ESU on original network\n");
  else if (method == GTRIE)
    printf("Method:     GTRIE with file containing complete g-trie\n");
  else if (method == SUBGRAPHS)
    printf("Method:     GTRIE with subgraphs read from file\n");

  // Compute frequency
  Global::show_occ = occurrences;
  Global::occ_file = f_occ;
  puts("\nCounting subgraph frequency on 'ORIGINAL NETWORK'");
  Timer::start(0);
  if (method == ESU) run_esu(g, &sg_original);
  else if (method == SUBGRAPHS) run_subgraphs(g, &sg_original);
  else if (method == GTRIE) run_gtrie(g, &sg_original);
  Timer::stop(0);  
  printf("%d subgraphs, ",   sg_original.countGraphs());
  printf("%.0f occurrences\n", sg_original.countOccurrences());
  printf("Time elapsed: %.6fs\n\n", Timer::elapsed(0));
  Global::show_occ = false;

  time_original = Timer::elapsed(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x16a4c(%rip), %eax     # 0x19748
decl %eax
cmpl $0x2, %eax
ja 0x2d18
movl %eax, %eax
leaq 0xde68(%rip), %rcx      # 0x10b74
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x2340
movb 0x16a03(%rip), %al      # 0x19721
leaq 0x26ddc(%rip), %r14     # 0x29b01
movb %al, (%r14)
movq 0x16a39(%rip), %rax     # 0x19768
leaq 0x26dd2(%rip), %rcx     # 0x29b08
movq %rax, (%rcx)
leaq 0xd48c(%rip), %rdi      # 0x101cc
callq 0x2340
xorl %edi, %edi
callq 0xaa6c
movl 0x169f6(%rip), %eax     # 0x19748
cmpl $0x3, %eax
je 0x2d8b
cmpl $0x2, %eax
je 0x2d76
cmpl $0x1, %eax
jne 0x2d9e
movq 0x169f0(%rip), %rdi     # 0x19758
leaq 0x16a11(%rip), %rsi     # 0x19780
callq 0x28a4
jmp 0x2d9e
movq 0x169db(%rip), %rdi     # 0x19758
leaq 0x169fc(%rip), %rsi     # 0x19780
callq 0x2988
jmp 0x2d9e
movq 0x169c6(%rip), %rdi     # 0x19758
leaq 0x169e7(%rip), %rsi     # 0x19780
callq 0x28b2
xorl %edi, %edi
callq 0xaa8c
leaq 0x169d4(%rip), %rbx     # 0x19780
movq %rbx, %rdi
callq 0xb5da
leaq 0xd444(%rip), %rdi      # 0x101ff
movl %eax, %esi
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
callq 0xb5d2
leaq 0xd43b(%rip), %rdi      # 0x1020e
movb $0x1, %al
callq 0x2060
xorl %edi, %edi
callq 0xaaac
leaq 0xd438(%rip), %rdi      # 0x10220
movb $0x1, %al
callq 0x2060
movb $0x0, (%r14)
xorl %edi, %edi
callq 0xaaac
movsd %xmm0, 0x16936(%rip)    # 0x19738
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::decide_action()
void CmdLine::decide_action() {

  t_start = time(0);

  if (create) {
    create_gtrie();
  } else {
      // Check method
      if (method == NOMETHOD)
	Error::msg("No valid method specified");    
      
      prepare_graph();
      prepare_files();
      compute_original();
      compute_results();
  }

}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x21d0
movq %rax, 0x15df9(%rip)     # 0x19788
cmpb $0x1, 0x15d8c(%rip)     # 0x19722
jne 0x399e
popq %rax
jmp 0x276c
cmpl $0x0, 0x15da3(%rip)     # 0x19748
jne 0x39b5
leaq 0xd029(%rip), %rdi      # 0x109d7
xorl %eax, %eax
callq 0x7c64
callq 0x2b68
callq 0x2a7e
callq 0x2cf2
popq %rax
jmp 0x2e0a
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::init(int, char**)
void CmdLine::init(int argc, char **argv) {
  about();
  defaults();
  parse_cmdargs(argc, argv);
  Isomorphism::initNauty(motif_size, dir);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x39fe
callq 0x3a34
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3acc
movl 0x15d38(%rip), %edi     # 0x19724
movzbl 0x15d2d(%rip), %esi     # 0x19720
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x68d0
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::defaults()
void CmdLine::defaults() {

  strcpy(graph_file, INVALID_FILE);
  dir        = false;
  motif_size = -1;

  method = ESU;

  strcpy(output_file, DEFAULT_RESULTS);
  strcpy(occ_file, DEFAULT_OCC);

  random_number    = 0;
  random_seed      = time(0);
  random_exchanges = 3;
  random_tries     = 10;

  create = false;
  format = SIMPLE_WEIGHT;
  output = TEXT;
  occurrences = false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movabsq $0x5f5f4c4c554e5f5f, %rax # imm = 0x5F5F4C4C554E5F5F
movq %rax, 0x148d8(%rip)     # 0x18320
xorl %ebx, %ebx
movb %bl, 0x148d8(%rip)      # 0x18328
movb %bl, 0x15cca(%rip)      # 0x19720
orl $-0x1, 0x15cc7(%rip)    # 0x19724
pushq $0x1
popq %rbp
movl %ebp, 0x15ce2(%rip)     # 0x19748
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
movq %rax, 0x154a9(%rip)     # 0x18f20
movl $0x63636f, 0x1589f(%rip) # imm = 0x63636F
andl $0x0, 0x15ca0(%rip)     # 0x19728
xorl %edi, %edi
callq 0x21d0
movl %eax, 0x15c97(%rip)     # 0x1972c
movl $0x3, 0x15c91(%rip)     # 0x19730
movl $0xa, 0x15c8b(%rip)     # 0x19734
movb %bl, 0x15c73(%rip)      # 0x19722
movl $0x2, 0x15c93(%rip)     # 0x1974c
movl %ebp, 0x15c91(%rip)     # 0x19750
movb %bl, 0x15c5c(%rip)      # 0x19721
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::finish()
void CmdLine::finish() { 
  if (!create) {
    fclose(f_output);
    if (occurrences) fclose(f_occ);
  }
  Isomorphism::finishNauty();
}

// Assembly:
cmpb $0x0, 0x157a1(%rip)     # 0x19722
jne 0x6918
pushq %rax
movq 0x157d1(%rip), %rdi     # 0x19760
callq 0x21f0
cmpb $0x1, 0x15786(%rip)     # 0x19721
jne 0x3fa9
movq 0x157c4(%rip), %rdi     # 0x19768
callq 0x21f0
addq $0x8, %rsp
jmp 0x6918
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/CmdLine.cpp
// Function: CmdLine::str_to_method(char*)
MethodType CmdLine::str_to_method(char *s) {
  if      (!strcmp(s, "esu"))       return ESU;
  else if (!strcmp(s, "gtrie"))     return GTRIE;
  else if (!strcmp(s, "subgraphs")) return SUBGRAPHS;
  else return NOMETHOD;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xca49(%rip), %rsi      # 0x10a06
callq 0x2300
testl %eax, %eax
je 0x3ff4
leaq 0xca3d(%rip), %rsi      # 0x10a0a
movq %rbx, %rdi
callq 0x2300
testl %eax, %eax
je 0x3ff8
leaq 0xca30(%rip), %rsi      # 0x10a10
movq %rbx, %rdi
callq 0x2300
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x3ffb
pushq $0x1
jmp 0x3ffa
pushq $0x2
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::_delete()
void GraphMatrix::_delete() {
  int i;

  if (_adjM!=NULL) {
    for (i=0; i<_num_nodes; i++)
      if (_adjM[i]!=NULL) delete[] _adjM[i];
    delete[] _adjM;
  }
  if (_adjIn!=NULL) delete[] _adjIn;
  if (_adjOut!=NULL) delete[] _adjOut;
  if (_neighbours!=NULL) delete[] _neighbours;

  if (_in!=NULL) delete[] _in;
  if (_out!=NULL) delete[] _out;
  if (_out!=NULL) delete[] _num_neighbours;

  if (_array_neighbours!=NULL) {
    for (i=0; i<_num_nodes; i++)
      if (_array_neighbours[i]!=NULL) delete[] _array_neighbours[i];
    delete[] _array_neighbours;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x4586
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
movq 0x30(%rbx), %rdi
cmpq %rax, %r14
jge 0x457c
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4577
callq 0x22b0
incq %r14
jmp 0x455c
testq %rdi, %rdi
je 0x4586
callq 0x22b0
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0x45c3
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x45b3
addq $-0x18, %r15
imulq $0x18, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0x4d62
addq $-0x18, %r13
jne 0x45a4
imulq $0x18, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2430
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x4600
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x45f0
addq $-0x18, %r15
imulq $0x18, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0x4d62
addq $-0x18, %r13
jne 0x45e1
imulq $0x18, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2430
movq 0x50(%rbx), %r15
testq %r15, %r15
je 0x463d
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x462d
addq $-0x18, %r15
imulq $0x18, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0x4d62
addq $-0x18, %r13
jne 0x461e
imulq $0x18, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x2430
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x464b
callq 0x22b0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x466e
callq 0x22b0
cmpq $0x0, 0x20(%rbx)
je 0x466e
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x466e
callq 0x22b0
cmpq $0x0, 0x38(%rbx)
je 0x46ab
xorl %r14d, %r14d
movslq 0xc(%rbx), %rax
movq 0x38(%rbx), %rdi
cmpq %rax, %r14
jge 0x4698
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4693
callq 0x22b0
incq %r14
jmp 0x4678
testq %rdi, %rdi
je 0x46ab
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x22b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::zero()
void GraphMatrix::zero() {
  int i,j;
  _num_edges = 0;

  for (i=0; i<_num_nodes;i++) {
    _in[i] = 0;
    _out[i] = 0;
    _num_neighbours[i] = 0;
    _adjIn[i].clear();
    _adjOut[i].clear();
    _neighbours[i].clear();
    for (j=0; j<_num_nodes;j++)
      _adjM[i][j]=false;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andl $0x0, 0x10(%rdi)
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
movq 0x48(%rdi), %rsi
movq 0x40(%rdi), %r8
movq 0x50(%rdi), %r9
movl 0xc(%rdi), %r11d
xorl %r10d, %r10d
movslq %r11d, %r11
cmpq %r11, %r10
jge 0x476f
andl $0x0, (%rax,%r10,4)
andl $0x0, (%rcx,%r10,4)
andl $0x0, (%rdx,%r10,4)
imulq $0x18, %r10, %r11
movq (%rsi,%r11), %rbx
cmpq %rbx, 0x8(%rsi,%r11)
je 0x4724
leaq (%rsi,%r11), %r14
movq %rbx, 0x8(%r14)
movq (%r8,%r11), %rbx
cmpq %rbx, 0x8(%r8,%r11)
je 0x4737
leaq (%r8,%r11), %r14
movq %rbx, 0x8(%r14)
movq (%r9,%r11), %rbx
cmpq %rbx, 0x8(%r9,%r11)
je 0x4749
addq %r9, %r11
movq %rbx, 0x8(%r11)
movl 0xc(%rdi), %r11d
movq 0x30(%rdi), %rbx
movslq %r11d, %r14
xorl %r15d, %r15d
cmpq %r14, %r15
jge 0x476a
movq (%rbx,%r10,8), %r12
movb $0x0, (%r12,%r15)
incq %r15
jmp 0x4757
incq %r10
jmp 0x46f6
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::createGraph(int, GraphType)
void GraphMatrix::createGraph(int n, GraphType t) {
  int i;

  _num_nodes = n;
  _type = t;

  _delete();

  _adjM = new bool*[n];  
  for (i=0; i<n; i++) _adjM[i] = new bool[n];
  _adjIn      = new vector<int>[n];
  _adjOut     = new vector<int>[n];
  _neighbours = new vector<int>[n];

  _in             = new int[n]; 
  _out            = new int[n];
  _num_neighbours = new int[n];

  zero();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rdi)
movl %edx, 0x8(%rdi)
callq 0x4546
movslq %ebp, %r14
leaq (,%r14,8), %rdi
xorl %r15d, %r15d
testl %r14d, %r14d
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
movl $0x0, %r12d
cmovgl %r14d, %r12d
callq 0x2030
movq %rax, 0x30(%rbx)
cmpq %r15, %r12
je 0x47d9
movq %r14, %rdi
callq 0x2030
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x47bf
pushq $0x18
popq %rbp
movq %r14, %rax
mulq %rbp
movq %rax, %r15
seto %al
movq %r15, %r12
addq $0x8, %r12
cmovbq %r13, %r12
testb %al, %al
cmovneq %r13, %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r13
movq %r14, (%rax)
addq $0x8, %r13
testl %r14d, %r14d
je 0x4830
leaq -0x18(%r15), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbp
subq %rdx, %rcx
addq $0x18, %rcx
movq %r13, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x2130
movq %r13, 0x48(%rbx)
movq %r12, %rdi
callq 0x2030
leaq 0x8(%rax), %r13
movq %r14, (%rax)
testl %r14d, %r14d
je 0x4868
leaq -0x18(%r15), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rbp
subq %rdx, %rcx
addq $0x18, %rcx
movq %r13, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x2130
movq %r13, 0x40(%rbx)
movq %r12, %rdi
callq 0x2030
leaq 0x8(%rax), %r12
movq %r14, (%rax)
testl %r14d, %r14d
je 0x48a0
addq $-0x18, %r15
movq %r15, %rax
xorl %edx, %edx
divq %rbp
subq %rdx, %r15
addq $0x18, %r15
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2130
leaq (,%r14,4), %r15
testl %r14d, %r14d
movq %r12, 0x50(%rbx)
pushq $-0x1
popq %rax
cmovsq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x28(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x28(%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/ComplexNetworks-DCC-FCUP[P]gtrieScanner/GraphMatrix.cpp
// Function: GraphMatrix::addEdge(int, int)
void GraphMatrix::addEdge(int a, int b) {

  if (_adjM[a][b]) return;

  _adjM[a][b] = true;

  _adjOut[a].push_back(b);
  _out[a]++;

  _adjIn[b].push_back(a);
  _in[b]++;

  _num_edges++;

  if (!_adjM[b][a]) {
    _neighbours[a].push_back(b);
    _num_neighbours[a]++;
    _neighbours[b].push_back(a);
    _num_neighbours[b]++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x30(%rdi), %rax
movslq %esi, %r15
movq (%rax,%r15,8), %rax
movslq %edx, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x49b6
movq %rdi, %rbx
movb $0x1, (%rax,%rcx)
imulq $0x18, %r15, %rdi
addq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4c68
movq 0x20(%rbx), %rax
incl (%rax,%r15,4)
movslq (%r14), %rax
imulq $0x18, %rax, %rdi
addq 0x48(%rbx), %rdi
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x4c68
movq 0x18(%rbx), %rax
movslq (%r14), %rcx
incl (%rax,%rcx,4)
incl 0x10(%rbx)
movq 0x30(%rbx), %rax
movslq (%r14), %rcx
movq (%rax,%rcx,8), %rcx
movslq (%r15), %rax
cmpb $0x0, (%rcx,%rax)
jne 0x49b6
imulq $0x18, %rax, %rdi
addq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4c68
movq 0x28(%rbx), %rax
leaq 0xc(%rsp), %rsi
movslq (%rsi), %rcx
incl (%rax,%rcx,4)
movslq (%r14), %rax
imulq $0x18, %rax, %rdi
addq 0x50(%rbx), %rdi
callq 0x4c68
movq 0x28(%rbx), %rax
movslq (%r14), %rcx
incl (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq