LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
movq %r14, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x216c
testl %eax, %eax
jne 0x1deb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
testl %eax, %eax
je 0x1dfa
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x94(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x216c
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1ded
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
cmpl $0x1, %eax
je 0x1ded
movl 0x8(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, 0x40(%rbx)
jle 0x1e51
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1e7c
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2a
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a
cmpl %eax, %r14d
jg 0x1deb
jmp 0x1ded
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2a
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a
cmpl %eax, %r14d
jge 0x1deb
jmp 0x1ded
// File: /workspace/github_c_makefile_star2_O1/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), %ebp
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addq $0x8c, %rdi
leaq 0x38(%r14), %r15
movq %r15, %rsi
callq 0x1b2a
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b2a
movl %eax, %ecx
movb $0x1, %al
cmpl %r12d, %ebp
jle 0x1efb
cmpl %ecx, %ebx
jg 0x1eff
jmp 0x1f01
cmpl %ecx, %ebx
jl 0x1f01
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %ebp
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addq $0x8c, %rdi
movq %r15, %rsi
callq 0x1b2a
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b2a
movl %eax, %ecx
movb $0x1, %al
cmpl %r12d, %ebp
jle 0x1f5e
cmpl %ecx, %ebx
jg 0x1f62
jmp 0x1f64
cmpl %ecx, %ebx
jl 0x1f64
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x20a3
movq %rdi, %rbx
testl %eax, %eax
jne 0x2005
leaq 0x60(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2208
testl %eax, %eax
jne 0x2005
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x2208
testl %eax, %eax
jne 0x2005
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x6, %ecx
callq 0x216c
cmpl $0x1, %eax
je 0x20d1
cmpl $0x1, 0x88(%rbx)
jne 0x2061
leaq 0x78(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2208
testl %eax, %eax
jne 0x2061
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x2208
testl %eax, %eax
jne 0x2061
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x3, %ecx
callq 0x216c
cmpl $0x1, %eax
je 0x20d1
cmpl $0x2, 0x88(%rbx)
jne 0x20a3
leaq 0x80(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x2208
testl %eax, %eax
jne 0x20a3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x2208
testl %eax, %eax
je 0x20b2
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x6, %ecx
callq 0x216c
movl $0x2, %r15d
cmpl $0x1, %eax
jne 0x20a5
movl %r15d, 0x2c(%rbx)
movb $0x1, %bpl
jmp 0x20a5
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %r14, %rsi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x2208
cmpl $0x1, %eax
je 0x2120
leaq 0x70(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b2a
movl %eax, %ebp
leaq 0x48(%rbx), %rsi
movq %r15, %rdi
callq 0x1b2a
cmpl %eax, %ebp
jge 0x214a
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
cmpl $0x1f5, %eax            # imm = 0x1F5
jl 0x214a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x216c
movl $0x4, %ecx
cmpl $0x1, %eax
je 0x215b
movq %rbx, %rdi
callq 0x1f94
testb %al, %al
jne 0x215e
movl $0x3, %ecx
movl %ecx, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %r10d
movl %r10d, %r9d
subl %ecx, %r9d
xorl %r8d, %r8d
testl %r9d, %r9d
cmovlel %r8d, %r9d
movl 0x4(%rsi), %eax
addl %ecx, %r10d
movl 0x8(%rdi), %r11d
movl 0xc(%rdi), %esi
cmpl %r11d, %r10d
cmovgel %r11d, %r10d
leal (%rax,%rcx), %r11d
cmpl %esi, %r11d
cmovll %r11d, %esi
cmpl %r10d, %r9d
jge 0x21eb
pushq %rbp
pushq %r14
pushq %rbx
subl %ecx, %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
movl %r9d, %r9d
movl %r10d, %r10d
movl %esi, %r11d
cmpl %esi, %eax
jge 0x21df
movq 0x10(%rdi), %rbx
movq (%rbx,%r9,8), %rbx
movq %rax, %r14
xorl %ebp, %ebp
cmpl %edx, (%rbx,%r14,4)
sete %bpl
addl %ebp, %r8d
incq %r14
cmpq %r14, %r11
jne 0x21ca
incq %r9
cmpq %r10, %r9
jne 0x21bb
popq %rbx
popq %r14
popq %rbp
imull %ecx, %ecx
movl %ecx, %eax
shrl %eax
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
shrq $0x20, %rcx
addl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %r8d
setg %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rsi), %r8d
movl %r8d, %r9d
subl %ecx, %r9d
xorl %eax, %eax
testl %r9d, %r9d
cmovlel %eax, %r9d
movl 0x4(%rsi), %r10d
addl %ecx, %r8d
movl 0x8(%rdi), %r11d
movl 0xc(%rdi), %esi
cmpl %r11d, %r8d
cmovgel %r11d, %r8d
leal (%r10,%rcx), %r11d
cmpl %esi, %r11d
cmovll %r11d, %esi
cmpl %r8d, %r9d
jge 0x227b
subl %ecx, %r10d
xorl %eax, %eax
testl %r10d, %r10d
cmovgl %r10d, %eax
movl %r9d, %ecx
movl %r8d, %r8d
movl %esi, %r9d
cmpl %esi, %eax
jge 0x2271
movq 0x10(%rdi), %r10
movq (%r10,%rcx,8), %r10
movq %rax, %r11
cmpl %edx, (%r10,%r11,4)
je 0x227c
incq %r11
cmpq %r11, %r9
jne 0x2263
incq %rcx
cmpq %r8, %rcx
jne 0x2254
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22f1
movq %rax, 0x68(%rbx)
leaq 0x58(%rbx), %rsi
movq %rbx, %rdi
callq 0x22f1
movq %rax, 0x70(%rbx)
xorl %ecx, %ecx
movl $0x0, %edx
testl %eax, %eax
jne 0x22b3
movl 0x8(%rbx), %edx
decl %edx
movl %edx, 0x60(%rbx)
cmpl $0x0, 0x74(%rbx)
jne 0x22c1
movl 0xc(%rbx), %ecx
decl %ecx
movl %ecx, 0x64(%rbx)
movl %edx, 0x78(%rbx)
xorl %eax, %eax
movl $0x0, %esi
testl %ecx, %ecx
jne 0x22d7
movl 0xc(%rbx), %esi
decl %esi
movl %esi, 0x7c(%rbx)
testl %edx, %edx
jne 0x22e3
movl 0x8(%rbx), %eax
decl %eax
movl %eax, 0x80(%rbx)
movl %ecx, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x8, %esi
movq %r14, %rdi
callq 0x2864
movl 0x8(%r13), %eax
decl %eax
leaq 0x8(%rsp), %r15
movl %eax, (%r15)
movl 0xc(%r13), %eax
decl %eax
movl %eax, 0x4(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b2a
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b2a
cmpl %eax, %ebp
movq %r15, %rax
cmovlq %r14, %rax
movq (%rax), %rax
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
xorl %eax, %eax
movl %eax, (%r14)
movl 0xc(%r13), %ecx
decl %ecx
movl %ecx, 0x4(%r14)
movl 0x8(%r13), %ecx
decl %ecx
movl %ecx, (%r15)
movl %eax, 0x4(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b2a
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b2a
cmpl %eax, %ebp
cmovlq %r14, %r15
movq (%r15), %rax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1b2a
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b2a
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_O1/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 0x244b
leaq 0x78(%rbx), %rsi
leaq 0x116(%rip), %r15       # 0x250a
movq %rbx, %rdi
movq %r15, %rdx
callq 0x254d
movl %eax, %ebp
leaq 0x80(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x254d
movl %eax, %r14d
leaq 0x60(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x254d
cmpl %r14d, %ebp
setg %cl
cmpl %eax, %ebp
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x2476
cmpl %eax, %ebp
setg %al
cmpl %ebp, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
je 0x2482
jmp 0x248e
movl 0xa4(%rbx), %ecx
xorl %esi, %esi
cmpl $0x1e, %ecx
setl %sil
xorl $0x3, %esi
cmpl $0x1f, %ecx
jl 0x246c
movl %ecx, %eax
xorl %edx, %edx
divl %esi
testl %edx, %edx
je 0x248e
movl %ecx, %eax
cltd
idivl %esi
cmpl $0x1, %edx
jne 0x2482
movl $0x1, 0x88(%rbx)
jmp 0x2498
movl $0x2, 0x88(%rbx)
jmp 0x2498
movl $0x0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x2864
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
cmpl 0x8(%r15), %eax
jge 0x2612
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0xc(%r15)
jle 0x2602
xorl %eax, %eax
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 0x25f2
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq *%rbx
cmpl $0x1, %eax
jne 0x25f2
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b2a
movl %eax, %ebp
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%r15), %eax
jl 0x25ae
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x8(%r15), %eax
jl 0x259d
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_O1/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 %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x2864
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x8(%rbx)
jle 0x26dc
xorl %ebp, %ebp
leaq -0x1b6(%rip), %r14      # 0x24a4
leaq 0x8(%rsp), %r15
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0xc(%rbx)
jle 0x26cd
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movslq 0x8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cltq
movl (%rcx,%rax,4), %eax
decl %eax
cmpl $0x1, %eax
ja 0x26be
movl 0x14(%rsp), %eax
orl 0x10(%rsp), %eax
je 0x26a4
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x254d
cmpl %ebp, %eax
jg 0x26be
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x254d
movl %eax, %ebp
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%rbx), %eax
jl 0x266f
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cmpl 0x8(%rbx), %eax
jl 0x265f
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %ebx
movq %rdi, %rax
orq %rsi, %rax
je 0x2771
movq %rsi, %r15
movq %rdi, %r12
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x276f
movq %rdx, %r14
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
testl %edi, %edi
jne 0x272e
cmpb $0x0, (%r15,%r13)
je 0x2771
cmpq %r13, %r14
je 0x2771
callq 0x2848
testl %eax, %eax
je 0x2746
movsbl (%r12,%r13), %edi
callq 0x2838
movsbl (%r15,%r13), %edi
callq 0x2848
testl %eax, %eax
je 0x275e
movsbl (%r15,%r13), %edi
callq 0x2838
movb (%r12,%r13), %al
leaq 0x1(%r13), %rcx
cmpb (%r15,%r13), %al
movq %rcx, %r13
je 0x271e
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpb $0x0, (%rdi)
je 0x27e5
movb (%rsi), %al
testb %al, %al
sete %cl
leaq 0x1(%rdi), %rdx
xorl %r8d, %r8d
testb %al, %al
je 0x27c6
movl $0x0, %r9d
movl %ecx, %r10d
cmpb (%rdi,%r8), %al
jne 0x27cc
xorl %r11d, %r11d
leaq 0x1(%r11), %r9
movb 0x1(%rsi,%r11), %bl
testb %bl, %bl
sete %r10b
je 0x27cc
cmpb (%rdx,%r11), %bl
movq %r9, %r11
je 0x27aa
jmp 0x27cc
xorl %r9d, %r9d
movl %ecx, %r10d
testb %r10b, %r10b
jne 0x27fb
leaq 0x1(%r8), %r10
incq %rdx
cmpb $0x0, 0x1(%rdi,%r8)
movq %r10, %r8
jne 0x2794
jmp 0x27eb
xorl %r10d, %r10d
xorl %r9d, %r9d
addq %r10, %rdi
xorl %eax, %eax
cmpb $0x0, (%rsi,%r9)
cmoveq %rdi, %rax
jmp 0x2801
addq %r8, %rdi
movq %rdi, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
incq %rdi
movb -0x1(%rdi), %cl
movzbl %cl, %eax
leal -0x9(%rax), %edx
cmpl $0x5, %edx
jb 0x28b0
cmpl $0x20, %eax
je 0x28b0
leal -0x2b(%rcx), %eax
xorl %esi, %esi
testb $-0x3, %al
sete %sil
movb -0x1(%rdi,%rsi), %al
leal -0x30(%rax), %r8d
xorl %edx, %edx
cmpb $0x9, %r8b
ja 0x2900
addq %rsi, %rdi
xorl %edx, %edx
movsbl %al, %eax
leal (%rdx,%rdx,4), %edx
leal (%rax,%rdx,2), %edx
addl $-0x30, %edx
movb (%rdi), %al
leal -0x30(%rax), %esi
incq %rdi
cmpb $0xa, %sil
jb 0x28e6
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x30bf
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)
movl $0x0, 0x74(%rsp)
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x3168
cmpb $0x0, (%rsi)
je 0x3168
movl %edi, %ebx
leaq 0x8(%rsp), %rdx
movq $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 0x2b50
movl %eax, %ebp
movq %r14, %rdi
callq 0x2818
cmpl $-0x1, %ebp
je 0x3158
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0x3944
movq %rax, %r14
movq 0x8(%rsp), %rsi
movslq %r14d, %rdx
movl %ebx, %edi
callq 0x1040
jmp 0x315e
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %rdi
callq 0x2818
movl %r14d, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x16d1e(%rip), %eax     # 0x19704
addl $-0x33, %eax
cmpl $-0x31, %eax
ja 0x2a06
leaq 0xe63b(%rip), %rdi      # 0x11030
movl $0x3, %esi
movl $0x32, %edx
xorl %eax, %eax
callq 0x8110
leaq 0xf101(%rip), %rdi      # 0x11b0e
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x9ebc
movq %rbx, 0x16d2a(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb150
movq 0x16d1c(%rip), %rdi     # 0x19758
movl 0x16cc2(%rip), %esi     # 0x19704
movzbl 0x16cb7(%rip), %edx     # 0x19700
leaq 0x160b0(%rip), %rcx     # 0x18b00
callq 0xa0ba
xorl %edi, %edi
callq 0xb170
xorl %edi, %edi
callq 0xb190
leaq 0xe5ef(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movl 0x16c8d(%rip), %ebx     # 0x19704
movq 0x16cda(%rip), %rdi     # 0x19758
callq 0xa47c
leaq 0xe5e4(%rip), %rdi      # 0x1106e
movl %ebx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2060
movq 0x16cbc(%rip), %rdi     # 0x19758
callq 0xa296
mulsd 0xe55f(%rip), %xmm0     # 0x11008
leaq 0xe5dd(%rip), %rdi      # 0x1108d
movb $0x1, %al
callq 0x2060
movq 0x16c9a(%rip), %rdi     # 0x19758
leaq 0x1643b(%rip), %rbx     # 0x18f00
movq %rbx, %rsi
callq 0xa484
leaq 0xe5d5(%rip), %rdi      # 0x110a9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2060
movq 0x16c73(%rip), %rbx     # 0x19758
testq %rbx, %rbx
je 0x2b06
movq %rbx, %rdi
callq 0x9f04
movl $0x8, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/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 0xefc8(%rip), %rdi      # 0x11b0e
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x9ebc
movq %r15, 0x16bf1(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb150
movq 0x16be3(%rip), %rdi     # 0x19758
movl 0x16b89(%rip), %esi     # 0x19704
movzbl 0x16b7e(%rip), %edx     # 0x19700
leaq 0x15f77(%rip), %rcx     # 0x18b00
callq 0xa0ba
xorl %edi, %edi
callq 0xb170
xorl %edi, %edi
callq 0xb190
leaq 0xe4b6(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movq 0x16ba7(%rip), %rdi     # 0x19758
callq 0xa296
mulsd 0xe44a(%rip), %xmm0     # 0x11008
leaq 0xe4c8(%rip), %rdi      # 0x1108d
movb $0x1, %al
callq 0x2060
movq 0x16b85(%rip), %rdi     # 0x19758
movq %r14, %rsi
callq 0xa2e0
movq 0x16b76(%rip), %rdi     # 0x19758
movl 0x16b1c(%rip), %edx     # 0x19704
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa542
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xeefe(%rip), %rdi      # 0x11b1e
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0x9ebc
movq %r15, 0x16b17(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb150
movq 0x16b09(%rip), %rdi     # 0x19758
leaq 0x15aaa(%rip), %rsi     # 0x18700
callq 0xa4e4
xorl %edi, %edi
callq 0xb170
xorl %edi, %edi
callq 0xb190
leaq 0xe3e9(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movq 0x16ada(%rip), %rdi     # 0x19758
callq 0xa296
mulsd 0xe37d(%rip), %xmm0     # 0x11008
leaq 0xe3fb(%rip), %rdi      # 0x1108d
movb $0x1, %al
callq 0x2060
movq 0x16ab8(%rip), %rdi     # 0x19758
movq %r14, %rsi
callq 0xa2e0
movq 0x16aa9(%rip), %rdi     # 0x19758
movl 0x16a4f(%rip), %edx     # 0x19704
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa542
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
ja 0x2d0d
movl $0x1, %eax
ucomisd %xmm0, %xmm1
ja 0x2d0d
movl 0x8(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x8(%rdi)
jg 0x2d0d
setl %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x16a1a(%rip)     # 0x19730
jne 0x2d26
leaq 0xe3a7(%rip), %rdi      # 0x110c6
xorl %eax, %eax
callq 0x8110
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
cmpq %rax, 0x161c9(%rip)     # 0x18f00
jne 0x2d83
movl 0x169f1(%rip), %eax     # 0x19730
cmpl $0x2, %eax
je 0x2d66
cmpl $0x1, %eax
jne 0x2d83
leaq 0x161b0(%rip), %rbx     # 0x18f00
movq %rbx, %rdi
callq 0x20e0
movl $0x7478742e, (%rax,%rbx) # imm = 0x7478742E
movb $0x0, 0x4(%rax,%rbx)
jmp 0x2d83
leaq 0x16193(%rip), %rbx     # 0x18f00
movq %rbx, %rdi
callq 0x20e0
movl $0x6d74682e, (%rax,%rbx) # imm = 0x6D74682E
movw $0x6c, 0x4(%rax,%rbx)
leaq 0x16176(%rip), %rdi     # 0x18f00
leaq 0xe361(%rip), %rsi      # 0x110f2
callq 0x2250
movq %rax, 0x169a3(%rip)     # 0x19740
testq %rax, %rax
jne 0x2db7
leaq 0xe34b(%rip), %rdi      # 0x110f4
leaq 0x16150(%rip), %rsi     # 0x18f00
xorl %eax, %eax
callq 0x8110
cmpb $0x1, 0x16943(%rip)     # 0x19701
jne 0x2ddf
leaq 0x16539(%rip), %rdi     # 0x19300
leaq 0xe324(%rip), %rsi      # 0x110f2
callq 0x2250
movq %rax, 0x1696e(%rip)     # 0x19748
testq %rax, %rax
je 0x2de1
popq %rbx
retq
leaq 0xe32c(%rip), %rdi      # 0x11114
leaq 0x16511(%rip), %rsi     # 0x19300
xorl %eax, %eax
popq %rbx
jmp 0x8110
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1678e(%rip), %eax     # 0x19728
decl %eax
cmpl $0x2, %eax
ja 0x2fb6
movl %eax, %eax
leaq 0xec12(%rip), %rcx      # 0x11bbc
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x2300
movb 0x16745(%rip), %al      # 0x19701
leaq 0x26b1e(%rip), %r14     # 0x29ae1
movb %al, (%r14)
movq 0x1677b(%rip), %rax     # 0x19748
leaq 0x26b14(%rip), %rcx     # 0x29ae8
movq %rax, (%rcx)
leaq 0xe1ee(%rip), %rdi      # 0x111cc
callq 0x2300
xorl %edi, %edi
callq 0xb150
movl 0x16738(%rip), %eax     # 0x19728
cmpl $0x3, %eax
je 0x302f
cmpl $0x2, %eax
je 0x301a
cmpl $0x1, %eax
jne 0x3042
movq 0x16732(%rip), %rdi     # 0x19738
movl 0x166f8(%rip), %esi     # 0x19704
leaq 0x1674d(%rip), %rdx     # 0x19760
callq 0x60ce
jmp 0x3042
movq 0x16717(%rip), %rdi     # 0x19738
leaq 0x16738(%rip), %rsi     # 0x19760
callq 0x2c0e
jmp 0x3042
movq 0x16702(%rip), %rdi     # 0x19738
leaq 0x16723(%rip), %rsi     # 0x19760
callq 0x2b34
xorl %edi, %edi
callq 0xb170
leaq 0x16710(%rip), %rbx     # 0x19760
movq %rbx, %rdi
callq 0xbd72
leaq 0xe1a0(%rip), %rdi      # 0x111ff
movl %eax, %esi
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
callq 0xbd6a
leaq 0xe197(%rip), %rdi      # 0x1120e
movb $0x1, %al
callq 0x2060
xorl %edi, %edi
callq 0xb190
leaq 0xe194(%rip), %rdi      # 0x11220
movb $0x1, %al
callq 0x2060
movb $0x0, (%r14)
xorl %edi, %edi
callq 0xb190
movsd %xmm0, 0x16672(%rip)    # 0x19718
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21c0
movq %rax, 0x15a67(%rip)     # 0x19768
cmpb $0x1, 0x159fa(%rip)     # 0x19702
jne 0x3d10
popq %rax
jmp 0x29dc
cmpl $0x0, 0x15a11(%rip)     # 0x19728
jne 0x3d27
leaq 0xdcb7(%rip), %rdi      # 0x119d7
xorl %eax, %eax
callq 0x8110
callq 0x2df8
callq 0x2d0e
callq 0x2f90
popq %rax
jmp 0x30ae
// File: /workspace/github_c_makefile_star2_O1/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 0x3d70
callq 0x3da6
movl %ebp, %edi
movq %rbx, %rsi
callq 0x3e46
movl 0x159a6(%rip), %edi     # 0x19704
movzbl 0x1599b(%rip), %esi     # 0x19700
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6d44
// File: /workspace/github_c_makefile_star2_O1/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, 0x14546(%rip)     # 0x18300
xorl %ebx, %ebx
movb %bl, 0x14546(%rip)      # 0x18308
movb %bl, 0x15938(%rip)      # 0x19700
movl $0xffffffff, 0x15932(%rip) # imm = 0xFFFFFFFF
movl $0x1, %ebp
movl %ebp, 0x1594b(%rip)     # 0x19728
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
movq %rax, 0x15112(%rip)     # 0x18f00
movl $0x63636f, 0x15508(%rip) # imm = 0x63636F
movl $0x0, 0x15906(%rip)     # 0x19708
xorl %edi, %edi
callq 0x21c0
movl %eax, 0x158fd(%rip)     # 0x1970c
movl $0x3, 0x158f7(%rip)     # 0x19710
movl $0xa, 0x158f1(%rip)     # 0x19714
movb %bl, 0x158d9(%rip)      # 0x19702
movl $0x2, 0x158f9(%rip)     # 0x1972c
movl %ebp, 0x158f7(%rip)     # 0x19730
movb %bl, 0x158c2(%rip)      # 0x19701
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x1547f(%rip)     # 0x19702
jne 0x6d94
pushq %rax
movq 0x154af(%rip), %rdi     # 0x19740
callq 0x21e0
cmpb $0x1, 0x15464(%rip)     # 0x19701
jne 0x42ab
movq 0x154a2(%rip), %rdi     # 0x19748
callq 0x21e0
addq $0x8, %rsp
jmp 0x6d94
// File: /workspace/github_c_makefile_star2_O1/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 0xd747(%rip), %rsi      # 0x11a06
callq 0x22c0
testl %eax, %eax
je 0x42f6
leaq 0xd73b(%rip), %rsi      # 0x11a0a
movq %rbx, %rdi
callq 0x22c0
testl %eax, %eax
je 0x42fd
leaq 0xd72e(%rip), %rsi      # 0x11a10
movq %rbx, %rdi
callq 0x22c0
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x4302
movl $0x1, %eax
jmp 0x4302
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x48f5
cmpl $0x0, 0xc(%rbx)
jle 0x48e7
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x48db
callq 0x2290
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x48c9
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x48f5
callq 0x2290
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x4947
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x4933
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x492d
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x4917
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x4999
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x4985
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x497f
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x4969
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x49eb
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0x49d7
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
movq -0x10(%r14,%r12), %rdi
testq %rdi, %rdi
je 0x49d1
movq (%r14,%r12), %rsi
subq %rdi, %rsi
callq 0x2200
addq $-0x18, %r12
jne 0x49bb
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x23f0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x49f9
callq 0x2290
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x4a07
callq 0x2290
cmpq $0x0, 0x20(%rbx)
je 0x4a1c
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4a1c
callq 0x2290
cmpq $0x0, 0x38(%rbx)
je 0x4a63
cmpl $0x0, 0xc(%rbx)
jle 0x4a4a
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4a3e
callq 0x2290
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x4a2c
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4a63
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movl $0x0, 0x10(%rdi)
cmpl $0x0, 0xc(%rdi)
jle 0x4b72
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rdi), %r13
movq 0x40(%rdi), %rbp
movq 0x50(%rdi), %r14
movq 0x30(%rdi), %rax
movq %rax, 0x8(%rsp)
movl $0x2, %r15d
xorl %r12d, %r12d
movq 0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax,%r12,4)
movq 0x18(%rsp), %rax
movl %ecx, (%rax,%r12,4)
movq 0x10(%rsp), %rax
movl %ecx, (%rax,%r12,4)
movq -0x8(%r13,%r15,4), %rax
cmpq %rax, (%r13,%r15,4)
je 0x4b1b
movq %rax, (%r13,%r15,4)
movq -0x8(%rbp,%r15,4), %rax
cmpq %rax, (%rbp,%r15,4)
je 0x4b2c
movq %rax, (%rbp,%r15,4)
movq -0x8(%r14,%r15,4), %rax
cmpq %rax, (%r14,%r15,4)
je 0x4b3b
movq %rax, (%r14,%r15,4)
movslq 0xc(%rbx), %rdx
testq %rdx, %rdx
jle 0x4b54
movq 0x8(%rsp), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x2120
incq %r12
movslq 0xc(%rbx), %rax
addq $0x6, %r15
cmpq %rax, %r12
jl 0x4aed
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x48ae
movslq %ebp, %r14
leaq (,%r14,8), %rdi
testl %r14d, %r14d
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
testl %r14d, %r14d
jle 0x4bd4
movl %ebp, %r15d
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x2030
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x4bbc
movl $0x18, %ecx
movq %r14, %rax
mulq %rcx
movq %rax, %r15
seto %al
addq $0x8, %r15
cmovbq %r12, %r15
testb %al, %al
cmovneq %r12, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %r14, (%rax)
addq $0x8, %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
testl %ebp, %ebp
je 0x4c3c
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2120
movq %r12, 0x48(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r12
movq %r14, (%rax)
testl %ebp, %ebp
je 0x4c7c
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x2120
movq %r12, 0x40(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r15
movq %r14, (%rax)
testl %ebp, %ebp
je 0x4cbc
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2120
shlq $0x2, %r14
testl %ebp, %ebp
movq %r15, 0x50(%rbx)
movq $-0x1, %r15
cmovnsq %r14, %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)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x30(%rdi), %rcx
movslq %esi, %rax
movq (%rcx,%rax,8), %rcx
movslq %edx, %rsi
cmpb $0x0, (%rcx,%rsi)
jne 0x4e45
movq %rdi, %rbx
movb $0x1, (%rcx,%rsi)
movq 0x40(%rdi), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4d5a
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4d64
leaq 0x8(%rsp), %rdx
callq 0x5248
movq 0x20(%rbx), %rax
movslq 0xc(%rsp), %rcx
incl (%rax,%rcx,4)
movq 0x48(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4d9b
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4da5
leaq 0xc(%rsp), %rdx
callq 0x5248
movq 0x18(%rbx), %rax
movslq 0x8(%rsp), %rcx
incl (%rax,%rcx,4)
incl 0x10(%rbx)
movq 0x30(%rbx), %rcx
movslq 0x8(%rsp), %rax
movq (%rcx,%rax,8), %rdx
movslq 0xc(%rsp), %rcx
cmpb $0x0, (%rdx,%rcx)
jne 0x4e45
movq 0x50(%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4dee
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4df8
leaq 0x8(%rsp), %rdx
callq 0x5248
movq 0x28(%rbx), %rax
movslq 0xc(%rsp), %rcx
incl (%rax,%rcx,4)
movq 0x50(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4e2f
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x4e39
leaq 0xc(%rsp), %rdx
callq 0x5248
movq 0x28(%rbx), %rax
movslq 0x8(%rsp), %rcx
incl (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
retq
nop