LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/strategy.c
// Function: angle_target_mode
unsigned char	angle_target_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)
		{
			if (delta(&game->contact, &game->angle_target)
					<= delta(&game->good_contact, &game->angle_target))
				return (TRUE);
		}
		else
		{
			if (delta(&game->contact, &game->angle_target)
					< delta(&game->good_contact, &game->angle_target))
				return (TRUE);
		}
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x24c5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x24c5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x1, %eax
je 0x2410
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2419
movb $0x1, -0x1(%rbp)
jmp 0x24c9
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x247f
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x2250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x247d
movb $0x1, -0x1(%rbp)
jmp 0x24c9
jmp 0x24c3
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x2250
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x24c1
movb $0x1, -0x1(%rbp)
jmp 0x24c9
jmp 0x24c3
jmp 0x24c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x2645
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x2645
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x1, %eax
je 0x2580
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2589
movb $0x1, -0x1(%rbp)
jmp 0x2649
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jle 0x25bb
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jle 0x25ff
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x2250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x25fd
movb $0x1, -0x1(%rbp)
jmp 0x2649
jmp 0x2643
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x2250
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2641
movb $0x1, -0x1(%rbp)
jmp 0x2649
jmp 0x2643
jmp 0x2645
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x27d1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8c, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x0, %eax
jne 0x27d1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x1, %eax
je 0x2700
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x94, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2709
movb $0x1, -0x1(%rbp)
jmp 0x27d5
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jle 0x273b
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x58(%rcx), %eax
jle 0x2785
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq 0x2250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x2783
movb $0x1, -0x1(%rbp)
jmp 0x27d5
jmp 0x27cf
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq 0x2250
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x27cd
movb $0x1, -0x1(%rbp)
jmp 0x27d5
jmp 0x27cf
jmp 0x27d1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jle 0x2852
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x2250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x2850
movb $0x1, -0x1(%rbp)
jmp 0x289a
jmp 0x2896
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x2250
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2894
movb $0x1, -0x1(%rbp)
jmp 0x289a
jmp 0x2896
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jle 0x2922
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x2250
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0x2920
movb $0x1, -0x1(%rbp)
jmp 0x296a
jmp 0x2966
movq -0x10(%rbp), %rdi
addq $0x8c, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x2250
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x94, %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2964
movb $0x1, -0x1(%rbp)
jmp 0x296a
jmp 0x2966
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/select_strategy.c
// Function: print_strategy
void			print_strategy(t_game *game)
{
	if (game->mode == E_ANGLE_TARGET)
		ft_dprintf(2, "\033[34mAngle TARGET\033[0m\n");
	else if (game->mode == E_ANGLE_OPMINE)
		ft_dprintf(2, "\033[35mAngle OPMINE\033[0m\n");
	else if (game->mode == E_ANGLE_OPADV)
		ft_dprintf(2, "\033[36mAngle OPADV\033[0m\n");
	else if (game->mode == E_ATTACK)
		ft_dprintf(2, "\033[31mAttack\033[0m\n");
	else if (game->mode == E_GLUE)
		ft_dprintf(2, "\033[37mGlue\033[0m\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x29ae
movl $0x2, %edi
leaq 0x869d(%rip), %rsi      # 0xb03f
movb $0x0, %al
callq 0x4600
jmp 0x2a30
movq -0x8(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0x29cd
movl $0x2, %edi
leaq 0x8692(%rip), %rsi      # 0xb056
movb $0x0, %al
callq 0x4600
jmp 0x2a2e
movq -0x8(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0x29ec
movl $0x2, %edi
leaq 0x868a(%rip), %rsi      # 0xb06d
movb $0x0, %al
callq 0x4600
jmp 0x2a2c
movq -0x8(%rbp), %rax
cmpl $0x3, 0x2c(%rax)
jne 0x2a0b
movl $0x2, %edi
leaq 0x8681(%rip), %rsi      # 0xb083
movb $0x0, %al
callq 0x4600
jmp 0x2a2a
movq -0x8(%rbp), %rax
cmpl $0x4, 0x2c(%rax)
jne 0x2a28
movl $0x2, %edi
leaq 0x8673(%rip), %rsi      # 0xb094
movb $0x0, %al
callq 0x4600
jmp 0x2a2a
jmp 0x2a2c
jmp 0x2a2e
jmp 0x2a30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x88(%rax)
jne 0x2a62
movb $0x0, -0x1(%rbp)
jmp 0x2bdb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
jne 0x2ad9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2ad9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2ad9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
xorl %edx, %edx
movl $0x6, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2ad9
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x2bd7
movq -0x10(%rbp), %rax
cmpl $0x1, 0x88(%rax)
jne 0x2b50
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2b50
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2b50
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
xorl %edx, %edx
movl $0x3, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2b50
movq -0x10(%rbp), %rax
movl $0x1, 0x2c(%rax)
jmp 0x2bd5
movq -0x10(%rbp), %rax
cmpl $0x2, 0x88(%rax)
jne 0x2bcd
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2bcd
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x2e10
cmpl $0x0, %eax
jne 0x2bcd
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x80, %rsi
xorl %edx, %edx
movl $0x6, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2bcd
movq -0x10(%rbp), %rax
movl $0x2, 0x2c(%rax)
jmp 0x2bd3
movb $0x0, -0x1(%rbp)
jmp 0x2bdb
jmp 0x2bd5
jmp 0x2bd7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
movl $0x3, %ecx
movl %ecx, %edx
callq 0x2e10
cmpl $0x1, %eax
je 0x2c4f
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
callq 0x2250
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
addq $0x48, %rsi
callq 0x2250
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jge 0x2c8f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
cmpl $0x1f4, %eax            # imm = 0x1F4
jle 0x2c8f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x38, %rsi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x2c8f
movq -0x8(%rbp), %rax
movl $0x4, 0x2c(%rax)
jmp 0x2cad
movq -0x8(%rbp), %rdi
callq 0x2a40
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2cab
movq -0x8(%rbp), %rax
movl $0x3, 0x2c(%rax)
jmp 0x2cad
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x18(%rbp), %eax
cmpl $0x0, %eax
jge 0x2cee
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x2cfa
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x2d1e
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x2d2a
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x2d4f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x2d5c
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2dd6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
cmpl $0x0, %eax
jge 0x2d80
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2d8d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x2dcb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x2dc0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2d93
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2d62
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl -0x18(%rbp), %eax
imull -0x18(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x40(%rbp), %edx
addl %eax, %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovgl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl -0x20(%rbp), %eax
cmpl $0x0, %eax
jge 0x2e37
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x2e43
movq -0x18(%rbp), %rax
movl (%rax), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x2e67
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x2e73
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0x2e98
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0x2ea5
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x2f1f
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x20(%rbp), %eax
cmpl $0x0, %eax
jge 0x2ec9
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x2ed6
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x2f14
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2f09
movl $0x1, -0x4(%rbp)
jmp 0x2f26
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2edc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2eab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
callq 0x3070
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x58, %rsi
callq 0x3070
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x70(%rax)
jne 0x2fad
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fb4
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2fb4
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x74(%rax)
jne 0x2fd7
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2fde
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x2fde
movl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x300f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3016
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x3016
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x3039
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3040
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x3040
movl -0x38(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x80(%rax)
movq -0x8(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x84(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x3910
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2250
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2250
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x30d8
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x30e0
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2250
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2250
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x3138
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3140
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2250
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2250
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x3170
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3178
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0xc(%rcx), %eax
cmpl $0x1f4, %eax            # imm = 0x1F4
jge 0x325f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x78, %rsi
leaq 0x1b7(%rip), %rdx       # 0x3380
callq 0x33f0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x80, %rsi
leaq 0x199(%rip), %rdx       # 0x3380
callq 0x33f0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
leaq 0x17e(%rip), %rdx       # 0x3380
callq 0x33f0
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x322a
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x322a
movq -0x8(%rbp), %rax
movl $0x1, 0x88(%rax)
jmp 0x325a
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x324a
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x324a
movq -0x8(%rbp), %rax
movl $0x2, 0x88(%rax)
jmp 0x3258
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x325a
jmp 0x32df
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %edx
movl $0x3, %eax
movl $0x2, %ecx
cmpl $0x1e, %edx
cmovll %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1e, 0xa4(%rax)
jle 0x32ac
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %eax
cltd
idivl -0x18(%rbp)
cmpl $0x0, %edx
jne 0x32ac
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x32df
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %eax
cltd
idivl -0x18(%rbp)
cmpl $0x1, %edx
jne 0x32cf
movq -0x8(%rbp), %rax
movl $0x1, 0x88(%rax)
jmp 0x32dd
movq -0x8(%rbp), %rax
movl $0x2, 0x88(%rax)
jmp 0x32df
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x331b
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x3341
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2250
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2250
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jg 0x3363
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x2cc0
cmpl $0x1, %eax
jne 0x3363
movl $0x1, -0x4(%rbp)
jmp 0x336a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x3910
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x34bf
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x34ba
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
je 0x3483
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x4, (%rax,%rcx,4)
jne 0x34b8
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq *%rax
cmpl $0x1, %eax
jne 0x34b6
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2250
movl %eax, -0x2c(%rbp)
jmp 0x34b8
jmp 0x343d
jmp 0x3420
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3910
movl $0x0, -0x1c(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x35ab
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x35a6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0x355b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x35a1
cmpl $0x0, -0x8(%rbp)
jne 0x3567
cmpl $0x0, -0x4(%rbp)
je 0x3580
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x286(%rip), %rdx      # 0x32f0
callq 0x33f0
cmpl -0x1c(%rbp), %eax
jg 0x359f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x2a7(%rip), %rdx      # 0x32f0
callq 0x33f0
movl %eax, -0x1c(%rbp)
jmp 0x35a1
jmp 0x3515
jmp 0x34f8
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x35ee
cmpq $0x0, -0x18(%rbp)
jne 0x35ee
movl $0x1, -0x4(%rbp)
jmp 0x36c2
cmpq $0x0, -0x10(%rbp)
je 0x35fc
cmpq $0x0, -0x18(%rbp)
jne 0x3608
movl $0x0, -0x4(%rbp)
jmp 0x36c2
jmp 0x360a
jmp 0x360c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3629
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x3642
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x364b
jmp 0x36bb
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x38a0
cmpl $0x0, %eax
je 0x3668
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x3870
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x38a0
cmpl $0x0, %eax
je 0x3685
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3870
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x36b6
movl $0x0, -0x4(%rbp)
jmp 0x36c2
jmp 0x360c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3794
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdx
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x3744
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x374d
jmp 0x3767
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x370e
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x3783
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37ce
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x36ec
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x37be
movq -0x10(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x37c6
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x37c6
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/libft/srcs/memory/ft_bzero.c
// Function: ft_bzero
void	ft_bzero(void *s, size_t n)
{
	unsigned char	*ptr_tmp;

	ptr_tmp = (unsigned char *)s;
	while (n-- > 0)
		*ptr_tmp++ = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
jbe 0x394d
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
jmp 0x3924
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x19(%rbp)
je 0x39ff
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x1a(%rbp)
jl 0x39f9
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
setle %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3a08
jmp 0x3a16
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x39c7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3a2e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x3a3a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3a3c
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x1b(%rbp)
jl 0x3a67
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0x3a70
jmp 0x3a95
imull $0xa, -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a3c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3aab
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3ab1
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/libft/srcs/get_next_line/get_next_line.c
// Function: get_next_line
int				get_next_line(const int fd, char **line)
{
	static	t_file	file;

	if (fd < 0 || !line)
		return (FAILURE);
	ft_fill_line_with_rest(&file);
	if (file.state != 1 && ft_read(&file) == FAILURE)
		return (FAILURE);
	if (file.cur != NULL)
	{
		*line = ft_strdup(file.cur);
		ft_strdel(&file.cur);
	}
	return ((*line == NULL && file.state != 0) ? FAILURE : file.state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x3adc
cmpq $0x0, -0x10(%rbp)
jne 0x3ae8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b73
leaq 0xb5d1(%rip), %rdi      # 0xf0c0
callq 0x3b80
cmpl $0x1, 0xb5c9(%rip)      # 0xf0c4
je 0x3b17
leaq 0xb5bc(%rip), %rdi      # 0xf0c0
callq 0x3cb0
cmpl $-0x1, %eax
jne 0x3b17
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b73
cmpq $0x0, 0xb5b1(%rip)      # 0xf0d0
je 0x3b47
movq 0xb5a8(%rip), %rdi      # 0xf0d0
callq 0x9d00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
leaq 0xb582(%rip), %rdi      # 0xf0c0
addq $0x10, %rdi
callq 0x3830
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3b64
cmpl $0x0, 0xb56c(%rip)      # 0xf0c4
je 0x3b64
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x3b6d
movl 0xb55a(%rip), %eax      # 0xf0c4
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
testb %al, %al
je 0x4647
movaps %xmm0, -0x110(%rbp)
movaps %xmm1, -0x100(%rbp)
movaps %xmm2, -0xf0(%rbp)
movaps %xmm3, -0xe0(%rbp)
movaps %xmm4, -0xd0(%rbp)
movaps %xmm5, -0xc0(%rbp)
movaps %xmm6, -0xb0(%rbp)
movaps %xmm7, -0xa0(%rbp)
movq %r9, -0x118(%rbp)
movq %r8, -0x120(%rbp)
movq %rcx, -0x128(%rbp)
movq %rdx, -0x130(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4681
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x468d
movl $0x0, -0x4(%rbp)
jmp 0x4718
movq $0x0, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x140(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x3e20
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x90(%rbp), %rdi
callq 0x3830
cmpl $-0x1, -0x1c(%rbp)
je 0x4709
movq -0x18(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x5850
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1040
leaq -0x18(%rbp), %rdi
callq 0x3830
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpl $0x3, 0x297d5(%rip)     # 0x2d194
jl 0x39ca
cmpl $0x32, 0x297cc(%rip)    # 0x2d194
jle 0x39e2
leaq 0x1c63f(%rip), %rdi     # 0x20010
movl $0x3, %esi
movl $0x32, %edx
movb $0x0, %al
callq 0xfb80
leaq 0x1c650(%rip), %rdi     # 0x20039
xorl %eax, %eax
callq 0x3060
movl $0x8, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x13610
jmp 0x3a0b
movq -0x18(%rbp), %rax
movq %rax, 0x297d2(%rip)     # 0x2d1e8
xorl %edi, %edi
callq 0x18b40
movq 0x297c4(%rip), %rdi     # 0x2d1e8
movl 0x2976a(%rip), %esi     # 0x2d194
movb 0x29760(%rip), %al      # 0x2d190
leaq 0x28b59(%rip), %rcx     # 0x2c590
andb $0x1, %al
movzbl %al, %edx
callq 0x13980
xorl %edi, %edi
callq 0x18b80
xorl %edi, %edi
callq 0x18bc0
leaq 0x1c5f4(%rip), %rdi     # 0x2004a
movb $0x1, %al
callq 0x3060
movl 0x29731(%rip), %eax     # 0x2d194
movl %eax, -0x24(%rbp)
movq 0x2977b(%rip), %rdi     # 0x2d1e8
callq 0x13fa0
movl -0x24(%rbp), %esi
movl %eax, %edx
leaq 0x1c5e1(%rip), %rdi     # 0x2005f
movb $0x0, %al
callq 0x3060
movq 0x2975c(%rip), %rdi     # 0x2d1e8
callq 0x13c20
movsd 0x1c56f(%rip), %xmm1    # 0x20008
mulsd %xmm1, %xmm0
leaq 0x1c5da(%rip), %rdi     # 0x2007e
movb $0x1, %al
callq 0x3060
movq 0x29736(%rip), %rdi     # 0x2d1e8
leaq 0x28ed7(%rip), %rsi     # 0x2c990
callq 0x13fc0
leaq 0x1c5d5(%rip), %rdi     # 0x2009a
leaq 0x28ec4(%rip), %rsi     # 0x2c990
movb $0x0, %al
callq 0x3060
movq 0x2970e(%rip), %rax     # 0x2d1e8
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3afb
movq -0x20(%rbp), %rdi
callq 0x13690
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x3280
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0x8, %esi
callq 0x3280
movq -0x8(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1c4c2(%rip), %rdi     # 0x20039
xorl %eax, %eax
callq 0x3060
movl $0x8, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x13610
jmp 0x3b99
movq -0x28(%rbp), %rax
movq %rax, 0x29644(%rip)     # 0x2d1e8
xorl %edi, %edi
callq 0x18b40
movq 0x29636(%rip), %rdi     # 0x2d1e8
movl 0x295dc(%rip), %esi     # 0x2d194
movb 0x295d2(%rip), %al      # 0x2d190
leaq 0x289cb(%rip), %rcx     # 0x2c590
andb $0x1, %al
movzbl %al, %edx
callq 0x13980
xorl %edi, %edi
callq 0x18b80
xorl %edi, %edi
callq 0x18bc0
leaq 0x1c466(%rip), %rdi     # 0x2004a
movb $0x1, %al
callq 0x3060
movq 0x295f6(%rip), %rdi     # 0x2d1e8
callq 0x13c20
movsd 0x1c409(%rip), %xmm1    # 0x20008
mulsd %xmm1, %xmm0
leaq 0x1c474(%rip), %rdi     # 0x2007e
movb $0x1, %al
callq 0x3060
movq 0x295d0(%rip), %rdi     # 0x2d1e8
movq -0x8(%rbp), %rsi
callq 0x13cc0
movq 0x295c0(%rip), %rdi     # 0x2d1e8
movq -0x10(%rbp), %rsi
movl 0x29562(%rip), %edx     # 0x2d194
callq 0x140d0
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x3280
movq -0x18(%rbp), %rdi
callq 0x3440