LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/get_size.c
// Function: process_size
int						process_size(t_point *game_size, enum e_state ***mx,
								char *line, char *type)
{
	t_point		size;
	int			len;

	ft_bzero(&size, sizeof(t_point));
	len = ft_strlen(type);
	if (ft_strnequ(line, type, len) == FALSE)
		return (FAILURE);
	line += len;
	if (check_size_format(line, &size) == FALSE)
		return (FAILURE);
	if (size.x == 0 || size.y == 0)
		return (FAILURE);
	if (game_size->x == 0 && game_size->y == 0)
	{
		game_size->x = size.x;
		game_size->y = size.y;
		if (*mx == NULL && alloc_game(mx, &size) == FAILURE)
			return (FAILURE);
	}
	return (SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
movl $0x8, %esi
callq 0x284c
movq %rbx, %rdi
callq 0x27e0
movslq %eax, %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x26d8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x1515
addq %r13, %r12
xorl %ebp, %ebp
movzbl (%r12), %eax
testl %eax, %eax
je 0x1515
cmpl $0x3a, %eax
je 0x14cf
cmpb $0x20, %al
jne 0x1515
cmpb $0x1, %bpl
ja 0x1515
leaq 0x1(%r12), %rdi
xorl %r13d, %r13d
testb %bpl, %bpl
setne %r13b
callq 0x2898
movl %eax, (%rsp,%r13,4)
movsbl 0x1(%r12), %edi
incq %r12
callq 0x2840
cmpl $0x1, %eax
je 0x14b7
incb %bpl
jmp 0x1483
cmpb $0x0, 0x1(%r12)
jne 0x1515
movl (%rsp), %esi
movl 0x4(%rsp), %edx
testl %esi, %esi
sete %al
testl %edx, %edx
sete %cl
orb %al, %cl
jne 0x1515
cmpl $0x0, (%r15)
jne 0x1513
cmpl $0x0, 0x4(%r15)
jne 0x1513
movl %esi, (%r15)
movl %edx, 0x4(%r15)
cmpq $0x0, (%r14)
jne 0x1513
movq %r14, %rdi
callq 0x1526
cmpl $-0x1, %eax
je 0x1515
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/get_size.c
// Function: alloc_game
static int				alloc_game(enum e_state ***mx, t_point *size)
{
	int		i;

	i = 0;
	*mx = (enum e_state **)malloc(sizeof(enum e_state *) * size->x);
	if (*mx == NULL)
		return (FAILURE);
	while (i < size->x)
	{
		(*mx)[i] = (enum e_state *)malloc(sizeof(enum e_state) * size->y);
		if ((*mx)[i] == NULL)
			return (FAILURE);
		i++;
	}
	return (SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x1070
movq %rax, (%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x1585
testl %ebp, %ebp
jle 0x1583
movq %rax, %r15
movslq %r12d, %r12
shlq $0x2, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x1070
movq %rax, (%r15,%rbp,8)
movq (%r14), %r15
cmpq $0x0, (%r15,%rbp,8)
je 0x1585
incq %rbp
cmpq %rbp, %r13
jne 0x1565
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/get_board.c
// Function: get_line_piece
int						get_line_piece(t_game *game, char *line)
{
	size_t	y;

	y = 0;
	if (((int)ft_strlen(line) > game->piece.size.y)
			|| (game->row > game->piece.size.x))
		return (FAILURE);
	while (line[y] != '\0')
	{
		game->piece.mx[game->row][y] = piece_char_is_ok(line[y]);
		if (game->piece.mx[game->row][y] == E_UNKNOW)
			return (FAILURE);
		y++;
	}
	return (SUCCESS);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x27e0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x1c(%r14)
jl 0x1833
movslq 0x30(%r14), %rdx
cmpl 0x18(%r14), %edx
jg 0x1833
movb (%rbx), %dil
testb %dil, %dil
je 0x1831
movq 0x20(%r14), %rcx
movq (%rcx,%rdx,8), %rsi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb $0x2a, %dil
setne %r9b
addl $0x5, %r9d
cmpb $0x2e, %dil
cmovel %edx, %r9d
movl %r9d, (%rsi,%r8,4)
movslq 0x30(%r14), %rsi
movq (%rcx,%rsi,8), %rsi
cmpl $0x6, (%rsi,%r8,4)
je 0x1833
movb 0x1(%rbx,%r8), %dil
incq %r8
testb %dil, %dil
jne 0x17fa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/process.c
// Function: ft_process
void					ft_process(t_game *game)
{
	static	t_strategy	strategy[] = {angle_target_mode, angle_opmine_mode,
										angle_opadv_mode, attack_mode,
										glue_mode};

	ft_bzero(&game->to_play, sizeof(t_point));
	game->nearest_adv = nearest(game);
	chose_better_angle(game);
	select_strategy(game);
	find_coord(game, strategy[game->mode]);
	game->last_mine = game->contact;
	ft_bzero(&game->last_adv, sizeof(t_point));
	ft_bzero(&game->good_contact, sizeof(t_point));
	ft_bzero(&game->contact, sizeof(t_point));
	game->turn++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x9c, %rdi
movl $0x8, %esi
movq %rdi, 0x8(%rsp)
callq 0x284c
movq %rbx, %rdi
callq 0x2607
movq %rax, 0x40(%rbx)
movq %rbx, %rdi
callq 0x23a8
movq %rbx, %rdi
callq 0x20c0
movl 0x18(%rbx), %r15d
movl 0x8(%rbx), %ebp
addl %r15d, %ebp
negl %r15d
cmpl %r15d, %ebp
jle 0x19ed
movl 0x2c(%rbx), %eax
leaq 0x9531(%rip), %rcx      # 0xadd0
movq (%rcx,%rax,8), %rax
movq %rax, (%rsp)
movl 0x1c(%rbx), %r14d
movl 0xc(%rbx), %r12d
addl %r14d, %r12d
negl %r14d
cmpl %r14d, %r12d
jle 0x19e1
movl %r15d, %eax
movq %rax, 0x10(%rsp)
movq %r14, %r13
movslq 0x18(%rbx), %rax
testq %rax, %rax
jle 0x19d5
movl 0x1c(%rbx), %ecx
xorl %edx, %edx
xorl %esi, %esi
testl %ecx, %ecx
jle 0x1986
leal (%r15,%rdx), %edi
xorl %r8d, %r8d
testl %edi, %edi
js 0x193a
leaq (%r8,%r13), %r9
testl %r9d, %r9d
js 0x193a
cmpl 0x8(%rbx), %edi
jge 0x193a
cmpl 0xc(%rbx), %r9d
jge 0x193a
movq 0x10(%rbx), %r10
movq (%r10,%rdi,8), %r10
movl %r9d, %r11d
movl (%r10,%r11,4), %r10d
leal -0x1(%r10), %r11d
cmpl $0x1, %r11d
ja 0x1957
movq 0x20(%rbx), %r9
movq (%r9,%rdx,8), %r9
cmpl $0x5, (%r9,%r8,4)
je 0x19d5
cmpl $0x1, %esi
jle 0x194d
jmp 0x19d5
movq 0x20(%rbx), %r9
movq (%r9,%rdx,8), %r9
cmpl $0x5, (%r9,%r8,4)
je 0x19d5
incq %r8
cmpq %r8, %rcx
jne 0x18ec
jmp 0x1986
cmpl $0x1, %esi
jg 0x19d5
addl $-0x3, %r10d
cmpl $0x1, %r10d
ja 0x194d
movq 0x20(%rbx), %r10
movq (%r10,%rdx,8), %r10
cmpl $0x5, (%r10,%r8,4)
jne 0x194d
movl %edi, 0x8c(%rbx)
movl %r9d, 0x90(%rbx)
incl %esi
jmp 0x194d
incq %rdx
cmpq %rax, %rdx
jne 0x18dd
cmpl $0x1, %esi
jne 0x19d5
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x19aa
cmpl $0x0, 0xa0(%rbx)
je 0x19b4
movq %rbx, %rdi
callq *(%rsp)
cmpb $0x1, %al
jne 0x19d5
movq 0x8c(%rbx), %rax
movq %rax, 0x94(%rbx)
movq %r13, %rax
shlq $0x20, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x9c(%rbx)
incq %r13
cmpl %r12d, %r13d
jne 0x18c9
incl %r15d
cmpl %ebp, %r15d
jne 0x18b5
leaq 0x8c(%rbx), %r14
movq 0x8c(%rbx), %rax
movq %rax, 0x48(%rbx)
leaq 0x38(%rbx), %rdi
movl $0x8, %esi
callq 0x284c
leaq 0x94(%rbx), %rdi
movl $0x8, %esi
callq 0x284c
movl $0x8, %esi
movq %r14, %rdi
callq 0x284c
incl 0xa4(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/utils.c
// Function: speak
void			speak(t_game *game, char **line)
{
	ft_strdel(line);
	free_matrix(&game->piece);
	ft_printf("%d %d\n", game->to_play.x, game->to_play.y);
	game->action = E_GET_BOARD_SIZE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2800
leaq 0x18(%rbx), %rdi
callq 0x1a78
movl 0x9c(%rbx), %esi
movl 0xa0(%rbx), %edx
leaq 0x55ca(%rip), %rdi      # 0x7032
xorl %eax, %eax
callq 0x2cc9
movl $0x1, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/utils.c
// Function: free_matrix
void			free_matrix(t_mx *mx)
{
	int		x;

	x = 0;
	while (x < mx->size.x)
	{
		free(mx->mx[x]);
		mx->mx[x] = NULL;
		x++;
	}
	free(mx->mx);
	mx->mx = NULL;
	mx->size.x = 0;
	mx->size.y = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1aab
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1a87
movq 0x8(%rbx), %rdi
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/utils.c
// Function: error
void			error(t_game *game, char **line)
{
	ft_strdel(line);
	free_matrix(&game->piece);
	free_matrix(&game->board);
	game->action = E_ERROR;
	if (game->error == 0)
	{
		game->error = 1;
		ft_putendl_fd("Error", 2);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2800
leaq 0x18(%rbx), %rdi
callq 0x1a78
leaq 0x8(%rbx), %rdi
callq 0x1a78
movl $0x7, 0x28(%rbx)
cmpl $0x0, 0xa8(%rbx)
je 0x1af2
popq %rbx
retq
movl $0x1, 0xa8(%rbx)
leaq 0x5536(%rip), %rdi      # 0x7039
movl $0x2, %esi
popq %rbx
jmp 0x285c
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/utils.c
// Function: check_first_line_board
unsigned char	check_first_line_board(unsigned int row, char *line)
{
	size_t	i;
	size_t	max;
	size_t	count;

	i = 0;
	max = row + 4;
	if (ft_strlen(line) != max)
		return (FALSE);
	while (i < 4)
	{
		if (line[i] != ' ')
			return (FALSE);
		i++;
	}
	count = 0;
	while (i < max)
	{
		if (count % 10 + '0' != line[i])
			return (FALSE);
		count++;
		i++;
	}
	return (TRUE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
addl $0x4, %r14d
movq %rsi, %rdi
callq 0x27e0
cmpq %r14, %rax
jne 0x1b9e
xorl %eax, %eax
cmpb $0x20, (%rbx,%rax)
jne 0x1b9e
incq %rax
cmpq $0x4, %rax
jne 0x1b3e
movb $0x1, %cl
cmpl $0x5, %r14d
jb 0x1ba0
movl $0x4, %edi
movl $0x30, %r8d
xorl %esi, %esi
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r9
shrq $0x2, %rdx
andq $-0x2, %rdx
leaq (%rdx,%rdx,4), %rax
movq %r8, %rdx
subq %rax, %rdx
movsbq (%rbx,%rdi), %rax
cmpq %rax, %rdx
jne 0x1b9e
incq %rsi
incq %rdi
incq %r8
cmpq %rdi, %r14
jne 0x1b6c
jmp 0x1ba0
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c(%rdi), %r14
movq %r14, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2150
testl %eax, %eax
jne 0x1bf0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
testl %eax, %eax
je 0x1c03
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x94(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2150
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1bf2
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
cmpl $0x1, %eax
je 0x1bf2
movl 0x8(%rbx), %eax
movl 0x40(%rbx), %r12d
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %r13d
addq $0x60, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b0e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b0e
cmpl %r13d, %r12d
jge 0x1c85
cmpl %eax, %r14d
jg 0x1bf0
jmp 0x1bf2
cmpl %eax, %r14d
jge 0x1bf0
jmp 0x1bf2
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/strategy.c
// Function: angle_opmine_mode
unsigned char	angle_opmine_mode(t_game *game)
{
	if (over(game, &game->contact, E_ADV, 3) == FALSE
			&& over(game, &game->contact, E_MINE, 5) == FALSE)
	{
		if (over(game, &game->good_contact, E_ADV, 3) == TRUE
				|| over(game, &game->good_contact, E_MINE, 5) == TRUE)
			return (TRUE);
		if (game->nearest_adv.x <= game->board.size.x / 2
			|| game->core_adv.x > game->core_mine.x)
		{
			if (delta(&game->contact, &game->angle_opmine)
					<= delta(&game->good_contact, &game->angle_opmine))
				return (TRUE);
		}
		else
		{
			if (delta(&game->contact, &game->angle_opmine)
					< delta(&game->good_contact, &game->angle_opmine))
				return (TRUE);
		}
	}
	return (FALSE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c(%rdi), %r14
movq %r14, %rsi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x2150
testl %eax, %eax
jne 0x1cd3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
testl %eax, %eax
je 0x1ce2
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 0x2150
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1cd5
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
cmpl $0x1, %eax
je 0x1cd5
movl 0x8(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, 0x40(%rbx)
jle 0x1d39
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1d64
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b0e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b0e
cmpl %eax, %r14d
jg 0x1cd3
jmp 0x1cd5
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b0e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b0e
cmpl %eax, %r14d
jge 0x1cd3
jmp 0x1cd5
// File: /workspace/github_c_makefile_star2_O3/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 0x2150
testl %eax, %eax
jne 0x1dcf
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
testl %eax, %eax
je 0x1dde
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 0x2150
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1dd1
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x2150
cmpl $0x1, %eax
je 0x1dd1
movl 0x8(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, 0x40(%rbx)
jle 0x1e35
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1e60
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b0e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b0e
cmpl %eax, %r14d
jg 0x1dcf
jmp 0x1dd1
subq $-0x80, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b0e
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b0e
cmpl %eax, %r14d
jge 0x1dcf
jmp 0x1dd1
// File: /workspace/github_c_makefile_star2_O3/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 0x1b0e
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b0e
movl %eax, %ecx
movb $0x1, %al
cmpl %r12d, %ebp
jle 0x1edf
cmpl %ecx, %ebx
jg 0x1ee3
jmp 0x1ee5
cmpl %ecx, %ebx
jl 0x1ee5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b0e
movl %eax, %ebx
addq $0x94, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b0e
movl %eax, %ecx
movb $0x1, %al
cmpl %r12d, %ebp
jle 0x1f42
cmpl %ecx, %ebx
jg 0x1f46
jmp 0x1f48
cmpl %ecx, %ebx
jl 0x1f48
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2089
movq %rdi, %rbx
testl %eax, %eax
jne 0x1fef
leaq 0x60(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x21e4
testl %eax, %eax
jne 0x1fe9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x21e4
testl %eax, %eax
jne 0x1fe9
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x6, %ecx
callq 0x2150
cmpl $0x1, %eax
je 0x20b7
movl 0x88(%rbx), %eax
cmpl $0x1, %eax
jne 0x2047
leaq 0x78(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x21e4
testl %eax, %eax
jne 0x2047
movl $0x1, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x21e4
testl %eax, %eax
jne 0x2047
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x3, %ecx
callq 0x2150
cmpl $0x1, %eax
je 0x20b7
cmpl $0x2, 0x88(%rbx)
jne 0x2089
leaq 0x80(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x21e4
testl %eax, %eax
jne 0x2089
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x21e4
testl %eax, %eax
je 0x2098
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 0x2150
movl $0x2, %r15d
cmpl $0x1, %eax
jne 0x208b
movl %r15d, 0x2c(%rbx)
movb $0x1, %bpl
jmp 0x208b
// File: /workspace/github_c_makefile_star2_O3/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 0x21e4
cmpl $0x1, %eax
je 0x2106
leaq 0x70(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b0e
movl %eax, %ebp
leaq 0x48(%rbx), %rsi
movq %r15, %rdi
callq 0x1b0e
cmpl %eax, %ebp
jge 0x2130
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
cmpl $0x1f5, %eax            # imm = 0x1F5
jl 0x2130
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl $0x2, %ecx
callq 0x2150
movl $0x4, %ecx
cmpl $0x1, %eax
je 0x2141
movq %rbx, %rdi
callq 0x1f78
testb %al, %al
jne 0x2144
movl $0x3, %ecx
movl %ecx, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
addl %ecx, %r10d
movl 0x8(%rdi), %eax
cmpl %eax, %r10d
cmovgel %eax, %r10d
cmpl %r10d, %r9d
jge 0x21c7
pushq %rbp
pushq %rbx
movl 0x4(%rsi), %eax
leal (%rax,%rcx), %r8d
movl 0xc(%rdi), %esi
cmpl %esi, %r8d
cmovll %r8d, %esi
subl %ecx, %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
movl %r9d, %r9d
movl %r10d, %r10d
cmpl %esi, %eax
jge 0x21bd
movq 0x10(%rdi), %r11
movq (%r11,%r9,8), %r11
movq %rax, %rbx
xorl %ebp, %ebp
cmpl %edx, (%r11,%rbx,4)
sete %bpl
addl %ebp, %r8d
incq %rbx
cmpq %rbx, %rsi
jne 0x21a8
incq %r9
cmpq %r10, %r9
jne 0x2199
popq %rbx
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_O3/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
addl %ecx, %r8d
movl 0x8(%rdi), %r10d
cmpl %r10d, %r8d
cmovgel %r10d, %r8d
cmpl %r8d, %r9d
jge 0x2250
movl 0x4(%rsi), %esi
leal (%rsi,%rcx), %r10d
movl 0xc(%rdi), %eax
cmpl %eax, %r10d
cmovll %r10d, %eax
subl %ecx, %esi
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movl %r9d, %esi
movl %r8d, %r8d
cmpl %eax, %ecx
jge 0x2246
movq 0x10(%rdi), %r9
movq (%r9,%rsi,8), %r9
movq %rcx, %r10
cmpl %edx, (%r9,%r10,4)
je 0x2251
incq %r10
cmpq %r10, %rax
jne 0x2238
incq %rsi
cmpq %r8, %rsi
jne 0x2229
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22c8
movq %rax, 0x68(%rbx)
leaq 0x58(%rbx), %rsi
movq %rbx, %rdi
callq 0x22c8
movq %rax, 0x70(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
jne 0x2283
movl 0x8(%rbx), %ecx
decl %ecx
movl %ecx, 0x60(%rbx)
shrq $0x20, %rax
jne 0x229b
movl 0xc(%rbx), %eax
decl %eax
movl %eax, 0x64(%rbx)
movl %ecx, 0x78(%rbx)
xorl %edx, %edx
jmp 0x22ac
movl $0x0, 0x64(%rbx)
movl %ecx, 0x78(%rbx)
movl 0xc(%rbx), %edx
decl %edx
xorl %eax, %eax
movl %edx, 0x7c(%rbx)
xorl %edx, %edx
testl %ecx, %ecx
jne 0x22ba
movl 0x8(%rbx), %edx
decl %edx
movl %edx, 0x80(%rbx)
movl %eax, 0x84(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x284c
movq 0x8(%r13), %xmm0
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
leaq 0x8(%rsp), %r15
movq %xmm1, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b0e
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b0e
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 0x1b0e
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b0e
cmpl %eax, %ebp
cmovlq %r14, %r15
movq (%r15), %rax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1b0e
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b0e
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_O3/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 0x2422
leaq 0x78(%rbx), %rsi
leaq 0x123(%rip), %r15       # 0x24ee
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2531
movl %eax, %ebp
leaq 0x80(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2531
movl %eax, %r14d
leaq 0x60(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2531
cmpl %r14d, %ebp
setg %cl
cmpl %eax, %ebp
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x2465
cmpl %eax, %ebp
setg %al
cmpl %ebp, %r14d
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2446
jmp 0x2471
movl 0xa4(%rbx), %eax
cmpl $0x1f, %eax
jl 0x2452
movl $0xaaaaaaab, %ecx       # imm = 0xAAAAAAAB
movq %rax, %rdx
imulq %rcx, %rdx
shrq $0x21, %rdx
leal (%rdx,%rdx,2), %ecx
movl %eax, %edx
subl %ecx, %edx
jne 0x2452
movl $0x0, 0x88(%rbx)
jmp 0x247b
xorl %ecx, %ecx
cmpl $0x1e, %eax
setl %cl
xorl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x2471
movl $0x1, 0x88(%rbx)
jmp 0x247b
movl $0x2, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ffoissey[P]filler_42/srcs/tools2.c
// Function: get_better
int			get_better(t_game *game, t_point *ref,
				int (*f)(t_game *, t_point *, t_point *ok, t_point *ref))
{
	t_point pos;
	t_point ok;
	int		d;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x284c
movl $0x0, 0x8(%rsp)
movl 0x8(%r15), %ecx
testl %ecx, %ecx
jle 0x25f4
movl 0xc(%r15), %eax
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
leaq 0x10(%rsp), %r13
movl $0x0, 0xc(%rsp)
testl %eax, %eax
jle 0x25e4
xorl %ecx, %ecx
movq 0x10(%r15), %rax
movslq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x25ce
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq *%rbx
cmpl $0x1, %eax
jne 0x25ce
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b0e
movl %eax, %ebp
movl 0xc(%rsp), %ecx
incl %ecx
movl %ecx, 0xc(%rsp)
movl 0xc(%r15), %eax
cmpl %eax, %ecx
jl 0x2589
movl 0x8(%r15), %ecx
movl 0x8(%rsp), %edx
incl %edx
movl %edx, 0x8(%rsp)
cmpl %ecx, %edx
jl 0x257b
jmp 0x25f6
xorl %ebp, %ebp
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_O3/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 0x284c
movl $0x0, 0x8(%rsp)
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
jle 0x26c7
movl 0xc(%rbx), %eax
xorl %ebp, %ebp
leaq -0x1ba(%rip), %r14      # 0x2488
leaq 0x8(%rsp), %r15
movl $0x0, 0xc(%rsp)
testl %eax, %eax
jle 0x26b9
xorl %ecx, %ecx
movq 0x10(%rbx), %rax
movslq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
decl %eax
cmpl $0x1, %eax
ja 0x26a5
movl 0x14(%rsp), %eax
orl 0x10(%rsp), %eax
je 0x268b
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2531
cmpl %ebp, %eax
jg 0x26a5
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2531
movl %eax, %ebp
movl 0xc(%rsp), %ecx
incl %ecx
movl %ecx, 0xc(%rsp)
movl 0xc(%rbx), %eax
cmpl %eax, %ecx
jl 0x2655
movl 0x8(%rbx), %ecx
movl 0x8(%rsp), %edx
incl %edx
movl %edx, 0x8(%rsp)
cmpl %ecx, %edx
jl 0x2647
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x275d
movq %rsi, %r15
movq %rdi, %r12
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x275b
movq %rdx, %r14
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
testl %edi, %edi
jne 0x271a
cmpb $0x0, (%r15,%r13)
je 0x275d
cmpq %r13, %r14
je 0x275d
callq 0x2830
testl %eax, %eax
je 0x2732
movsbl (%r12,%r13), %edi
callq 0x2820
movsbl (%r15,%r13), %edi
callq 0x2830
testl %eax, %eax
je 0x274a
movsbl (%r15,%r13), %edi
callq 0x2820
movb (%r12,%r13), %al
leaq 0x1(%r13), %rcx
cmpb (%r15,%r13), %al
movq %rcx, %r13
je 0x270a
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_O3/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
movb (%rdi), %r10b
testb %r10b, %r10b
je 0x27c3
movb (%rsi), %cl
testb %cl, %cl
sete %dl
leaq 0x1(%rdi), %r8
xorl %eax, %eax
cmpb %r10b, %cl
jne 0x27a6
xorl %r11d, %r11d
leaq 0x1(%r11), %r9
movb 0x1(%rsi,%r11), %bl
testb %bl, %bl
sete %r10b
je 0x27ac
cmpb (%r8,%r11), %bl
movq %r9, %r11
je 0x278a
jmp 0x27ac
xorl %r9d, %r9d
movl %edx, %r10d
testb %r10b, %r10b
jne 0x27d8
movb 0x1(%rdi,%rax), %r10b
incq %rax
incq %r8
testb %r10b, %r10b
jne 0x2782
jmp 0x27c8
xorl %eax, %eax
xorl %r9d, %r9d
addq %rax, %rdi
xorl %eax, %eax
cmpb $0x0, (%rsi,%r9)
cmoveq %rdi, %rax
jmp 0x27de
addq %rax, %rdi
movq %rdi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2898
cmpl $0x20, %eax
je 0x2898
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 0x28e8
addq %rsi, %rdi
xorl %edx, %edx
movzbl %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 0x28ce
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3087
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 0x3130
cmpb $0x0, (%rsi)
je 0x3130
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 0x2b40
movl %eax, %ebp
movq %r14, %rdi
callq 0x2800
cmpl $-0x1, %ebp
je 0x3120
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0x3908
movq %rax, %r14
movq 0x8(%rsp), %rsi
movslq %r14d, %rdx
movl %ebx, %edi
callq 0x1040
jmp 0x3126
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %rdi
callq 0x2800
movl %r14d, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x8240
leaq 0xf0e3(%rip), %rdi      # 0x11af0
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
callq 0xa032
movq %rbx, 0x16d2a(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb2cc
movq 0x16d1c(%rip), %rdi     # 0x19758
movl 0x16cc2(%rip), %esi     # 0x19704
movzbl 0x16cb7(%rip), %edx     # 0x19700
leaq 0x160b0(%rip), %rcx     # 0x18b00
callq 0xa22e
xorl %edi, %edi
callq 0xb2ec
xorl %edi, %edi
callq 0xb30c
leaq 0xe5ef(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movl 0x16c8d(%rip), %ebx     # 0x19704
movq 0x16cda(%rip), %rdi     # 0x19758
callq 0xa5f4
leaq 0xe5e4(%rip), %rdi      # 0x1106e
movl %ebx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x2060
movq 0x16cbc(%rip), %rdi     # 0x19758
callq 0xa40a
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 0xa5fc
leaq 0xe5d5(%rip), %rdi      # 0x110a9
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2060
movq 0x16c73(%rip), %rbx     # 0x19758
testq %rbx, %rbx
je 0x2af2
movq %rbx, %rdi
callq 0xa07a
movl $0x8, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O3/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 0xefb2(%rip), %rdi      # 0x11af0
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0xa032
movq %r15, 0x16bf9(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb2cc
movq 0x16beb(%rip), %rdi     # 0x19758
movl 0x16b91(%rip), %esi     # 0x19704
movzbl 0x16b86(%rip), %edx     # 0x19700
leaq 0x15f7f(%rip), %rcx     # 0x18b00
callq 0xa22e
xorl %edi, %edi
callq 0xb2ec
xorl %edi, %edi
callq 0xb30c
leaq 0xe4be(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movq 0x16baf(%rip), %rdi     # 0x19758
callq 0xa40a
mulsd 0xe452(%rip), %xmm0     # 0x11008
leaq 0xe4d0(%rip), %rdi      # 0x1108d
movb $0x1, %al
callq 0x2060
movq 0x16b8d(%rip), %rdi     # 0x19758
movq %r14, %rsi
callq 0xa454
movq 0x16b7e(%rip), %rdi     # 0x19758
movl 0x16b24(%rip), %edx     # 0x19704
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa6ba
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xeee8(%rip), %rdi      # 0x11b00
callq 0x2300
movl $0x8, %edi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
callq 0xa032
movq %r15, 0x16b1f(%rip)     # 0x19758
xorl %edi, %edi
callq 0xb2cc
movq 0x16b11(%rip), %rdi     # 0x19758
leaq 0x15ab2(%rip), %rsi     # 0x18700
callq 0xa65c
xorl %edi, %edi
callq 0xb2ec
xorl %edi, %edi
callq 0xb30c
leaq 0xe3f1(%rip), %rdi      # 0x11059
movb $0x1, %al
callq 0x2060
movq 0x16ae2(%rip), %rdi     # 0x19758
callq 0xa40a
mulsd 0xe385(%rip), %xmm0     # 0x11008
leaq 0xe403(%rip), %rdi      # 0x1108d
movb $0x1, %al
callq 0x2060
movq 0x16ac0(%rip), %rdi     # 0x19758
movq %r14, %rsi
callq 0xa454
movq 0x16ab1(%rip), %rdi     # 0x19758
movl 0x16a57(%rip), %edx     # 0x19704
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa6ba
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_c_makefile_star2_O3/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 0x2d05
movl $0x1, %eax
ucomisd %xmm0, %xmm1
ja 0x2d05
movl 0x8(%rsi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x8(%rdi)
jg 0x2d05
setl %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x16a22(%rip)     # 0x19730
jne 0x2d1e
leaq 0xe3af(%rip), %rdi      # 0x110c6
xorl %eax, %eax
callq 0x8240
movabsq $0x73746c75736572, %rax # imm = 0x73746C75736572
cmpq %rax, 0x161d1(%rip)     # 0x18f00
jne 0x2d7b
movl 0x169f9(%rip), %eax     # 0x19730
cmpl $0x2, %eax
je 0x2d5e
cmpl $0x1, %eax
jne 0x2d7b
leaq 0x161b8(%rip), %rbx     # 0x18f00
movq %rbx, %rdi
callq 0x20e0
movl $0x7478742e, (%rax,%rbx) # imm = 0x7478742E
movb $0x0, 0x4(%rax,%rbx)
jmp 0x2d7b
leaq 0x1619b(%rip), %rbx     # 0x18f00
movq %rbx, %rdi
callq 0x20e0
movl $0x6d74682e, (%rax,%rbx) # imm = 0x6D74682E
movw $0x6c, 0x4(%rax,%rbx)
leaq 0x1617e(%rip), %rdi     # 0x18f00
leaq 0xe369(%rip), %rsi      # 0x110f2
callq 0x2250
movq %rax, 0x169ab(%rip)     # 0x19740
testq %rax, %rax
jne 0x2daf
leaq 0xe353(%rip), %rdi      # 0x110f4
leaq 0x16158(%rip), %rsi     # 0x18f00
xorl %eax, %eax
callq 0x8240
cmpb $0x1, 0x1694b(%rip)     # 0x19701
jne 0x2dd7
leaq 0x16541(%rip), %rdi     # 0x19300
leaq 0xe32c(%rip), %rsi      # 0x110f2
callq 0x2250
movq %rax, 0x16976(%rip)     # 0x19748
testq %rax, %rax
je 0x2dd9
popq %rbx
retq
leaq 0xe334(%rip), %rdi      # 0x11114
leaq 0x16519(%rip), %rsi     # 0x19300
xorl %eax, %eax
popq %rbx
jmp 0x8240
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x16796(%rip), %eax     # 0x19728
decl %eax
cmpl $0x2, %eax
ja 0x2fae
movl %eax, %eax
leaq 0xebfa(%rip), %rcx      # 0x11b9c
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x2300
movb 0x1674d(%rip), %al      # 0x19701
leaq 0x26b26(%rip), %r14     # 0x29ae1
movb %al, (%r14)
movq 0x16783(%rip), %rax     # 0x19748
leaq 0x26b1c(%rip), %rcx     # 0x29ae8
movq %rax, (%rcx)
leaq 0xe1f6(%rip), %rdi      # 0x111cc
callq 0x2300
xorl %edi, %edi
callq 0xb2cc
movl 0x16740(%rip), %eax     # 0x19728
cmpl $0x3, %eax
je 0x3027
cmpl $0x2, %eax
je 0x3012
cmpl $0x1, %eax
jne 0x303a
movq 0x1673a(%rip), %rdi     # 0x19738
movl 0x16700(%rip), %esi     # 0x19704
leaq 0x16755(%rip), %rdx     # 0x19760
callq 0x6236
jmp 0x303a
movq 0x1671f(%rip), %rdi     # 0x19738
leaq 0x16740(%rip), %rsi     # 0x19760
callq 0x2c06
jmp 0x303a
movq 0x1670a(%rip), %rdi     # 0x19738
leaq 0x1672b(%rip), %rsi     # 0x19760
callq 0x2b2c
xorl %edi, %edi
callq 0xb2ec
leaq 0x16718(%rip), %rbx     # 0x19760
movq %rbx, %rdi
callq 0xbec6
leaq 0xe1a8(%rip), %rdi      # 0x111ff
movl %eax, %esi
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
callq 0xbebe
leaq 0xe19f(%rip), %rdi      # 0x1120e
movb $0x1, %al
callq 0x2060
xorl %edi, %edi
callq 0xb30c
leaq 0xe19c(%rip), %rdi      # 0x11220
movb $0x1, %al
callq 0x2060
movb $0x0, (%r14)
xorl %edi, %edi
callq 0xb30c
movsd %xmm0, 0x1667a(%rip)    # 0x19718
addq $0x8, %rsp
popq %rbx
popq %r14
retq