LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: digraph<char, int> reverse<char, int>(digraph<char, int> const&)
inline digraph<N, A> reverse(const digraph<N, A>& g)
{
    digraph<N, A> r;
    // copy the connections
    for (const auto& n : g.nodes()) {
        r.add(n);
        for (const auto& cnx : g.connections(n)) {
            r.add(cnx.first, n, cnx.second);
        }
    }
    return r;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x24270
movq 0x78(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x18(%rsp)
jmp 0x26a4c
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0xa150
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0xa180
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x26a8c
jmp 0x26b65
leaq 0x50(%rsp), %rdi
callq 0xa1d0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movsbl (%rax), %esi
callq 0x2d4d0
jmp 0x26aaf
movq 0x78(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2ada0
movq %rax, (%rsp)
jmp 0x26ac4
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2add0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2ae00
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2ae30
testb $0x1, %al
jne 0x26b00
jmp 0x26b54
leaq 0x30(%rsp), %rdi
callq 0x2ae50
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %rsi, %rcx
addq $0x4, %rcx
callq 0x242b0
jmp 0x26b2c
jmp 0x26b2e
leaq 0x30(%rsp), %rdi
callq 0x2ae70
jmp 0x26aeb
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x24610
jmp 0x26b88
jmp 0x26b56
leaq 0x50(%rsp), %rdi
callq 0xa350
jmp 0x26a74
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x26b7b
movq 0x8(%rsp), %rdi
callq 0x24610
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: grame-cncm[P]digraph/tests.cpp
// Function: bool equiv<char, int>(digraph<char, int> const&, digraph<char, int> const&)
bool equiv(const digraph<N, A>& g, const digraph<N, A>& h)
{
    if (g.nodes() != h.nodes()) {
        return false;
    } else {
        for (const auto& n : g.nodes()) {
            if (g.connections(n) != h.connections(n)) return false;
        }
        return true;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2ad80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x38620
testb $0x1, %al
jne 0x26bda
jmp 0x26be4
movb $0x0, 0x47(%rsp)
jmp 0x26c83
movq 0x38(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa150
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa180
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x26c26
jmp 0x26c7e
leaq 0x20(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ada0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ada0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x38650
testb $0x1, %al
jne 0x26c69
jmp 0x26c70
movb $0x0, 0x47(%rsp)
jmp 0x26c83
jmp 0x26c72
leaq 0x20(%rsp), %rdi
callq 0xa350
jmp 0x26c11
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: digraph<char, int> chain<char, int>(digraph<char, int> const&, bool)
inline digraph<N, A> chain(const digraph<N, A>& g, bool strict)
{
    const digraph<N, A> h = reverse(g);
    digraph<N, A>       r;
    for (const auto& n : g.nodes()) {
        if (!strict) r.add(n);
        if (g.connections(n).size() == 1) {
            for (const auto& m : g.connections(n)) {
                if (h.connections(m.first).size() == 1) {
                    r.add(n, m.first, m.second);
                }
            }
        }
    }
    return r;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x30(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
andb $0x1, %al
movb %al, 0xa7(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x26a10
movq 0x30(%rsp), %rdi
movb $0x0, 0x8f(%rsp)
callq 0x24270
jmp 0x26ce8
movq 0xa8(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x20(%rsp)
jmp 0x26cfc
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xa150
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0xa180
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x26d3c
jmp 0x26e9c
leaq 0x68(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x58(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x26da1
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rax
movsbl (%rax), %esi
callq 0x2d4d0
jmp 0x26d69
jmp 0x26da1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x26ed2
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x24610
jmp 0x26ed2
movq 0xa8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2ada0
movq %rax, 0x18(%rsp)
jmp 0x26dba
movq 0x18(%rsp), %rdi
callq 0x38bb0
cmpq $0x1, %rax
jne 0x26e8b
movq 0xa8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2ada0
movq %rax, 0x10(%rsp)
jmp 0x26de7
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2add0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2ae00
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2ae30
testb $0x1, %al
jne 0x26e24
jmp 0x26e89
leaq 0x48(%rsp), %rdi
callq 0x2ae50
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x2ada0
movq %rax, 0x8(%rsp)
jmp 0x26e4c
movq 0x8(%rsp), %rdi
callq 0x38bb0
cmpq $0x1, %rax
jne 0x26e7b
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rdx, %rcx
addq $0x4, %rcx
callq 0x242b0
jmp 0x26e79
jmp 0x26e7b
jmp 0x26e7d
leaq 0x48(%rsp), %rdi
callq 0x2ae70
jmp 0x26e0f
jmp 0x26e8b
jmp 0x26e8d
leaq 0x68(%rsp), %rdi
callq 0xa350
jmp 0x26d24
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x26eb8
movq 0x30(%rsp), %rdi
callq 0x24610
leaq 0x90(%rsp), %rdi
callq 0x24610
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x24610
movq 0x80(%rsp), %rdi
callq 0x2290
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: std::vector<char, std::allocator<char>> roots<char, int>(digraph<char, int> const&)
inline std::vector<N> roots(const digraph<N, A>& G)
{
    std::map<N, int> R;
    for (const N& n : G.nodes()) {
        for (const auto& c : G.connections(n)) {
            R[c.first]++;
        }
    }
    std::vector<N> V;
    for (const N& n : G.nodes()) {
        if (R[n] == 0) V.push_back(n);
    }
    return V;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x29b90
movq 0xe8(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x38(%rsp)
jmp 0x270a5
movq 0x38(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xa150
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xa180
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x270fa
jmp 0x271de
leaq 0x98(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x88(%rsp)
movq 0xe8(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2ada0
movq %rax, 0x20(%rsp)
jmp 0x2712b
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2add0
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x2ae00
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2ae30
testb $0x1, %al
jne 0x27171
jmp 0x271ca
leaq 0x78(%rsp), %rdi
callq 0x2ae50
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x28f20
movq %rax, 0x18(%rsp)
jmp 0x27199
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x78(%rsp), %rdi
callq 0x2ae70
jmp 0x2715c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x272e4
jmp 0x271cc
leaq 0x98(%rsp), %rdi
callq 0xa350
jmp 0x270dc
movq 0x28(%rsp), %rdi
movb $0x0, 0x67(%rsp)
callq 0x38bc0
movq 0xe8(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x10(%rsp)
jmp 0x27201
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa150
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0xa180
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x2723e
jmp 0x272b4
leaq 0x50(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x28f20
movq %rax, 0x8(%rsp)
jmp 0x27266
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x272a3
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x38bd0
jmp 0x27281
jmp 0x272a3
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x27300
jmp 0x272e4
jmp 0x272a5
leaq 0x50(%rsp), %rdi
callq 0xa350
jmp 0x27229
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x272ca
movq 0x28(%rsp), %rdi
callq 0x27300
leaq 0xb8(%rsp), %rdi
callq 0x28290
movq 0x30(%rsp), %rax
addq $0xf8, %rsp
retq
leaq 0xb8(%rsp), %rdi
callq 0x28290
movq 0xa8(%rsp), %rdi
callq 0x2290
nop
// File: grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: std::vector<char, std::allocator<char>> leaves<char, int>(digraph<char, int> const&)
inline std::vector<N> leaves(const digraph<N, A>& G)
{
    std::vector<N> L;
    for (const N& n : G.nodes()) {
        if (G.connections(n).size() == 0) {
            L.push_back(n);
        }
    }
    return L;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x38bc0
movq 0x58(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x18(%rsp)
jmp 0x27396
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa150
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa180
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x273d3
jmp 0x27444
leaq 0x30(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2ada0
movq %rax, (%rsp)
jmp 0x273f7
movq (%rsp), %rdi
callq 0x38bb0
cmpq $0x0, %rax
jne 0x27433
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x38bd0
jmp 0x27417
jmp 0x27433
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x27300
jmp 0x27464
jmp 0x27435
leaq 0x30(%rsp), %rdi
callq 0xa350
jmp 0x273be
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x2745a
movq 0x8(%rsp), %rdi
callq 0x27300
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2290
nop
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: std::ostream& operator<<<char>(std::ostream&, schedule<char> const&)
inline std::ostream& operator<<(std::ostream& file, const schedule<N>& S)
{
    std::string sep = "";

    file << "Schedule {";
    for (const N& n : S.elements()) {
        file << sep << S.order(n) << ":" << n;
        sep = ", ";
    }
    return file << "}";
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x22a0
movq 0x38(%rsp), %rdx
leaq 0x15bdf(%rip), %rsi     # 0x3d081
leaq 0x78(%rsp), %rdi
callq 0x2200
jmp 0x274ae
leaq 0x77(%rsp), %rdi
callq 0x21c0
movq 0xa0(%rsp), %rdi
leaq 0x17b11(%rip), %rsi     # 0x3efd8
callq 0x2180
jmp 0x274ce
movq 0x98(%rsp), %rdi
callq 0x39af0
movq %rax, 0x30(%rsp)
jmp 0x274e2
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39360
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39390
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x393c0
testb $0x1, %al
jne 0x27522
jmp 0x275fb
leaq 0x50(%rsp), %rdi
callq 0x39400
movq %rax, 0x40(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x2150
movq %rax, 0x28(%rsp)
jmp 0x2754a
movq 0x98(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x39b00
movl %eax, 0x24(%rsp)
jmp 0x27562
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rdi
callq 0x2280
movq %rax, 0x18(%rsp)
jmp 0x27577
movq 0x18(%rsp), %rdi
leaq 0x15aff(%rip), %rsi     # 0x3d082
callq 0x2180
movq %rax, 0x10(%rsp)
jmp 0x2758f
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movsbl (%rax), %esi
callq 0x21e0
jmp 0x275a3
leaq 0x15a80(%rip), %rsi     # 0x3d02a
leaq 0x78(%rsp), %rdi
callq 0x21f0
jmp 0x275b6
jmp 0x275b8
leaq 0x50(%rsp), %rdi
callq 0x39410
jmp 0x2750a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x77(%rsp), %rdi
callq 0x21c0
jmp 0x2762d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x20e0
jmp 0x2762d
movq 0xa0(%rsp), %rdi
leaq 0x16c91(%rip), %rsi     # 0x3e29b
callq 0x2180
movq %rax, 0x8(%rsp)
jmp 0x27616
leaq 0x78(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: schedule<char> dfschedule<char, int>(digraph<char, int> const&)
inline schedule<N> dfschedule(const digraph<N, A>& G)
{
    schedule<N> S;
    std::set<N> V;  // set of visited nodes

    // recursive deep first visit (pseudo local function using a lambda)
    std::function<void(const N&)> dfvisit = [&](const N& n) {
        if (V.find(n) == V.end()) {
            V.insert(n);
            for (const auto& p : G.connections(n)) {
                dfvisit(p.first);
            }
            S.append(n);
        }
    };

    for (const auto& n : roots(G)) dfvisit(n);

    return S;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
callq 0x39460
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5200
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq 0xd8(%rsp), %rcx
movq %rcx, 0x68(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x39490
jmp 0x276bc
movq 0xd8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x27060
jmp 0x276d0
leaq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x38fc0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0x38e60
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x39540
testb $0x1, %al
jne 0x2773a
leaq 0x30(%rsp), %rdi
callq 0x27300
jmp 0x27785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x277c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x277b3
leaq 0x28(%rsp), %rdi
callq 0x39580
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x39590
jmp 0x2775d
jmp 0x2775f
leaq 0x28(%rsp), %rdi
callq 0x395d0
jmp 0x276f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x27300
jmp 0x277b3
movb $0x1, 0xd7(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x395f0
leaq 0xa0(%rsp), %rdi
callq 0x5620
testb $0x1, 0xd7(%rsp)
jne 0x277e3
jmp 0x277d9
leaq 0x80(%rsp), %rdi
callq 0x395f0
leaq 0xa0(%rsp), %rdi
callq 0x5620
movq 0x10(%rsp), %rdi
callq 0x27930
jmp 0x277ef
movq 0x10(%rsp), %rdi
callq 0x27930
movq (%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x2290
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: int schedulingcost<char, int>(digraph<char, int> const&, schedule<char> const&)
inline int schedulingcost(const digraph<N, A>& G, const schedule<N>& S)
{
    int cost = 0;
    for (const N& n : G.nodes()) {
        int t1 = S.order(n);
        for (const auto& c : G.connections(n)) {
            int t0 = S.order(c.first);
            // assert(t1 > t0);
            cost += std::abs(t1 - t0);  // We may have loops
        }
    }
    return cost;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa150
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa180
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x2785b
jmp 0x2791a
leaq 0x40(%rsp), %rdi
callq 0xa1d0
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39b00
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2ada0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2add0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ae00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ae30
testb $0x1, %al
jne 0x278c4
jmp 0x27909
leaq 0x18(%rsp), %rdi
callq 0x2ae50
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x39b00
movl %eax, 0x4(%rsp)
movl 0x2c(%rsp), %eax
subl 0x4(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2ae70
jmp 0x278af
jmp 0x2790b
leaq 0x40(%rsp), %rdi
callq 0xa350
jmp 0x27843
movl 0x54(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: schedule<char> bfschedule<char, int>(digraph<char, int> const&)
inline schedule<N> bfschedule(const digraph<N, A>& G)
{
    std::vector<std::vector<N>> P = parallelize(G);
    schedule<N>                 S;

    for (uint64_t i = 0; i < P.size(); i++) {
        for (const N& n : P[i]) S.append(n);
    }
    return S;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x39d80
movq 0x18(%rsp), %rdi
movb $0x0, 0x5f(%rsp)
callq 0x39460
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3a010
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x27a7b
movq 0x50(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x3a030
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x38fc0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x38e60
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x39540
testb $0x1, %al
jne 0x27a14
jmp 0x27a66
leaq 0x40(%rsp), %rdi
callq 0x39580
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x398e0
jmp 0x27a34
jmp 0x27a36
leaq 0x40(%rsp), %rdi
callq 0x395d0
jmp 0x279ff
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x27930
leaq 0x60(%rsp), %rdi
callq 0x3a050
jmp 0x27aa8
jmp 0x27a68
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x279a8
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x27a91
movq 0x18(%rsp), %rdi
callq 0x27930
leaq 0x60(%rsp), %rdi
callq 0x3a050
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: schedule<char> dfcyclesschedule<char, int>(digraph<char, int> const&)
inline schedule<N> dfcyclesschedule(const digraph<N, A>& G)
{
    digraph<digraph<N, A>, A> H  = graph2dag(G);
    schedule<digraph<N, A>>   SH = dfschedule(H);
    schedule<N>               S;
    for (const digraph<N, A>& n : SH.elements()) {
        S.append(dfschedule(cut(n, 1)));
    }
    return S;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x108(%rsp), %rsi
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x24b10
movq 0x20(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x3b340
jmp 0x27b12
movq 0x10(%rsp), %rdi
movb $0x0, 0xa3(%rsp)
callq 0x39460
leaq 0xb0(%rsp), %rdi
callq 0x3b500
movq %rax, 0x8(%rsp)
jmp 0x27b38
movq 0x8(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x37350
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rdi
callq 0x37380
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x373b0
testb $0x1, %al
jne 0x27b8d
jmp 0x27c75
leaq 0x90(%rsp), %rdi
callq 0x373f0
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x24bc0
jmp 0x27bbb
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x27640
jmp 0x27bcc
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3b510
jmp 0x27bdd
leaq 0x38(%rsp), %rdi
callq 0x27930
leaq 0x28(%rsp), %rdi
callq 0x24610
leaq 0x90(%rsp), %rdi
callq 0x37400
jmp 0x27b6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x27ccf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x27cb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x27c69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x27930
leaq 0x28(%rsp), %rdi
callq 0x24610
jmp 0x27cb8
movb $0x1, 0xa3(%rsp)
testb $0x1, 0xa3(%rsp)
jne 0x27c91
movq 0x10(%rsp), %rdi
callq 0x27930
leaq 0xb0(%rsp), %rdi
callq 0x3b5a0
leaq 0xf8(%rsp), %rdi
callq 0x24bb0
movq 0x18(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
retq
movq 0x10(%rsp), %rdi
callq 0x27930
leaq 0xb0(%rsp), %rdi
callq 0x3b5a0
leaq 0xf8(%rsp), %rdi
callq 0x24bb0
movq 0xa8(%rsp), %rdi
callq 0x2290
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: schedule<char> bfcyclesschedule<char, int>(digraph<char, int> const&)
inline schedule<N> bfcyclesschedule(const digraph<N, A>& G)
{
    digraph<digraph<N, A>, A> H  = graph2dag(G);
    schedule<digraph<N, A>>   SH = bfschedule(H);
    schedule<N>               S;
    for (const digraph<N, A>& n : SH.elements()) {
        S.append(dfschedule(cut(n, 1)));
    }
    return S;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0xf8(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x24b10
movq 0x10(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x3bf00
jmp 0x27d41
movq (%rsp), %rdi
movb $0x0, 0x93(%rsp)
callq 0x39460
leaq 0xa0(%rsp), %rdi
callq 0x3b500
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x37350
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x37380
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x373b0
testb $0x1, %al
jne 0x27da9
jmp 0x27e8a
leaq 0x80(%rsp), %rdi
callq 0x373f0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x1, %edx
callq 0x24bc0
jmp 0x27dd1
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x27640
jmp 0x27de2
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3b510
jmp 0x27df2
leaq 0x28(%rsp), %rdi
callq 0x27930
leaq 0x18(%rsp), %rdi
callq 0x24610
leaq 0x80(%rsp), %rdi
callq 0x37400
jmp 0x27d8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x27ee2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x27ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x27e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x27930
leaq 0x18(%rsp), %rdi
callq 0x24610
jmp 0x27ecc
movb $0x1, 0x93(%rsp)
testb $0x1, 0x93(%rsp)
jne 0x27ea5
movq (%rsp), %rdi
callq 0x27930
leaq 0xa0(%rsp), %rdi
callq 0x3b5a0
leaq 0xe8(%rsp), %rdi
callq 0x24bb0
movq 0x8(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq (%rsp), %rdi
callq 0x27930
leaq 0xa0(%rsp), %rdi
callq 0x3b5a0
leaq 0xe8(%rsp), %rdi
callq 0x24bb0
movq 0x98(%rsp), %rdi
callq 0x2290
nopl (%rax)
// File: grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: digraph<char, int> mapconnections<char, int>(digraph<char, int> const&, std::function<bool (char const&, char const&, int const&)>)
inline digraph<N, A> mapconnections(const digraph<N, A>& G, std::function<bool(const N&, const N&, const A&)> keep)
{
    digraph<N, A> R;
    for (const N& n : G.nodes()) {
        R.add(n);
        for (const auto& c : G.connections(n)) {
            if (keep(n, c.first, c.second)) {
                R.add(n, c.first, c.second);
            }
        }
    }
    return R;
}

// Assembly:
subq $0xa8, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
callq 0x24270
movq 0x98(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x30(%rsp)
jmp 0x32cd2
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0xa150
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0xa180
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa1b0
testb $0x1, %al
jne 0x32d1b
jmp 0x32e2c
leaq 0x68(%rsp), %rdi
callq 0xa1d0
movq 0x20(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movsbl (%rax), %esi
callq 0x2d4d0
jmp 0x32d3e
movq 0x98(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2ada0
movq %rax, 0x10(%rsp)
jmp 0x32d57
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2add0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2ae00
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2ae30
testb $0x1, %al
jne 0x32d97
jmp 0x32e1b
leaq 0x48(%rsp), %rdi
callq 0x2ae50
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rdx, %rcx
addq $0x4, %rcx
callq 0x32f00
movb %al, 0xf(%rsp)
jmp 0x32dc7
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x32dd1
jmp 0x32e0a
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rdx, %rcx
addq $0x4, %rcx
callq 0x242b0
jmp 0x32dee
jmp 0x32e0a
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x24610
jmp 0x32e55
jmp 0x32e0c
leaq 0x48(%rsp), %rdi
callq 0x2ae70
jmp 0x32d7f
jmp 0x32e1d
leaq 0x68(%rsp), %rdi
callq 0xa350
jmp 0x32d03
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x32e48
movq 0x20(%rsp), %rdi
callq 0x24610
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x2290
nop
// File: grame-cncm[P]digraph/./dglib/schedule.hh
// Function: schedule<char>::append(char const&)
schedule& append(const N& n)
    {
        if (fOrder[n] > 0) {
            std::cerr << "WARNING, already scheduled" << std::endl;
        } else {
            fElements.push_back(n);
            fOrder[n] = fElements.size();
        }
        return *this;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x28f20
cmpl $0x0, (%rax)
jle 0x3992f
movq 0x1c6de(%rip), %rdi     # 0x55ff0
leaq 0x56a4(%rip), %rsi      # 0x3efbd
callq 0x2180
movq %rax, %rdi
movq 0x1c690(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x39965
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x38bd0
movq 0x10(%rsp), %rdi
callq 0x39100
movq 0x10(%rsp), %rdi
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x28f20
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: yuryu[P]tfoecho/server.cpp
// Function: accept_and_register(int, int)
int accept_and_register(int sfd, int epollfd)
{
    // Accept a new connection
    struct sockaddr addr;
    socklen_t addrlen = sizeof(addr);
    int s;
    do
    {
        s = accept4(sfd, &addr, &addrlen, SOCK_NONBLOCK);
    } while( s == -1 && errno == EINTR );
    if( s == -1 )
    {
        cerror("accept");
        std::exit(EXIT_FAILURE);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = s;
    if( epoll_ctl(epollfd, EPOLL_CTL_ADD, s, &ev) == -1 )
    {
        perror("epoll_ctl: EPOLL_CTL_ADD");
        std::exit(EXIT_FAILURE);
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x10, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
movl $0x800, %ecx            # imm = 0x800
callq 0x20e0
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x20(%rbp)
movb %al, -0x2d(%rbp)
jne 0x2696
callq 0x2030
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2665
cmpl $-0x1, -0x20(%rbp)
jne 0x26b9
leaq 0x1989(%rip), %rdi      # 0x4033
callq 0x25f0
movl $0x1, %edi
callq 0x21f0
movl $0x80000001, -0x2c(%rbp) # imm = 0x80000001
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %edi
movl -0x20(%rbp), %edx
movl $0x1, %esi
leaq -0x2c(%rbp), %rcx
callq 0x2240
cmpl $-0x1, %eax
jne 0x26f5
leaq 0x1954(%rip), %rdi      # 0x403a
callq 0x2170
movl $0x1, %edi
callq 0x21f0
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yuryu[P]tfoecho/server.cpp
// Function: main
int main(int argc, char *argv[])
{
    std::string port;
    if( argc <= 1 )
    {
        port = DEFAULT_PORT;
    } else {
        port = argv[1];
    }

    server(port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2250
cmpl $0x1, -0x8(%rbp)
jg 0x2bf0
leaq 0x14c3(%rip), %rsi      # 0x408f
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2bd7
jmp 0x2c05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x2c22
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2c03
jmp 0x2c05
leaq -0x30(%rbp), %rdi
callq 0x2900
jmp 0x2c10
leaq -0x30(%rbp), %rdi
callq 0x2130
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2290
nopl (%rax,%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/test_source/test_matrix_alloc_problem.cc
// Function: get_wall_seconds()
static double get_wall_seconds() {
  struct timeval tv;
  if(gettimeofday(&tv, NULL) != 0)
    throw std::runtime_error("Error in cht::get_wall_seconds(), in gettimeofday().");
  double seconds = tv.tv_sec + (double)tv.tv_usec / 1000000;
  return seconds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2280
cmpl $0x0, %eax
je 0x27da
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x998d(%rip), %rsi      # 0xc132
callq 0x2070
jmp 0x27ac
movq -0x30(%rbp), %rdi
movq 0xf839(%rip), %rsi      # 0x11ff0
movq 0xf7fa(%rip), %rdx      # 0x11fb8
callq 0x22b0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x2806
cvtsi2sdq -0x10(%rbp), %xmm0
cvtsi2sdq -0x8(%rbp), %xmm1
movsd 0x9832(%rip), %xmm2     # 0xc020
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22d0
nop
// File: davidsun[P]TinyCompiler/Item.cpp
// Function: Item::operator=(Item const&)
Item &Item::operator = (const Item &item){
    left_side = item.left_side;
    right_side = item.right_side;
    position = item.position;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x3050
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidsun[P]TinyCompiler/CodeItem.cpp
// Function: CodeItem::operator=(CodeItem const&)
CodeItem &CodeItem::operator = (const CodeItem &code_item){
    command = code_item.command;
    param1 = code_item.param1;
    param2 = code_item.param2;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3050
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movb 0x21(%rcx), %cl
movb %cl, 0x21(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: davidsun[P]TinyCompiler/ItemSet.cpp
// Function: ItemSet::operator==(ItemSet const&) const
bool ItemSet::operator == (const ItemSet &itemSet) const{
    if (_items.size() != itemSet._items.size()) return false;
    int found = 0;
    for (int i = 0; i < _items.size(); i ++){
        for (int j = 0; j < itemSet._items.size(); j ++){
            if (_items[i] == itemSet._items[j]){
                found ++;
                break;
            }
        }
    }
    return found == _items.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x48f0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x444f
movb $0x0, -0x1(%rbp)
jmp 0x4519
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x48f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x44f6
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x48f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x44e6
movq -0x38(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x4920
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x4920
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x3cb0
testb $0x1, %al
jne 0x44ce
jmp 0x44d9
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x44e6
jmp 0x44db
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4481
jmp 0x44e8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x445d
movq -0x38(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x48f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidsun[P]TinyCompiler/LexicalAnalytics.cpp
// Function: LexicalAnalytics::getType_p(char) const
int LexicalAnalytics::getType_p(char c) const{
    switch (c){
        case ';':
        case ':':
        case '(':
        case ')':
        case '{':
        case '}':
        case '*':
        case '/':
        case '+':
        case '-':
        case '=':
        case '<':
        case '>':
        case ',':
        case '!':
        case '?':
            return TYPE_TOKEN;
        case '\t':
        case '\n':
        case '\r':
        case ' ':
            return TYPE_BLANK;
    }
    return TYPE_NORMAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x74, %eax
ja 0x6cc6
movq -0x20(%rbp), %rax
leaq 0x1e3c5(%rip), %rcx     # 0x25070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x6ccd
movl $0x2, -0x4(%rbp)
jmp 0x6ccd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: davidsun[P]TinyCompiler/LRAnalytics.cpp
// Function: LRAnalytics::addRule(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void LRAnalytics::addRule(char left_side, const string &right_side){
    _rules.push_back(Item(left_side, right_side, 0));
    for (int i = 0; i < right_side.size(); i ++)
        if (std::string::npos == _letters.find(right_side[i])) _letters += right_side[i];
    if (std::string::npos == _letters.find(left_side)) _letters += left_side;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x20, %rax
movq %rax, -0x68(%rbp)
movsbl -0x9(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %ecx, %ecx
callq 0x3bc0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x9600
jmp 0x7dcf
leaq -0x48(%rbp), %rdi
callq 0x4940
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x7e6c
movq -0x18(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0x3300
movq -0x70(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x3380
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x7e5c
movq -0x18(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0x3300
movq -0x70(%rbp), %rdi
movb (%rax), %al
movsbl %al, %esi
callq 0x31b0
jmp 0x7e5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4940
jmp 0x7ea4
jmp 0x7e5e
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x7ddf
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x9(%rbp), %esi
callq 0x3380
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x7e9b
movq -0x70(%rbp), %rdi
movb -0x9(%rbp), %al
movsbl %al, %esi
callq 0x31b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: davidsun[P]TinyCompiler/LRAnalytics.cpp
// Function: LRAnalytics::getNonTerminals[abi:cxx11]() const
string LRAnalytics::getNonTerminals() const{
    string ret;
    for (int i = 0; i < _rules.size(); i ++)
        if (std::string::npos == ret.find(_rules[i].left_side)) ret += _rules[i].left_side;
    return ret;
}

// 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 0x33a0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x20, %rdi
callq 0x48f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x825c
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4920
movq -0x40(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x3380
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x824c
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x4920
movq -0x40(%rbp), %rdi
movsbl (%rax), %esi
callq 0x31b0
jmp 0x8233
jmp 0x824c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31a0
jmp 0x8279
jmp 0x824e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x81c3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x826f
movq -0x40(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: davidsun[P]TinyCompiler/LRAnalytics.cpp
// Function: LRAnalytics::getTerminals[abi:cxx11]() const
string LRAnalytics::getTerminals() const{
    string non = getNonTerminals();
    string ret;
    for (int i = 0; i < _letters.size(); i ++)
        if (std::string::npos == non.find(_letters[i])) ret += _letters[i];
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8190
movq -0x50(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0x33a0
movl $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x31e0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x8386
movq -0x58(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0x3300
leaq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x3380
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
jne 0x8376
movq -0x58(%rbp), %rdi
movslq -0x38(%rbp), %rsi
callq 0x3300
movq -0x50(%rbp), %rdi
movsbl (%rax), %esi
callq 0x31b0
jmp 0x8354
jmp 0x8376
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x83ac
jmp 0x8378
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x82f0
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x8399
movq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: davidsun[P]TinyCompiler/CodeGenerator.cpp
// Function: CodeGenerator::parse(LRAnalytics const&, std::vector<std::pair<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, std::vector<int, std::allocator<int>> const&, std::vector<std::vector<CodeItem, std::allocator<CodeItem>>, std::allocator<std::vector<CodeItem, std::allocator<CodeItem>>>> const&)
vector <string> CodeGenerator::parse(const LRAnalytics &lr_analytics, const vector <pair <char, string> > &la_result, const vector <int> &lra_result, const vector <ListCodeItems> &code_rules){
    _lra_position = lra_result.size() - 1;
    _la_position = la_result.size() - 1;
    _tmp_count = 0;
    _label_count = 0;
    _lr_analytics = lr_analytics;
    _la_result = la_result;
    _lra_result = lra_result;
    _code_rules = code_rules;
    return parse_p().second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfd80
movq %rax, %rcx
movq -0x80(%rbp), %rax
subq $0x1, %rcx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x7890
movq -0x80(%rbp), %rdi
subq $0x1, %rax
movl %eax, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movq -0x18(%rbp), %rsi
addq $0x10, %rdi
callq 0x11b40
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x48, %rdi
callq 0x11b80
movq -0x80(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x60, %rdi
callq 0x11dd0
movq -0x80(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x78, %rdi
callq 0x12020
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10210
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
addq $0x20, %rsi
callq 0xc320
leaq -0x68(%rbp), %rdi
callq 0x12270
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davidsun[P]TinyCompiler/CodeRunner.cpp
// Function: CodeRunner::getVariable_p(std::map<int, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Variable*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Variable*>>>, std::less<int>, std::allocator<std::pair<int const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Variable*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Variable*>>>>>> const&, std::vector<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Variable *CodeRunner::getVariable_p(const map <int, map <string, Variable *> > &variables, const vector <int> &cur_scopes, const string &name){
    for (int i = 0; i < cur_scopes.size(); i ++){
        map <int, map <string, Variable *> >::const_iterator it = variables.find(cur_scopes[i]);
        if (it != variables.end()){
            map <string, Variable *>::const_iterator itx = it -> second.find(name);
            if (itx != it -> second.end()) return itx -> second;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfd80
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x1bcd3
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x1c8d0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1c8a0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c920
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c8f0
testb $0x1, %al
jne 0x1bc65
jmp 0x1bcc3
leaq -0x38(%rbp), %rdi
callq 0x1c950
movq %rax, %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
callq 0x1c970
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c950
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1c9d0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1c9a0
testb $0x1, %al
jne 0x1bcae
jmp 0x1bcc1
leaq -0x48(%rbp), %rdi
callq 0x1ca00
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1bcdb
jmp 0x1bcc3
jmp 0x1bcc5
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1bbff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: KokiKishimoto[P]cp_decomposition/./model_file_load.hpp
// Function: ModelFileLoad::model_load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void model_load(std::string modelfile){
		std::ifstream fin;
		
		fin.open(modelfile);
		fin >> Size >> vecDim;
		Vec.resize(Size);
		for (int i = 0; i < Size; i++) {
			std::string tmp;
			fin >> tmp;
			Vec[i].resize(vecDim);
			for (int j = 0; j < vecDim; j++) {
				fin >> Vec[i][j];
			}
		}
		fin.close();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rsi, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x22a0
movq -0x260(%rbp), %rdi
movq -0x258(%rbp), %rsi
movl $0x8, %edx
callq 0x21e0
jmp 0x4ed2
movq -0x268(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x2140
movq %rax, -0x270(%rbp)
jmp 0x4eee
movq -0x270(%rbp), %rdi
movq -0x268(%rbp), %rsi
addq $0x4, %rsi
callq 0x2140
jmp 0x4f07
movq -0x268(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq (%rax), %rsi
callq 0xc7d0
jmp 0x4f1f
movl $0x0, -0x228(%rbp)
movq -0x268(%rbp), %rcx
movl -0x228(%rbp), %eax
cmpl (%rcx), %eax
jge 0x504c
leaq -0x248(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x2320
movq -0x278(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x2300
jmp 0x4f66
movq -0x268(%rbp), %rdi
addq $0x8, %rdi
movslq -0x228(%rbp), %rsi
callq 0xc860
movq %rax, %rdi
movq -0x268(%rbp), %rax
movslq 0x4(%rax), %rsi
callq 0x52e0
jmp 0x4f92
movl $0x0, -0x24c(%rbp)
movq -0x268(%rbp), %rcx
movl -0x24c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x502c
movq -0x268(%rbp), %rdi
addq $0x8, %rdi
movslq -0x228(%rbp), %rsi
callq 0xc860
movq %rax, %rdi
movslq -0x24c(%rbp), %rsi
callq 0xc880
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
callq 0x21c0
jmp 0x4fe5
jmp 0x4fe7
movl -0x24c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24c(%rbp)
jmp 0x4f9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x506f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2150
jmp 0x506f
leaq -0x248(%rbp), %rdi
callq 0x2150
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x4f29
leaq -0x218(%rbp), %rdi
callq 0x2080
jmp 0x505a
leaq -0x218(%rbp), %rdi
callq 0x2090
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x2090
movq -0x220(%rbp), %rdi
callq 0x23a0
nopw (%rax,%rax)