LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_strjoin.c
// Function: ft_strjoin
char		*ft_strjoin(char const *s1, char const *s2)
{
	size_t	i;
	size_t	j;
	size_t	ss1;
	size_t	ss2;
	char	*s3;

	if (s1)
	{
		i = 0;
		j = 0;
		ss1 = ft_strlen((char *)s1);
		ss2 = ft_strlen((char *)s2);
		if (!(s3 = malloc(sizeof(char) * (ss1 + ss2 + 1))))
			return (0);
		while (i < (ss1))
		{
			s3[i] = s1[i];
			i++;
		}
		while (j < (ss2))
			s3[i++] = s2[j++];
		s3[i] = '\0';
		return (s3);
	}
	return (NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xba17
movq %rsi, %rbx
movq %rdi, %r13
callq 0xbc3c
movl %eax, %r15d
movslq %eax, %r14
movq %rbx, (%rsp)
movq %rbx, %rdi
callq 0xbc3c
movl %eax, %ebp
movslq %eax, %r12
leaq (%r14,%r12), %rdi
incq %rdi
callq 0x7100
testq %rax, %rax
je 0xba17
movq %rax, %rbx
testl %r15d, %r15d
je 0xba1b
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x73f0
jmp 0xba1e
xorl %ebx, %ebx
jmp 0xba3c
xorl %r14d, %r14d
testl %ebp, %ebp
je 0xba37
movq %rbx, %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x73f0
addq %r12, %r14
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/ft_strnew.c
// Function: ft_strnew
char		*ft_strnew(size_t size, char c)
{
	char	*s;
	size_t	i;

	i = 0;
	if (!(s = malloc(sizeof(char) * (size + 1))))
		return (NULL);
	while (i < size)
	{
		s[i] = c;
		i++;
	}
	s[i] = '\0';
	return (s);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
incq %rdi
callq 0x7100
testq %rax, %rax
je 0xba7f
movq %rax, %rbx
testq %r14, %r14
je 0xba83
movzbl %bpl, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7030
jmp 0xba86
xorl %ebx, %ebx
jmp 0xba8b
xorl %r14d, %r14d
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/get_next_line.c
// Function: debut
char				*debut(char *rest, char **line, int i)
{
	char			*tmp;

	if (i >= 0)
	{
		rest[i] = '\0';
		*line = ft_strdupi(rest);
		tmp = ft_strdup(rest + (i + 1));
		free(rest);
		rest = NULL;
		rest = tmp;
		return (rest);
	}
	return (rest);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %edx, %edx
js 0xbaee
movq %rsi, %r14
movl %edx, %eax
leaq (%rbx,%rax), %r15
incq %r15
movb $0x0, -0x1(%r15)
movq %rbx, %rdi
callq 0xbcac
movq %rax, (%r14)
movq %r15, %rdi
callq 0xbc55
movq %rax, %r14
movq %rbx, %rdi
callq 0x7170
movq %r14, %rax
jmp 0xbaf1
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/get_next_line.c
// Function: last_line
char				*last_line(char *rest, char **line, int i, int ret)
{
	char			*tmp;

	if (ret == 0 && i != -1)
	{
		rest[i] = '\0';
		*line = ft_strdupi(rest);
		tmp = ft_strdup(rest + (i + 1));
		free(rest);
		rest = NULL;
		rest = tmp;
		free(tmp);
		tmp = NULL;
		return (rest);
	}
	else if (ret == 0)
	{
		*line = ft_strdup(rest);
		free(rest);
		rest = NULL;
		return (rest);
	}
	return (rest);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %ecx, %ecx
setne %al
cmpl $-0x1, %edx
sete %sil
orb %al, %sil
jne 0xbb45
movslq %edx, %rax
leaq (%rbx,%rax), %r15
incq %r15
movb $0x0, -0x1(%r15)
movq %rbx, %rdi
callq 0xbcac
movq %rax, (%r14)
movq %r15, %rdi
callq 0xbc55
movq %rax, %r14
movq %rbx, %rdi
callq 0x7170
movq %r14, %rbx
jmp 0xbb57
testl %ecx, %ecx
jne 0xbb62
movq %rbx, %rdi
callq 0xbc55
movq %rax, (%r14)
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x7170
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/get_next_line.c
// Function: get_next_line
int					get_next_line(int fd, char **line)
{
	static char		*rest = NULL;
	int				ret;
	char			buf[BUFFER_SIZE + 1];
	int				i;

	i = 0;
	while ((ret = read(fd, buf, BUFFER_SIZE)) > 0 || i != -1)
	{
		buf[ret] = '\0';
		rest = ft_strxjoin(rest, buf);
		i = ft_check_retour(rest);
		if (i >= 0)
			rest = debut(rest, line, i);
		if (i >= 0)
			return (1);
	}
	rest = last_line(rest, line, i, ret);
	if (ret == 0 && i != -1)
		return (1);
	else if (ret == 0)
		return (0);
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %ebp
xorl %r15d, %r15d
movq %rsp, %r14
movl $0x32, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x70e0
movq %rax, %r12
testl %r12d, %r12d
setle %al
cmpl $-0x1, %r15d
sete %cl
testb %al, %cl
jne 0xbbff
movslq %r12d, %rax
movb $0x0, (%rsp,%rax)
movq 0xd715(%rip), %rdi      # 0x192c8
movq %r14, %rsi
callq 0xbd0d
movq %rax, 0xd706(%rip)      # 0x192c8
xorl %r15d, %r15d
movzbl (%rax,%r15), %ecx
testl %ecx, %ecx
je 0xbbd8
cmpl $0xa, %ecx
je 0xbbde
incq %r15
jmp 0xbbc5
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %r15d, %r15d
js 0xbb82
movq %rax, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0xbaae
movq %rax, 0xd6d0(%rip)      # 0x192c8
movl $0x1, %eax
jmp 0xbc2f
movq 0xd6c2(%rip), %r14      # 0x192c8
testl %r12d, %r12d
jne 0xbc21
movq %r14, %rdi
callq 0xbc55
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x7170
xorl %r14d, %r14d
movq %r14, 0xd6a0(%rip)      # 0x192c8
xorl %eax, %eax
negl %r12d
sbbl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/get_next_line_utils.c
// Function: ft_strdup
char				*ft_strdup(const char *s1)
{
	int				size_s1;
	char			*copy;
	int				i;

	i = 0;
	size_s1 = ft_strlen((char *)s1);
	if (!(copy = malloc(sizeof(char) * (size_s1 + 1))))
		return (NULL);
	while (s1[i] != '\0')
	{
		copy[i] = s1[i];
		i++;
	}
	copy[i] = '\0';
	return (copy);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xbc7f
xorl %edi, %edi
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rbx, %rcx
addq %rax, %rdi
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0xbc6d
sarq $0x20, %rdi
jmp 0xbc84
movl $0x1, %edi
callq 0x7100
testq %rax, %rax
je 0xbca8
movb (%rbx), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0xbca2
movb %dl, (%rax,%rcx)
movb 0x1(%rbx,%rcx), %dl
incq %rcx
jmp 0xbc92
movb $0x0, (%rax,%rcx)
jmp 0xbcaa
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/get_next_line_utils.c
// Function: ft_strxjoin
char				*ft_strxjoin(char const *s1, char const *s2)
{
	size_t			i;
	size_t			j;
	size_t			ss1;
	size_t			ss2;
	char			*s3;

	i = 0;
	j = 0;
	if (s1 == NULL)
		ss1 = 0;
	else
		ss1 = ft_strlen((char *)s1);
	ss2 = ft_strlen((char *)s2);
	if (!(s3 = malloc(sizeof(char) * (ss1 + ss2 + 1))))
		return (0);
	while (i < (ss1))
	{
		s3[i] = s1[i];
		i++;
	}
	while (j < (ss2))
		s3[i++] = s2[j++];
	s3[i] = '\0';
	free_(s1);
	return (s3);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
movabsq $0x100000000, %rax      # imm = 0x100000000
testq %rdi, %rdi
je 0xbd4d
movq %rbx, %rcx
movq %r14, %r12
addq %rax, %r12
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0xbd3b
sarq $0x20, %r12
jmp 0xbd50
xorl %r12d, %r12d
testq %r15, %r15
je 0xbd6a
movq %r15, %rcx
addq %rax, %r14
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0xbd58
sarq $0x20, %r14
jmp 0xbd6d
xorl %r14d, %r14d
leaq (%r12,%r14), %rdi
incq %rdi
callq 0x7100
testq %rax, %rax
je 0xbd99
movq %rax, %r13
testq %r12, %r12
je 0xbd9e
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x73f0
movq %r12, %rax
jmp 0xbda0
xorl %r13d, %r13d
jmp 0xbdcf
xorl %eax, %eax
testq %r14, %r14
je 0xbdbc
movq %r13, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x73f0
addq %r12, %r14
movq %r14, %rax
movb $0x0, (%r13,%rax)
testq %rbx, %rbx
je 0xbdcf
movq %rbx, %rdi
callq 0x7170
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/itoa.c
// Function: ft_itoa
char				*ft_itoa(int n)
{
	unsigned int	size;
	unsigned int	i;
	unsigned int	a;
	char			*tab1;

	i = n;
	size = ft_count(n);
	a = size;
	if (!(tab1 = malloc(sizeof(char) * (size + 1))))
		return (0);
	if (n == 0)
		tab1[0] = 0;
	if (n < 0)
	{
		i = -n;
	}
	while (a--)
	{
		tab1[a] = (i % 10) + '0';
		i = i / 10;
	}
	if (n < 0)
		tab1[0] = '-';
	tab1[size] = '\0';
	return (tab1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
je 0xbe40
movl %ebx, %eax
shrl $0x1f, %eax
movl %ebx, %ecx
negl %ecx
cmovsl %ebx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %ecx, %esi
imulq %rdx, %rsi
shrq $0x23, %rsi
incl %eax
cmpl $0x9, %ecx
movl %esi, %ecx
ja 0xbe28
movl %eax, %r14d
jmp 0xbe46
movl $0x1, %r14d
leal 0x1(%r14), %edi
callq 0x7100
testq %rax, %rax
je 0xbea0
testl %ebx, %ebx
jne 0xbe5b
movb $0x0, (%rax)
testq %r14, %r14
je 0xbe92
movl %ebx, %edx
negl %edx
cmovsl %ebx, %edx
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movq %r14, %rsi
movl %edx, %edi
imulq %rcx, %rdi
shrq $0x23, %rdi
leal (%rdi,%rdi), %r8d
leal (%r8,%r8,4), %r8d
subl %r8d, %edx
orb $0x30, %dl
movb %dl, -0x1(%rax,%rsi)
movl %edi, %edx
decq %rsi
jne 0xbe6f
testl %ebx, %ebx
jns 0xbe99
movb $0x2d, (%rax)
movb $0x0, (%rax,%r14)
jmp 0xbea2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/itoa_base.c
// Function: ft_count_base
size_t				ft_count_base(unsigned long c, char *base)
{
	unsigned int	i;
	unsigned int	a;
	unsigned long	d;

	a = ft_strlen(base);
	d = c;
	i = 0;
	if (c == 0)
		return (1);
	while (d != 0)
	{
		d = d / a;
		i++;
	}
	return (i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xbc3c
testq %rbx, %rbx
je 0xbed7
movl %eax, %ecx
xorl %esi, %esi
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
incl %esi
cmpq %rcx, %rbx
movq %rax, %rbx
jae 0xbec1
movl %esi, %eax
jmp 0xbedc
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/florianne1212[P]Cub3D_42/srcs/basic/itoa_base.c
// Function: ft_itoa_base
char				*ft_itoa_base(unsigned long nbr, char *base)
{
	unsigned int	size;
	unsigned long	i;
	unsigned int	a;
	char			*tab1;

	i = nbr;
	size = ft_count_base(nbr, base);
	a = size;
	if (!(tab1 = malloc(sizeof(char) * (size + 1))))
		return (0);
	if (nbr == 0)
		tab1[0] = 0;
	while (a--)
	{
		tab1[a] = base[i % ft_strlen(base)];
		i = i / ft_strlen(base);
	}
	tab1[size] = '\0';
	return (tab1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xbc3c
testq %r14, %r14
je 0xbf18
movl %eax, %esi
xorl %edi, %edi
movq %r14, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
incl %edi
cmpq %rsi, %rcx
movq %rax, %rcx
jae 0xbf01
movl %edi, %r12d
jmp 0xbf1e
movl $0x1, %r12d
leal 0x1(%r12), %edi
callq 0x7100
testq %rax, %rax
je 0xbf7e
movq %rax, %r15
testq %r14, %r14
jne 0xbf39
movb $0x0, (%r15)
testq %r12, %r12
je 0xbf77
movq %r12, %r13
movq %rbx, %rdi
callq 0xbc3c
movslq %eax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movb (%rbx,%rdx), %al
movb %al, -0x1(%r15,%r13)
movq %rbx, %rdi
callq 0xbc3c
movslq %eax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r14
decq %r13
jne 0xbf41
movb $0x0, (%r15,%r12)
jmp 0xbf81
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: ac(int, double)
void ac(int id, double t)
{
    if (!problems[id].acCount)
        ++distinctAc;
    ++problems[id].acCount;
    ++problems[id].totalCount;
    ++acCount;
    ++totalCount;
    ++combo;
    totalAcTime += t;
    problems[id].totalAcTime += t;
    printf("\033[44;42;1mAccepted\033[0m in %.2lf seconds.\n\n", t);
    waitAnyKey();
}

// Assembly:
movslq %edi, %rax
movq 0xbb6c(%rip), %rcx      # 0x2e4d0
leaq (%rax,%rax,4), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
cmpl $0x0, 0x48(%rcx,%rdx)
jne 0x2297d
incl 0xbb7f(%rip)            # 0x2e4fc
pushq %rbp
movq %rsp, %rbp
incl 0x48(%rax)
incl 0x4c(%rax)
incl 0xbb63(%rip)            # 0x2e4f0
incl 0xbb61(%rip)            # 0x2e4f4
incl 0xbb5f(%rip)            # 0x2e4f8
movsd 0xbb47(%rip), %xmm1     # 0x2e4e8
addsd %xmm0, %xmm1
movsd %xmm1, 0xbb3b(%rip)     # 0x2e4e8
movsd 0x40(%rax), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rax)
leaq 0x5932(%rip), %rdi      # 0x282f4
movb $0x1, %al
callq 0x2040
leaq 0x58ff(%rip), %rdi      # 0x282cf
callq 0x21f0
leaq 0x5909(%rip), %rdi      # 0x282e5
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: wa(int)
void wa(int id)
{
    ++problems[id].totalCount;
    ++totalCount;
    combo = 0;
    printf("\033[37;41;1mWrong Answer\033[0m, expected %s\n\n", problems[id].answer().c_str());
    waitAnyKey();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movslq %edi, %rax
movq 0xbadb(%rip), %rcx      # 0x2e4d0
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
incl 0x4c(%rcx,%rax)
incl 0xbae9(%rip)            # 0x2e4f4
movl $0x0, 0xbae3(%rip)      # 0x2e4f8
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x2313a
movq (%rbx), %rsi
leaq 0x58f4(%rip), %rdi      # 0x2831f
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
leaq -0x18(%rbp), %rax
cmpq %rax, %rdi
je 0x22a4a
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x2140
leaq 0x587e(%rip), %rdi      # 0x282cf
callq 0x21f0
leaq 0x5888(%rip), %rdi      # 0x282e5
callq 0x20f0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: quit()
void quit()
{
    for (const auto &problem : problems)
    {
        if (problem.acCount == problem.totalCount)
            continue;
        cerr << "AC Rate: " << problem.acCount << " / " << problem.totalCount << endl;
        cerr << problem << endl;
    }
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xba52(%rip), %rbx      # 0x2e4d0
movq 0xba53(%rip), %r15      # 0x2e4d8
cmpq %r15, %rbx
je 0x22b51
movq 0xa55b(%rip), %r14      # 0x2cff0
leaq 0x58b7(%rip), %r12      # 0x28353
movl 0x48(%rbx), %eax
cmpl 0x4c(%rbx), %eax
je 0x22b44
movl $0x9, %edx
movq %r14, %rdi
leaq 0x5892(%rip), %rsi      # 0x28349
callq 0x2160
movl 0x48(%rbx), %esi
movq %r14, %rdi
callq 0x2210
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2160
movl 0x4c(%rbx), %esi
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x231ed
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
addq $0x50, %rbx
cmpq %r15, %rbx
jne 0x22a9c
xorl %edi, %edi
callq 0x2190
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: ask(int)
void ask(int id)
{
    clearScreen();
    printf("distinct AC: %d / %d\tAC Rate: %d / %d\tCombo: %d\tAverageTime: %.2lf\n\n", distinctAc, (int)problems.size(), acCount, totalCount, combo, totalAcTime / acCount);
    problems[id].shuffle();
    cout << problems[id] << endl;

    auto startTime = chrono::steady_clock::now();
    string str;
    cin >> str;
    if (cin.fail() || str == "q")
        quit();
    auto endTime = chrono::steady_clock::now();

    if (problems[id].check(str))
        ac(id, 1.0 * chrono::duration_cast<chrono::milliseconds>(endTime - startTime).count() / 1000);
    else
        wa(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x5773(%rip), %rdi      # 0x282ee
callq 0x20f0
movl 0xb976(%rip), %esi      # 0x2e4fc
movq 0xb94b(%rip), %rax      # 0x2e4d8
subq 0xb93c(%rip), %rax      # 0x2e4d0
shrq $0x4, %rax
imull $0xcccccccd, %eax, %edx # imm = 0xCCCCCCCD
movl 0xb94c(%rip), %ecx      # 0x2e4f0
movl 0xb949(%rip), %r8d      # 0x2e4f4
movl 0xb946(%rip), %r9d      # 0x2e4f8
movsd 0xb92e(%rip), %xmm0     # 0x2e4e8
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
leaq 0x578e(%rip), %rdi      # 0x28357
movb $0x1, %al
callq 0x2040
movslq %ebx, %r13
movq 0xb8f6(%rip), %rax      # 0x2e4d0
movq %r13, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %r14
movq 0x20(%rax,%r14), %rdi
movq 0x28(%rax,%r14), %rsi
leaq 0xa552(%rip), %rdx      # 0x2d148
callq 0x2380f
addq 0xb8ce(%rip), %r14      # 0x2e4d0
movq 0xa3bf(%rip), %rdi      # 0x2cfc8
movq %r14, %rsi
callq 0x231ed
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
callq 0x21c0
movq %rax, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0xa377(%rip), %r15      # 0x2cfd8
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x21b0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x22d25
leaq 0x28d2(%rip), %rsi      # 0x25559
leaq -0x48(%rbp), %rdi
callq 0x2070
testl %eax, %eax
je 0x22d25
callq 0x21c0
movq %rax, %r15
leaq (,%r13,4), %rdi
addq %r13, %rdi
shlq $0x4, %rdi
addq 0xb81a(%rip), %rdi      # 0x2e4d0
leaq -0x48(%rbp), %rsi
callq 0x2330e
testb %al, %al
je 0x22cfa
subq %r14, %r15
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r15, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
cvtsi2sd %rdx, %xmm0
divsd 0x2317(%rip), %xmm0     # 0x25008
movl %ebx, %edi
callq 0x2295a
jmp 0x22d01
movl %ebx, %edi
callq 0x229e2
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x22d16
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x22a69
jmp 0x22d2e
jmp 0x22d2e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x22d46
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: main
int main()
{
    signal(SIGINT, signalHandler);

#ifdef _WIN32
    system("chcp 65001");
#endif

    clearScreen();
    puts("答题时请输入正确选项的编号，可能多选，编号间不带空格，顺序随意，输入 q 退出\n");
    puts("https://github.com/ouuan/Despised\n");
    waitAnyKey();

    for (int i = 0; i < (int)problems.size(); ++i)
        q.emplace(1.0 * rng() / rng.max(), i);

    while (true)
    {
        int u = q.top().second;
        q.pop();
        ask(u);
        q.emplace(problems[u].weight(), u);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq -0x20c(%rip), %rsi      # 0x22b58
movl $0x2, %edi
callq 0x2180
leaq 0x5579(%rip), %rdi      # 0x282ee
callq 0x20f0
leaq 0x561b(%rip), %rdi      # 0x2839c
callq 0x21f0
leaq 0x5680(%rip), %rdi      # 0x2840d
callq 0x21f0
leaq 0x5536(%rip), %rdi      # 0x282cf
callq 0x21f0
leaq 0x5540(%rip), %rdi      # 0x282e5
callq 0x20f0
movq 0xb727(%rip), %rax      # 0x2e4d8
subq 0xb718(%rip), %rax      # 0x2e4d0
movl $0x0, -0x24(%rbp)
shrq $0x4, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
jle 0x22e4b
leaq 0xa374(%rip), %rbx      # 0x2d148
leaq 0xb725(%rip), %r14      # 0x2e500
leaq -0x30(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %rbx, %rdi
callq 0x2348e
movq %rax, %xmm0
punpckldq 0x2228(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2230(%rip), %xmm0     # 0x25030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x21fc(%rip), %xmm1     # 0x25010
movsd %xmm1, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x23454
movl -0x24(%rbp), %eax
incl %eax
movq 0xb6a5(%rip), %rcx      # 0x2e4d8
subq 0xb696(%rip), %rcx      # 0x2e4d0
movl %eax, -0x24(%rbp)
shrq $0x4, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
cmpl %ecx, %eax
jl 0x22de3
leaq 0xb6ae(%rip), %rbx      # 0x2e500
leaq -0x30(%rbp), %r14
leaq -0x24(%rbp), %r15
movq 0xb69f(%rip), %rax      # 0x2e500
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
callq 0x234fa
movl -0x24(%rbp), %edi
callq 0x22b61
movslq -0x24(%rbp), %rax
leaq (%rax,%rax,4), %rdi
shlq $0x4, %rdi
addq 0xb646(%rip), %rdi      # 0x2e4d0
callq 0x2354c
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x23454
jmp 0x22e5a
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: Problem::Problem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Option, std::allocator<Option>> const&)
Problem(const string &_statement, const vector<Option> &_options) : statement(_statement), options(_options), multianswer(false), totalAcTime(0), acCount(0), totalCount(0)
    {
        int answerCnt = 0;
        for (Option option : options)
        {
            answerCnt += option.correct;
        }
        if (answerCnt > 1)
        {
            multianswer = true;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x235ce
leaq 0x20(%rbx), %rdi
movq %rdi, -0x40(%rbp)
movq %r15, %rsi
callq 0x23676
movb $0x0, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %r12
cmpq %r12, %r13
je 0x22fa5
movq %r14, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
xorl %r14d, %r14d
leaq -0x58(%rbp), %rbx
movq %rbx, -0x68(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x235ce
movzbl 0x20(%r13), %r15d
movb %r15b, -0x48(%rbp)
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x22f8b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2140
addl %r15d, %r14d
addq $0x28, %r13
cmpq %r12, %r13
jne 0x22f55
cmpl $0x1, %r14d
movq -0x38(%rbp), %rax
jbe 0x22fa5
movb $0x1, 0x38(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, -0x30(%rbp)
movq %rbx, -0x38(%rbp)
movq %rax, %r15
jmp 0x22fcd
movq %rax, %r15
movq -0x40(%rbp), %rdi
callq 0x23074
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x22fe9
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2140
movq %r15, %rdi
callq 0x2220
nop
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: Problem::answer[abi:cxx11]() const
string answer() const
    {
        string res;

        for (int i = 0; i < (int)options.size(); ++i)
        {
            if (options[i].correct)
            {
                res.push_back(i + '1');
            }
        }

        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
testl %ecx, %ecx
jle 0x231bd
movq %rsi, %r14
movl $0x20, %r12d
xorl %r13d, %r13d
cmpb $0x1, (%rax,%r12)
jne 0x23199
leal 0x31(%r13), %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2100
incq %r13
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xcccccccd, %ecx, %ecx # imm = 0xCCCCCCCD
movslq %ecx, %rcx
addq $0x28, %r12
cmpq %rcx, %r13
jl 0x23183
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x231e5
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: operator<<(std::ostream&, Problem const&)
ostream &operator<<(ostream &os, const Problem &problem)
    {
        if (problem.multianswer)
        {
            os << "\033[34m[多选题]\033[0m ";
        }
        os << problem.statement << endl;
        for (int i = 0; i < (int)problem.options.size(); ++i)
            os << i + 1 << ") " << problem.options[i].text << endl;
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x38(%rsi)
jne 0x2321b
leaq 0x524c(%rip), %rsi      # 0x2845a
movl $0x15, %edx
movq %rbx, %rdi
callq 0x2160
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x28(%r14), %rax
subq 0x20(%r14), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
testl %eax, %eax
jle 0x232fc
movl $0x8, %r12d
xorl %r15d, %r15d
incq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2210
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x51d9(%rip), %rsi      # 0x28470
callq 0x2160
movq 0x20(%r14), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %r13, %rdi
callq 0x2160
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
movq 0x28(%r14), %rax
subq 0x20(%r14), %rax
shrq $0x3, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
cltq
addq $0x28, %r12
cmpq %rax, %r15
jl 0x23277
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ouuan[P]Despised/main.cpp
// Function: Problem::check(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool check(const string &str) const
    {
        set<int> user, correct;

        for (int i = 0; i < (int)options.size(); ++i)
        {
            if (options[i].correct)
            {
                correct.insert(i);
            }
        }

        for (auto c : str)
            user.insert(c - '1');

        return correct == user;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
leaq -0x88(%rbp), %rcx
xorl %eax, %eax
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movl %eax, -0x2c(%rbp)
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xcccccccd, %edx, %edx # imm = 0xCCCCCCCD
testl %edx, %edx
jle 0x233b3
movq %rdi, %r15
leaq -0x60(%rbp), %r12
leaq -0x2c(%rbp), %r13
cltq
leaq (%rax,%rax,4), %rax
cmpb $0x1, 0x20(%rcx,%rax,8)
jne 0x23392
movq %r12, %rdi
movq %r13, %rsi
callq 0x23ce8
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq 0x20(%r15), %rcx
movq 0x28(%r15), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xcccccccd, %edx, %edx # imm = 0xCCCCCCCD
cmpl %edx, %eax
jl 0x2337a
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x233eb
movq (%r14), %r13
xorl %ebx, %ebx
leaq -0x90(%rbp), %r14
leaq -0x2c(%rbp), %r15
movsbl (%r13,%rbx), %eax
addl $-0x31, %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x23e10
incq %rbx
cmpq %rbx, %r12
jne 0x233cc
movq -0x38(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x2340a
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x23ec8
movl %eax, %ebx
jmp 0x2340c
xorl %ebx, %ebx
leaq -0x60(%rbp), %rdi
callq 0x23f22
leaq -0x90(%rbp), %rdi
callq 0x23f22
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23434
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23f22
leaq -0x90(%rbp), %rdi
callq 0x23f22
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]filler_42/srcs/main.c
// Function: main
int		main(int ac, char **av)
{
	t_game				game;
	char				*line;
	static	t_process	process[] = {get_player, get_size,
									get_board_first_line, get_board,
									get_size, get_piece, speak, error};

	(void)ac;
	ft_bzero(&game, sizeof(game));
	game.action = E_GET_PLAYER;
	game.process_name = av[0];
	line = NULL;
	while (get_next_line(0, &line) > 0)
	{
		process[game.action](&game, &line);
		ft_strdel(&line);
	}
	ft_strdel(&line);
	free_matrix(&game.board);
	return (SUCCESS);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movl $0xb0, %esi
movq %r14, %rdi
callq 0x2864
movl $0x0, 0x28(%r14)
movq (%rbx), %rax
movq %rax, (%r14)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
xorl %edi, %edi
callq 0x290c
testl %eax, %eax
jle 0x11f7
leaq 0x9bc7(%rip), %r15      # 0xad90
leaq 0x10(%rsp), %rbx
leaq 0x8(%rsp), %r14
movl 0x38(%rsp), %eax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%r15,%rax,8)
movq %r14, %rdi
callq 0x2818
xorl %edi, %edi
movq %r14, %rsi
callq 0x290c
testl %eax, %eax
jg 0x11d3
leaq 0x8(%rsp), %rdi
callq 0x2818
leaq 0x18(%rsp), %rdi
callq 0x1a94
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]filler_42/srcs/action.c
// Function: get_player
void	get_player(t_game *game, char **line)
{
	if (ft_strnequ(*line, PLAYER_ONE, PLAYER_SIZE) == TRUE
			&& (ft_strstr(*line, game->process_name) != NULL))
	{
		game->my_char = P1_CHAR;
		game->my_last_char = P1_LAST_CHAR;
		game->adv_char = P2_CHAR;
		game->adv_last_char = P2_LAST_CHAR;
		game->action = E_GET_BOARD_SIZE;
	}
	else if (ft_strnequ(*line, PLAYER_TWO, PLAYER_SIZE) == TRUE
			&& (ft_strstr(*line, game->process_name) != NULL))
	{
		game->my_char = P2_CHAR;
		game->my_last_char = P2_LAST_CHAR;
		game->adv_char = P1_CHAR;
		game->adv_last_char = P1_LAST_CHAR;
		game->action = E_GET_BOARD_SIZE;
	}
	else
		error(game, line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x5dd4(%rip), %rsi      # 0x7004
movl $0xf, %edx
callq 0x26ec
cmpl $0x1, %eax
jne 0x1258
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2780
testq %rax, %rax
je 0x1258
movl $0x6f4f7858, 0x34(%rbx) # imm = 0x6F4F7858
jmp 0x1288
movq (%r14), %rdi
leaq 0x5db2(%rip), %rsi      # 0x7014
movl $0xf, %edx
callq 0x26ec
cmpl $0x1, %eax
jne 0x1297
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2780
testq %rax, %rax
je 0x1297
movl $0x78586f4f, 0x34(%rbx) # imm = 0x78586F4F
movl $0x1, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ade
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]filler_42/srcs/action.c
// Function: get_size
void	get_size(t_game *game, char **line)
{
	game->row = 0;
	if (game->action == E_GET_PIECE_SIZE)
	{
		if (process_size(&game->piece.size, &game->piece.mx, *line, PIECE)
				== FAILURE)
			error(game, line);
		else
			game->action = E_GET_PIECE;
	}
	else
	{
		if (process_size(&game->board.size, &game->board.mx, *line, PLATEAU)
				== FAILURE)
			error(game, line);
		else
			game->action = E_GET_BOARD_FIRST_LINE;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x30(%rdi)
cmpl $0x4, 0x28(%rdi)
movq (%rsi), %rdx
jne 0x12e6
leaq 0x18(%r14), %rdi
leaq 0x20(%r14), %rsi
leaq 0x5d52(%rip), %rcx      # 0x7024
callq 0x1434
cmpl $-0x1, %eax
je 0x130f
movl $0x5, 0x28(%r14)
jmp 0x1307
leaq 0x8(%r14), %rdi
leaq 0x10(%r14), %rsi
leaq 0x5d35(%rip), %rcx      # 0x702a
callq 0x1434
cmpl $-0x1, %eax
je 0x130f
movl $0x2, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ade
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]filler_42/srcs/action.c
// Function: get_board
void	get_board(t_game *game, char **line)
{
	if (game->row + 1 == game->board.size.x)
	{
		if (get_line_board(game, *line) == FAILURE)
			error(game, line);
		else
			game->action = E_GET_PIECE_SIZE;
	}
	else if (get_line_board(game, *line) == FAILURE)
		error(game, line);
	else
		game->row++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x30(%rdi), %ebp
incl %ebp
movl 0x8(%rdi), %r15d
movq (%rsi), %rsi
callq 0x159c
cmpl %r15d, %ebp
jne 0x138e
cmpl $-0x1, %eax
je 0x13a2
movl $0x4, 0x28(%r14)
jmp 0x1397
cmpl $-0x1, %eax
je 0x13a2
incl 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ade
// File: /workspace/github_c_makefile_star2_O1/ffoissey[P]filler_42/srcs/action.c
// Function: get_piece
void	get_piece(t_game *game, char **line)
{
	if (game->row + 1 == game->piece.size.x)
	{
		if (get_line_piece(game, *line) == FAILURE)
			error(game, line);
		else
		{
			if (game->turn == 0)
				get_angle(game);
			ft_process(game);
			speak(game, line);
			game->action = E_GET_BOARD_SIZE;
		}
	}
	else if (get_line_piece(game, *line) == FAILURE)
		error(game, line);
	else
		game->row++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rdi), %ebp
incl %ebp
movl 0x18(%rdi), %r15d
movq (%rsi), %rsi
callq 0x17cf
cmpl %r15d, %ebp
jne 0x140c
cmpl $-0x1, %eax
je 0x141f
cmpl $0x0, 0xa4(%rbx)
jne 0x13f0
movq %rbx, %rdi
callq 0x2282
movq %rbx, %rdi
callq 0x1854
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a5c
movl $0x1, 0x28(%rbx)
jmp 0x1414
cmpl $-0x1, %eax
je 0x141f
incl 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1ade
// File: /workspace/github_c_makefile_star2_O1/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 0x2864
movq %rbx, %rdi
callq 0x2804
movslq %eax, %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x26ec
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x151e
addq %r13, %r12
xorl %ebp, %ebp
movzbl (%r12), %eax
testl %eax, %eax
je 0x151e
cmpl $0x3a, %eax
je 0x14d3
cmpb $0x20, %al
jne 0x151e
cmpb $0x1, %bpl
ja 0x151e
leaq 0x1(%r12), %rdi
callq 0x28b0
testb %bpl, %bpl
je 0x14b8
movl %eax, 0x4(%rsp)
jmp 0x14bb
movl %eax, (%rsp)
movsbl 0x1(%r12), %edi
incq %r12
callq 0x2858
cmpl $0x1, %eax
je 0x14bb
incb %bpl
jmp 0x1483
cmpb $0x0, 0x1(%r12)
jne 0x151e
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
testl %eax, %eax
sete %dl
testl %ecx, %ecx
sete %sil
orb %dl, %sil
jne 0x151e
cmpl $0x0, (%r15)
jne 0x151c
cmpl $0x0, 0x4(%r15)
jne 0x151c
movl %eax, (%r15)
movl %ecx, 0x4(%r15)
cmpq $0x0, (%r14)
jne 0x151c
movq %rsp, %rsi
movq %r14, %rdi
callq 0x152f
cmpl $-0x1, %eax
je 0x151e
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq (%rsi), %r12
leaq (,%r12,8), %rdi
callq 0x1070
movq %rax, (%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x158e
testl %r12d, %r12d
jle 0x158c
movslq 0x4(%r15), %r15
shlq $0x2, %r15
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x1070
movq (%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq (%r14), %rax
cmpq $0x0, (%rax,%r13,8)
je 0x158e
incq %r13
cmpq %r13, %r12
jne 0x156b
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2804
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, 0x1c(%r14)
jl 0x1849
movl 0x30(%r14), %ecx
cmpl 0x18(%r14), %ecx
jg 0x1849
movb (%rbx), %dil
testb %dil, %dil
je 0x1847
movq 0x20(%r14), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %r8d, %r8d
cmpb $0x2a, %dil
setne %r8b
addl $0x5, %r8d
cmpb $0x2e, %dil
cmovel %edx, %r8d
movslq 0x30(%r14), %rdi
movq (%rcx,%rdi,8), %rdi
movl %r8d, (%rdi,%rsi,4)
movslq 0x30(%r14), %rdi
movq (%rcx,%rdi,8), %rdi
cmpl $0x6, (%rdi,%rsi,4)
je 0x1849
movb 0x1(%rbx,%rsi), %dil
incq %rsi
testb %dil, %dil
jne 0x1809
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2864
movq %rbx, %rdi
callq 0x2623
movq %rax, 0x40(%rbx)
movq %rbx, %rdi
callq 0x23d1
movq %rbx, %rdi
callq 0x20da
movl 0x18(%rbx), %r15d
movl 0x8(%rbx), %ebp
addl %r15d, %ebp
negl %r15d
cmpl %r15d, %ebp
jle 0x1a09
movl 0x2c(%rbx), %eax
leaq 0x9519(%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 0x19fd
movl %r15d, %eax
movq %rax, 0x10(%rsp)
movq %r14, %r13
movslq 0x18(%rbx), %rax
testq %rax, %rax
jle 0x19f1
movl 0x1c(%rbx), %ecx
xorl %edx, %edx
xorl %esi, %esi
testl %ecx, %ecx
jle 0x19a2
leal (%r15,%rdx), %edi
xorl %r8d, %r8d
testl %edi, %edi
js 0x1949
leaq (%r8,%r13), %r9
testl %r9d, %r9d
js 0x1949
cmpl 0x8(%rbx), %edi
jge 0x1949
cmpl 0xc(%rbx), %r9d
jge 0x1949
movq 0x10(%rbx), %r10
movq (%r10,%rdi,8), %r10
movl %r9d, %r11d
movl (%r10,%r11,4), %r11d
leal -0x1(%r11), %r10d
cmpl $0x1, %r10d
ja 0x196d
movq 0x20(%rbx), %r10
movq (%r10,%rdx,8), %r10
cmpl $0x5, (%r10,%r8,4)
movb $0x1, %r10b
jne 0x1970
jmp 0x195a
movq 0x20(%rbx), %r9
movq (%r9,%rdx,8), %r9
cmpl $0x5, (%r9,%r8,4)
sete %r10b
testb %r10b, %r10b
jne 0x19f1
incq %r8
cmpq %r8, %rcx
jne 0x1904
jmp 0x19a2
movb $0x1, %r10b
cmpl $0x1, %esi
jg 0x195a
addl $-0x3, %r11d
cmpl $0x1, %r11d
ja 0x199d
movq 0x20(%rbx), %r10
movq (%r10,%rdx,8), %r10
cmpl $0x5, (%r10,%r8,4)
jne 0x199d
movl %edi, 0x8c(%rbx)
movl %r9d, 0x90(%rbx)
incl %esi
xorl %r10d, %r10d
jmp 0x195a
incq %rdx
cmpq %rax, %rdx
jne 0x18f5
cmpl $0x1, %esi
jne 0x19f1
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x19c6
cmpl $0x0, 0xa0(%rbx)
je 0x19d0
movq %rbx, %rdi
callq *(%rsp)
cmpb $0x1, %al
jne 0x19f1
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 0x18e1
incl %r15d
cmpl %ebp, %r15d
jne 0x18cd
leaq 0x8c(%rbx), %r14
movq 0x8c(%rbx), %rax
movq %rax, 0x48(%rbx)
leaq 0x38(%rbx), %rdi
movl $0x8, %esi
callq 0x2864
leaq 0x94(%rbx), %rdi
movl $0x8, %esi
callq 0x2864
movl $0x8, %esi
movq %r14, %rdi
callq 0x2864
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_O1/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 0x2818
leaq 0x18(%rbx), %rdi
callq 0x1a94
movl 0x9c(%rbx), %esi
movl 0xa0(%rbx), %edx
leaq 0x55ae(%rip), %rdi      # 0x7032
xorl %eax, %eax
callq 0x2d01
movl $0x1, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ac7
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 0x1aa3
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_O1/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 0x2818
leaq 0x18(%rbx), %rdi
callq 0x1a94
leaq 0x8(%rbx), %rdi
callq 0x1a94
movl $0x7, 0x28(%rbx)
cmpl $0x0, 0xa8(%rbx)
je 0x1b0e
popq %rbx
retq
movl $0x1, 0xa8(%rbx)
leaq 0x551a(%rip), %rdi      # 0x7039
movl $0x2, %esi
popq %rbx
jmp 0x2874
// File: /workspace/github_c_makefile_star2_O1/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 0x2804
cmpq %r14, %rax
jne 0x1bba
xorl %eax, %eax
cmpb $0x20, (%rbx,%rax)
jne 0x1bba
incq %rax
cmpq $0x4, %rax
jne 0x1b5a
movb $0x1, %cl
cmpl $0x5, %r14d
jb 0x1bbc
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 0x1bba
incq %rsi
incq %rdi
incq %r8
cmpq %rdi, %r14
jne 0x1b88
jmp 0x1bbc
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x216c
testl %eax, %eax
jne 0x1c0c
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
testl %eax, %eax
je 0x1c1f
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 0x216c
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1c0e
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
cmpl $0x1, %eax
je 0x1c0e
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 0x1b2a
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a
cmpl %r13d, %r12d
jge 0x1ca1
cmpl %eax, %r14d
jg 0x1c0c
jmp 0x1c0e
cmpl %eax, %r14d
jge 0x1c0c
jmp 0x1c0e
// File: /workspace/github_c_makefile_star2_O1/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 0x216c
testl %eax, %eax
jne 0x1cef
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
testl %eax, %eax
je 0x1cfe
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 0x1cf1
movq %rbx, %rdi
movq %r15, %rsi
movl $0x3, %edx
movl $0x5, %ecx
callq 0x216c
cmpl $0x1, %eax
je 0x1cf1
movl 0x8(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, 0x40(%rbx)
jle 0x1d55
movl 0x50(%rbx), %eax
cmpl 0x58(%rbx), %eax
jle 0x1d80
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2a
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a
cmpl %eax, %r14d
jg 0x1cef
jmp 0x1cf1
addq $0x78, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2a
movl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a
cmpl %eax, %r14d
jge 0x1cef
jmp 0x1cf1