LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xead0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xef1c
movq $0x1, -0x8(%rbp)
jmp 0xef47
jmp 0xef1e
cmpq $0x0, -0x28(%rbp)
je 0xef40
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xef1e
movl -0x1c(%rbp), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xeee0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x7100
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xefb8
movq $0x0, -0x8(%rbp)
jmp 0xf048
cmpq $0x0, -0x10(%rbp)
jne 0xefc6
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
jmp 0xefc8
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x0, %eax
je 0xf035
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xead0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq -0x48(%rbp), %rax
movb (%rax,%rdx), %dl
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xead0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
jmp 0xefc8
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0x1298d(%rip), %rdi     # 0x3b568
callq 0x29740
cmpl $0x0, 0x48(%rax)
jne 0x28bf5
movl 0x129a8(%rip), %eax     # 0x3b594
addl $0x1, %eax
movl %eax, 0x1299f(%rip)     # 0x3b594
movslq -0x4(%rbp), %rsi
leaq 0x12968(%rip), %rdi     # 0x3b568
callq 0x29740
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movslq -0x4(%rbp), %rsi
leaq 0x1294f(%rip), %rdi     # 0x3b568
callq 0x29740
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
movl 0x1295b(%rip), %eax     # 0x3b588
addl $0x1, %eax
movl %eax, 0x12952(%rip)     # 0x3b588
movl 0x12950(%rip), %eax     # 0x3b58c
addl $0x1, %eax
movl %eax, 0x12947(%rip)     # 0x3b58c
movl 0x12945(%rip), %eax     # 0x3b590
addl $0x1, %eax
movl %eax, 0x1293c(%rip)     # 0x3b590
movsd -0x10(%rbp), %xmm0
addsd 0x1291f(%rip), %xmm0    # 0x3b580
movsd %xmm0, 0x12917(%rip)    # 0x3b580
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0x128ea(%rip), %rdi     # 0x3b568
callq 0x29740
movsd -0x18(%rbp), %xmm0
addsd 0x40(%rax), %xmm0
movsd %xmm0, 0x40(%rax)
movsd -0x10(%rbp), %xmm0
leaq 0x9656(%rip), %rdi      # 0x322f4
movb $0x1, %al
callq 0x2040
callq 0x28b80
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0x128a2(%rip), %rdi     # 0x3b568
movq %rdi, -0x48(%rbp)
callq 0x29740
movq -0x48(%rbp), %rdi
movl 0x4c(%rax), %ecx
incl %ecx
movl %ecx, 0x4c(%rax)
movl 0x128ab(%rip), %eax     # 0x3b58c
incl %eax
movl %eax, 0x128a3(%rip)     # 0x3b58c
movl $0x0, 0x1289d(%rip)     # 0x3b590
movslq -0x4(%rbp), %rsi
callq 0x29740
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x29760
movq -0x40(%rbp), %rdi
callq 0x20b0
movq %rax, %rsi
leaq 0x9600(%rip), %rdi      # 0x3231f
xorl %eax, %eax
callq 0x2040
jmp 0x28d28
leaq -0x28(%rbp), %rdi
callq 0x2110
callq 0x28b80
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2110
movq -0x30(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
leaq 0x127f9(%rip), %rax     # 0x3b568
movq %rax, -0x8(%rbp)
leaq 0x127ee(%rip), %rdi     # 0x3b568
callq 0x29830
movq %rax, -0x10(%rbp)
leaq 0x127de(%rip), %rdi     # 0x3b568
callq 0x29860
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x29890
testb $0x1, %al
jne 0x28da9
jmp 0x28e44
leaq -0x10(%rbp), %rdi
callq 0x298d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
jne 0x28dc8
jmp 0x28e36
movq 0x11221(%rip), %rdi     # 0x39ff0
leaq 0x9573(%rip), %rsi      # 0x32349
callq 0x21c0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x955f(%rip), %rsi      # 0x32353
callq 0x21c0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %esi
callq 0x2310
movq %rax, %rdi
movq 0x111a6(%rip), %rsi     # 0x39fb8
callq 0x2200
movq -0x20(%rbp), %rsi
movq 0x111ce(%rip), %rdi     # 0x39ff0
callq 0x298f0
movq %rax, %rdi
movq 0x11187(%rip), %rsi     # 0x39fb8
callq 0x2200
leaq -0x10(%rbp), %rdi
callq 0x299c0
jmp 0x28d93
xorl %edi, %edi
callq 0x2270
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2, %edi
leaq -0x23b(%rip), %rsi      # 0x28e50
callq 0x2260
callq 0x28ba0
leaq 0x9300(%rip), %rdi      # 0x3239c
callq 0x22f0
leaq 0x9365(%rip), %rdi      # 0x3240d
callq 0x22f0
callq 0x28b80
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0x124a2(%rip), %rdi     # 0x3b568
callq 0x299e0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x2916e
leaq 0x11100(%rip), %rdi     # 0x3a1e0
callq 0x29d80
movq %rax, %xmm0
movaps 0x5f2f(%rip), %xmm1     # 0x2f020
movaps %xmm1, -0x50(%rbp)
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x5f2f(%rip), %xmm1     # 0x2f030
movaps %xmm1, -0x40(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x29e40
movaps -0x50(%rbp), %xmm3
movaps -0x40(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq 0x12445(%rip), %rdi     # 0x3b598
leaq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0x29d20
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x290b9
jmp 0x29170
leaq 0x12421(%rip), %rdi     # 0x3b598
callq 0x29e50
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
leaq 0x1240f(%rip), %rdi     # 0x3b598
callq 0x29e70
movl -0x14(%rbp), %edi
callq 0x28e70
movslq -0x14(%rbp), %rsi
leaq 0x123c7(%rip), %rdi     # 0x3b568
callq 0x29740
movq %rax, %rdi
callq 0x29ec0
movsd %xmm0, -0x20(%rbp)
leaq 0x123de(%rip), %rdi     # 0x3b598
leaq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x29d20
jmp 0x29170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0x20c0
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
movq -0x18(%rbp), %rsi
callq 0x29fc0
jmp 0x29416
movq -0x80(%rbp), %rax
movb $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
movl $0x0, 0x48(%rax)
movl $0x0, 0x4c(%rax)
movl $0x0, -0x28(%rbp)
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2a0b0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2a0e0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2a110
testb $0x1, %al
jne 0x29470
jmp 0x294ce
leaq -0x38(%rbp), %rdi
callq 0x2a150
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x2a170
jmp 0x29487
movb -0x48(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x29670
leaq -0x38(%rbp), %rdi
callq 0x2a1b0
jmp 0x2945d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x294e5
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x295f0
jmp 0x294e5
cmpl $0x1, -0x28(%rbp)
jle 0x294dc
movq -0x80(%rbp), %rax
movb $0x1, 0x38(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x2110
movq -0x20(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x22c0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x20, %rdi
callq 0x2a1d0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x29801
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x2ab60
testb $0x1, 0x20(%rax)
je 0x297f4
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x31, %eax
movsbl %al, %esi
callq 0x2180
jmp 0x297db
jmp 0x297f4
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0x2981e
jmp 0x297f6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x29793
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x29814
movq -0x40(%rbp), %rdi
callq 0x2110
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x38(%rax)
je 0x2991a
movq -0x8(%rbp), %rdi
leaq 0x8b1b(%rip), %rsi      # 0x32430
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x10687(%rip), %rsi     # 0x39fb8
callq 0x2200
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2a1d0
movq %rax, %rcx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x299b3
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x2310
movq %rax, %rdi
leaq 0x8ad3(%rip), %rsi      # 0x32446
callq 0x21c0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x2ab60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x10615(%rip), %rsi     # 0x39fb8
callq 0x2200
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2993d
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2b430
leaq -0x70(%rbp), %rdi
callq 0x2b430
movl $0x0, -0x74(%rbp)
movq -0xd0(%rbp), %rdi
movl -0x74(%rbp), %eax
movl %eax, -0xd4(%rbp)
addq $0x20, %rdi
callq 0x2a1d0
movq %rax, %rcx
movl -0xd4(%rbp), %eax
cmpl %ecx, %eax
jge 0x29b79
movq -0xd0(%rbp), %rdi
addq $0x20, %rdi
movslq -0x74(%rbp), %rsi
callq 0x2ab60
testb $0x1, 0x20(%rax)
je 0x29b69
leaq -0x70(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x2b450
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x29b27
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
jmp 0x29b69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2b5a0
leaq -0x40(%rbp), %rdi
callq 0x2b5a0
jmp 0x29c69
jmp 0x29b6b
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x29ac7
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x21b0
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x2350
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2b4a0
testb $0x1, %al
jne 0x29bc3
jmp 0x29c31
leaq -0xa8(%rbp), %rdi
callq 0x2b4e0
movb (%rax), %al
movb %al, -0xb1(%rbp)
movsbl -0xb1(%rbp), %eax
addl $-0x31, %eax
movl %eax, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x2b500
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x29c06
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movb %al, -0xc0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2b550
jmp 0x29baa
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2b570
movb %al, -0xf2(%rbp)
jmp 0x29c46
leaq -0x70(%rbp), %rdi
callq 0x2b5a0
leaq -0x40(%rbp), %rdi
callq 0x2b5a0
movb -0xf2(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xc0(%rbp), %rdi
movl $0xb0, %esi
callq 0x3910
movl $0x0, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0xc8(%rbp)
xorl %edi, %edi
leaq -0xc8(%rbp), %rsi
callq 0x3ac0
cmpl $0x0, %eax
jle 0x11fe
movl -0x98(%rbp), %eax
movl %eax, %ecx
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
leaq 0xde63(%rip), %rax      # 0xf050
callq *(%rax,%rcx,8)
leaq -0xc8(%rbp), %rdi
callq 0x3830
jmp 0x11bd
leaq -0xc8(%rbp), %rdi
callq 0x3830
leaq -0xc0(%rbp), %rdi
addq $0x8, %rdi
callq 0x2150
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x9db6(%rip), %rsi      # 0xb004
movl $0xf, %edx
callq 0x35c0
cmpl $0x1, %eax
jne 0x12a3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x36d0
cmpq $0x0, %rax
je 0x12a3
movq -0x8(%rbp), %rax
movb $0x4f, 0x36(%rax)
movq -0x8(%rbp), %rax
movb $0x6f, 0x37(%rax)
movq -0x8(%rbp), %rax
movb $0x58, 0x34(%rax)
movq -0x8(%rbp), %rax
movb $0x78, 0x35(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x1315
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x9d63(%rip), %rsi      # 0xb014
movl $0xf, %edx
callq 0x35c0
cmpl $0x1, %eax
jne 0x1306
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x36d0
cmpq $0x0, %rax
je 0x1306
movq -0x8(%rbp), %rax
movb $0x58, 0x36(%rax)
movq -0x8(%rbp), %rax
movb $0x78, 0x37(%rax)
movq -0x8(%rbp), %rax
movb $0x4f, 0x34(%rax)
movq -0x8(%rbp), %rax
movb $0x6f, 0x35(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x1313
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x1315
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x4, 0x28(%rax)
jne 0x138d
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x9cbd(%rip), %rcx      # 0xb024
callq 0x1580
cmpl $-0x1, %eax
jne 0x1380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x138b
movq -0x8(%rbp), %rax
movl $0x5, 0x28(%rax)
jmp 0x13d5
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x9c7b(%rip), %rcx      # 0xb02a
callq 0x1580
cmpl $-0x1, %eax
jne 0x13c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x13d3
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
jmp 0x13d5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1484
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1830
cmpl $-0x1, %eax
jne 0x1477
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x1482
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
jmp 0x14b7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1830
cmpl $-0x1, %eax
jne 0x14a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x14b5
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x14b7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x1540
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1a30
cmpl $-0x1, %eax
jne 0x1507
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x153e
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x151d
movq -0x8(%rbp), %rdi
callq 0x2f30
movq -0x8(%rbp), %rdi
callq 0x1c90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x20f0
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x1573
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1a30
cmpl $-0x1, %eax
jne 0x1564
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
jmp 0x1571
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0x1573
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x3910
movq -0x28(%rbp), %rdi
callq 0x37e0
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x35c0
cmpl $0x0, %eax
jne 0x15d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x166c
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1680
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1603
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x166c
cmpl $0x0, -0x30(%rbp)
je 0x160f
cmpl $0x0, -0x2c(%rbp)
jne 0x1618
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x166c
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1665
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1665
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1663
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1780
cmpl $-0x1, %eax
jne 0x1663
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x166c
jmp 0x1665
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/get_size.c
// Function: check_size_format
static unsigned char	check_size_format(char *line, t_point *size)
{
	unsigned char count;

	count = 0;
	while (*line != '\0' && *line != ':')
	{
		if (*line != ' ' || count >= 2)
			return (FALSE);
		line++;
		if (count == 0)
			size->x = ft_atoi(line);
		else
			size->y = ft_atoi(line);
		while (ft_isdigit(*line) == TRUE)
			line++;
		count++;
	}
	return (*line == ':' && *(line + 1) == '\0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0x16b5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x16c1
jmp 0x1747
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x16d6
movzbl -0x19(%rbp), %eax
cmpl $0x2, %eax
jl 0x16df
movb $0x0, -0x1(%rbp)
jmp 0x1774
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0x1707
movq -0x10(%rbp), %rdi
callq 0x39b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1719
movq -0x10(%rbp), %rdi
callq 0x39b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x171b
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x38e0
cmpl $0x1, %eax
jne 0x173a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x171b
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x1694
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x1b(%rbp)
jne 0x1769
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x17c4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1821
jmp 0x17c6
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x181a
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x180f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1821
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17c6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/get_board.c
// Function: get_line_board
int						get_line_board(t_game *game, char *line)
{
	size_t	y;
	char	row_str[5];

	y = 0;
	row_str[4] = '\0';
	row_str[3] = ' ';
	row_str[2] = game->row % 10 + '0';
	row_str[1] = (game->row / 10) % 10 + '0';
	row_str[0] = game->row / 100 + '0';
	if (ft_strnequ(row_str, line, 4) == FALSE)
		return (FAILURE);
	line += 4;
	if (((int)ft_strlen(line) != game->board.size.y)
			|| (game->row > game->board.size.x))
		return (FAILURE);
	while (line[y] != '\0')
	{
		game->board.mx[game->row][y] = board_char_is_ok(game,
											line[y], game->row, y);
		if (game->board.mx[game->row][y] == E_UNKNOW)
			return (FAILURE);
		y++;
	}
	return (SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x20, -0x22(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, -0x23(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movb %dl, %al
movb %al, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl $0x64, %ecx
cltd
idivl %ecx
addl $0x30, %eax
movb %al, -0x25(%rbp)
leaq -0x25(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x35c0
cmpl $0x0, %eax
jne 0x18be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1989
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37e0
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x18ec
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x18f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1989
jmp 0x18fa
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1982
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %edx
movq -0x20(%rbp), %rcx
movsbl %al, %esi
callq 0x19a0
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
cmpl $0x6, (%rax,%rcx,4)
jne 0x1971
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1989
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x18fa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/get_board.c
// Function: board_char_is_ok
static enum e_state		board_char_is_ok(t_game *game, char c, int x, int y)
{
	t_point	pos;

	pos.x = x;
	pos.y = y;
	if (c == EMPTY)
		return (E_EMPTY);
	else if (c == P1_CHAR || c == P2_CHAR
			|| c == P1_LAST_CHAR || c == P2_LAST_CHAR)
		return (which_char(game, c, pos));
	else
		return (E_UNKNOW);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x2e, %eax
jne 0x19d6
movl $0x0, -0x4(%rbp)
jmp 0x1a19
movsbl -0x11(%rbp), %eax
cmpl $0x4f, %eax
je 0x19fa
movsbl -0x11(%rbp), %eax
cmpl $0x58, %eax
je 0x19fa
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
je 0x19fa
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
jne 0x1a12
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movq -0x24(%rbp), %rdx
movsbl %al, %esi
callq 0x1b40
movl %eax, -0x4(%rbp)
jmp 0x1a19
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37e0
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x1a6a
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jle 0x1a73
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1af0
jmp 0x1a75
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1ae9
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1b00
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
cmpl $0x6, (%rax,%rcx,4)
jne 0x1adb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1af0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1a75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/get_board.c
// Function: piece_char_is_ok
static enum e_state		piece_char_is_ok(char c)
{
	if (c == EMPTY)
		return (E_EMPTY);
	else if (c == FULL)
		return (E_FULL);
	else
		return (E_UNKNOW);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x2e, %eax
jne 0x1b1c
movl $0x0, -0x4(%rbp)
jmp 0x1b35
movsbl -0x5(%rbp), %eax
cmpl $0x2a, %eax
jne 0x1b2e
movl $0x5, -0x4(%rbp)
jmp 0x1b35
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/get_board.c
// Function: which_char
static enum e_state		which_char(t_game *game, char c, t_point pos)
{
	if (c == game->my_char || c == game->my_last_char)
	{
		if (game->core_mine.x == 0 && game->core_mine.y == 0)
		{
			game->last_mine = pos;
			game->core_mine = pos;
		}
		return (c == game->my_last_char ? E_LAST_MINE : E_MINE);
	}
	if (game->core_adv.x == 0 && game->core_adv.y == 0)
	{
		game->last_adv = pos;
		game->core_adv = pos;
	}
	else if (game->board.mx[pos.x][pos.y] == E_EMPTY
			|| c == game->adv_last_char)
	{
		if ((game->last_adv.x == 0 && game->last_adv.y == 0)
				|| delta(&pos, &game->core_mine)
				< delta(&game->last_adv, &game->core_mine))
			game->last_adv = pos;
		return (E_LAST_ADV);
	}
	return (E_ADV);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdx, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x36(%rcx), %ecx
cmpl %ecx, %eax
je 0x1b76
movsbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x37(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1bc5
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x1ba2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x5c(%rax)
jne 0x1ba2
movq -0x18(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x18(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, 0x58(%rax)
movsbl -0x19(%rbp), %edx
movq -0x18(%rbp), %rax
movsbl 0x37(%rax), %esi
movl $0x3, %eax
movl $0x4, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1c84
movq -0x18(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x1bf6
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x1bf6
movq -0x18(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, 0x50(%rax)
jmp 0x1c7d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1c20
movsbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl 0x35(%rcx), %ecx
cmpl %ecx, %eax
jne 0x1c7b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x1c34
movq -0x18(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x1c66
movq -0x18(%rbp), %rsi
addq $0x58, %rsi
leaq -0xc(%rbp), %rdi
callq 0x2250
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
addq $0x58, %rsi
callq 0x2250
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x1c72
movq -0x18(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x1c84
jmp 0x1c7d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x9c, %rdi
movl $0x8, %esi
callq 0x3910
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x34d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rdi
callq 0x3190
movq -0x8(%rbp), %rdi
callq 0x2bf0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, %ecx
leaq 0xd395(%rip), %rax      # 0xf090
movq (%rax,%rcx,8), %rsi
callq 0x1d70
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8c(%rcx), %rcx
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movl $0x8, %esi
callq 0x3910
movq -0x8(%rbp), %rdi
addq $0x94, %rdi
movl $0x8, %esi
callq 0x3910
movq -0x8(%rbp), %rdi
addq $0x8c, %rdi
movl $0x8, %esi
callq 0x3910
movq -0x8(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/process.c
// Function: find_coord
static void				find_coord(t_game *game, t_strategy strategy)
{
	t_point end;
	t_point	start;
	int		tmp_y;

	start.x = 0 - game->piece.size.x - 1;
	tmp_y = 0 - game->piece.size.y - 1;
	end.x = game->board.size.x + game->piece.size.x;
	end.y = game->board.size.y + game->piece.size.y;
	while (++start.x < end.x)
	{
		start.y = tmp_y;
		while (++start.y < end.y)
		{
			if (check_piece(game, &start) == TRUE)
			{
				if ((game->to_play.x == 0 && game->to_play.y == 0)
					|| strategy(game) == TRUE)
				{
					game->good_contact = game->contact;
					game->to_play = start;
				}
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x18(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subl 0x1c(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x18(%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x1c(%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl -0x18(%rbp), %eax
jge 0x1e55
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl -0x14(%rbp), %eax
jge 0x1e50
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1e60
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e4e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x9c(%rax)
jne 0x1e15
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
je 0x1e27
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e4c
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8c(%rcx), %rcx
movq %rcx, 0x94(%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x9c(%rax)
jmp 0x1e4e
jmp 0x1dd8
jmp 0x1dc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]filler_42/srcs/process.c
// Function: check_piece
static unsigned char	check_piece(t_game *game, t_point *pos)
{
	t_point	p;
	int		contact;

	contact = 0;
	p.x = 0;
	while (p.x < game->piece.size.x)
	{
		p.y = 0;
		while (p.y < game->piece.size.y)
		{
			if (pos_is_ok(game, pos, &p, &contact) == FALSE)
				return (FALSE);
			p.y++;
		}
		p.x++;
	}
	return (contact == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x1ed6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x1ecb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x1ef0
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1ec0
movb $0x0, -0x1(%rbp)
jmp 0x1ee5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e91
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e7e
cmpl $0x1, -0x24(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3830
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x2150
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xa0(%rax), %edx
leaq 0x8f01(%rip), %rdi      # 0xb032
movb $0x0, %al
callq 0x40e0
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x21a2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2163
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3830
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x2150
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2150
movq -0x8(%rbp), %rax
movl $0x7, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa8(%rax)
jne 0x224a
movq -0x8(%rbp), %rax
movl $0x1, 0xa8(%rax)
leaq 0x8df9(%rip), %rdi      # 0xb039
movl $0x2, %esi
callq 0x3950
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x4, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37e0
cmpq -0x20(%rbp), %rax
je 0x22db
movb $0x0, -0x1(%rbp)
jmp 0x2363
jmp 0x22dd
cmpq $0x4, -0x18(%rbp)
jae 0x2309
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x22fb
movb $0x0, -0x1(%rbp)
jmp 0x2363
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x22dd
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x235f
movq -0x28(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbq (%rax,%rcx), %rax
cmpq %rax, %rdx
je 0x2345
movb $0x0, -0x1(%rbp)
jmp 0x2363
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2311
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)