LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/main.cpp
// Function: newtest()
void newtest()
{
    digraph<char, multidep> g;
    g.add('A', 'B', {{{"M", 2}, {"N", 0}}, 0});
    std::cout << "g = " << g << std::endl;
    dotfile(std::cout, g);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
leaq 0x8(%rsp), %rdi
callq 0x270c
movb $0x41, 0x5(%rsp)
movb $0x42, 0x4(%rsp)
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19b94(%rip), %rsi     # 0x1c020
leaq 0x19b8e(%rip), %rdx     # 0x1c021
leaq 0x18(%rsp), %rdi
callq 0x3130
leaq 0x40(%rsp), %rdi
movl $0x2, -0x8(%rdi)
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19b69(%rip), %rsi     # 0x1c022
leaq 0x19b63(%rip), %rdx     # 0x1c023
callq 0x3130
leaq 0x18(%rsp), %rsi
movl $0x0, 0x48(%rsi)
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
movl $0x2, %edx
callq 0x275e
leaq 0x98(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x31d0
leaq 0x98(%rsp), %rcx
movl $0x0, 0x30(%rcx)
movq 0x8(%rsp), %rdi
leaq 0x5(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x397e
leaq 0x98(%rsp), %rdi
callq 0x34f0
leaq 0x68(%rsp), %rdi
callq 0x34f0
leaq 0x50(%rsp), %rbx
xorl %r14d, %r14d
movq 0x40(%rsp,%r14), %rdi
leaq (%rbx,%r14), %rax
cmpq %rdi, %rax
je 0x2551
callq 0x2150
addq $-0x28, %r14
cmpq $-0x50, %r14
jne 0x253e
movq 0x25a6e(%rip), %rdi     # 0x27fd0
leaq 0x1add8(%rip), %rsi     # 0x1d341
movl $0x4, %edx
callq 0x21a0
movq 0x25a56(%rip), %rdi     # 0x27fd0
leaq 0x8(%rsp), %rsi
callq 0x27e1
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x25a1b(%rip), %rdi     # 0x27fd0
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x2a36
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25d0
callq 0x3504
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x34f0
jmp 0x25f2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x34f0
jmp 0x2601
movq %rax, %rbx
movq $-0x50, %r15
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x2616
callq 0x2150
addq $-0x28, %r14
addq $0x28, %r15
jne 0x2608
jmp 0x263b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x263b
callq 0x2150
jmp 0x263b
jmp 0x2638
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x264a
callq 0x3504
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/main.cpp
// Function: main
int main(int, const char**)
{
    std::cout << "Tests digraph library\n";
    // newtest();

    bool r = true;
    r &= mcheck0();
    r &= mcheck1();
    r &= mcheck2();
    r &= mcheck3();
    r &= mcheck4();
    r &= mcheck5();
    r &= check1();
    // r &= check2();
    // r &= check3();
    r &= check4();
    r &= check5();
    // r &= check7();
    r &= check8();
    r &= check9();
    r &= check10();
    r &= check11();
    r &= check12();
    r &= check13();
    // r &= check14();
    // r &= check15();

    return (r) ? 0 : 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x25973(%rip), %rdi     # 0x27fd0
leaq 0x199c0(%rip), %rsi     # 0x1c024
movl $0x16, %edx
callq 0x21a0
callq 0x708c
movl %eax, %ebx
callq 0x86b0
movl %eax, %ebp
andb %bl, %bpl
callq 0x9f6f
movl %eax, %ebx
callq 0xaca7
movl %eax, %r14d
andb %bl, %r14b
andb %bpl, %r14b
callq 0xba6f
movl %eax, %ebx
callq 0xcc9d
movl %eax, %ebp
andb %bl, %bpl
callq 0xf06c
movl %eax, %ebx
andb %bpl, %bl
andb %r14b, %bl
callq 0x1032d
movl %eax, %ebp
callq 0x10947
movl %eax, %r14d
andb %bpl, %r14b
callq 0x119b7
movl %eax, %ebp
andb %r14b, %bpl
callq 0x12016
movl %eax, %r14d
andb %bpl, %r14b
andb %bl, %r14b
callq 0x12331
movl %eax, %ebx
callq 0x128fb
movl %eax, %ebp
andb %bl, %bpl
callq 0x12e08
movl %eax, %ebx
andb %bpl, %bl
callq 0x139f0
andb %bl, %al
andb %r14b, %al
xorb $0x1, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/stdprinting.hh
// Function: std::ostream& operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>(std::ostream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>> const&)
inline std::ostream& operator<<(std::ostream& file, const std::map<N, A>& S)
{
    std::string sep = "";

    file << "std::map{";
    for (const auto& e : S) {
        file << sep << e;
        sep = ", ";
    }
    return file << "}";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x17881(%rip), %rdx     # 0x1c0c7
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3130
leaq 0x1782c(%rip), %rsi     # 0x1c086
movl $0x9, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x491c
leaq 0x177f1(%rip), %r13     # 0x1c070
leaq 0x8(%rsp), %r12
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a0
movq %rax, %rbp
movl $0xa, %edx
movq %rax, %rdi
leaq 0x177d3(%rip), %rsi     # 0x1c07b
callq 0x21a0
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbp, %rdi
callq 0x21a0
movq %rax, %rbp
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movl 0x40(%r15), %esi
movq %rbp, %rdi
callq 0x2240
movl $0x1, %edx
movq %rax, %rdi
leaq 0x18970(%rip), %rsi     # 0x1d25b
callq 0x21a0
movq 0x10(%rsp), %rdx
movl $0x2, %r8d
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rcx
callq 0x2200
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %r14, %rax
jne 0x4884
leaq 0x18938(%rip), %rsi     # 0x1d25b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4944
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4958
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x496f
callq 0x2150
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/arrow.hh
// Function: arrow_traits<std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>>, int>>::label(std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>>, int> const&)
static std::string label(const multidep& M)
    {
        std::stringstream sn;
        std::string       sep = "";
        for (const auto& d : M.first) {
            sn << sep << d.first << ":" << d.second;
            sep = " ";
        }
        return sn.str();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20f0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1771c(%rip), %rdx     # 0x1c0c7
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3130
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x4a43
leaq 0x176fc(%rip), %r13     # 0x1c0c8
leaq 0x190c0(%rip), %rbp     # 0x1da93
leaq 0x8(%rsp), %rbx
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x21a0
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rax, %rdi
callq 0x21a0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movl 0x40(%r15), %esi
movq %r12, %rdi
callq 0x2240
movq 0x10(%rsp), %rdx
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
movq %rbp, %rcx
callq 0x2200
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %r14, %rax
jne 0x49d8
leaq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2210
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4a69
callq 0x2150
movq 0x23540(%rip), %rsi     # 0x27fb0
leaq 0x30(%rsp), %rdi
callq 0x2110
leaq 0xb0(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4aa3
movq %rax, %rbx
jmp 0x4aba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4aba
callq 0x2150
movq 0x234ef(%rip), %rsi     # 0x27fb0
leaq 0x30(%rsp), %rdi
callq 0x2110
leaq 0xb0(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/digraph.hh
// Function: digraph<char, std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>>, int>>::internalgraph::areConnected(char const&, char const&, std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>>, int>&) const
bool areConnected(const N& n1, const N& n2, A& d) const
        {
            auto c = fConnections.at(n1);
            auto q = c.find(n2);
            if (q != c.end()) {
                d = q->second;
                return true;
            } else {
                return false;
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
addq $0x30, %rdi
callq 0x47dc
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x58b8
movq 0x10(%r15), %r8
testq %r8, %r8
je 0x5878
leaq 0x8(%rsp), %rcx
movb (%r14), %al
movq %rcx, %r14
movq %r14, %rdx
movq %r8, %rsi
movb 0x20(%r8), %dil
xorl %r8d, %r8d
cmpb %al, %dil
setl %r8b
movq %rsi, %r14
cmovlq %rdx, %r14
movq 0x10(%rsi,%r8,8), %r8
testq %r8, %r8
jne 0x5842
cmpq %rcx, %r14
je 0x5878
cmpb %al, %dil
cmovlq %rdx, %rsi
cmpb 0x20(%rsi), %al
jge 0x588e
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x38e0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x451a
movl 0x58(%r14), %eax
movl %eax, 0x30(%rbx)
movb $0x1, %bl
jmp 0x587a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x38e0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/mtests.cpp
// Function: mcheck(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool mcheck(const std::string& testname, const std::string& testvalue, const std::string& expectedvalue)
{
    bool ok = (0 == expectedvalue.compare(testvalue));
    if (ok) {
        std::cout << testname << " SUCCESS " << std::endl;
    } else {
        std::cout << testname << " FAILED " << std::endl;
        std::cout << "We got     [[" << testvalue << "]]" << std::endl;
        std::cout << "instead of [[" << expectedvalue << "]]" << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2040
movl %eax, %ebx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x223ee(%rip), %rdi     # 0x27fd0
callq 0x21a0
movq %rax, %r15
testl %ebx, %ebx
je 0x5cce
leaq 0x16620(%rip), %rsi     # 0x1c219
movl $0x8, %edx
movq %r15, %rdi
callq 0x21a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x2239c(%rip), %r15     # 0x27fd0
leaq 0x165e7(%rip), %rsi     # 0x1c222
movl $0xd, %edx
movq %r15, %rdi
callq 0x21a0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x21a0
movq %rax, %r13
leaq 0x165cd(%rip), %r12     # 0x1c230
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21a0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x16591(%rip), %rsi     # 0x1c233
movl $0xd, %edx
movq %r15, %rdi
callq 0x21a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
jmp 0x5cdd
leaq 0x1653a(%rip), %rsi     # 0x1c20f
movl $0x9, %edx
movq %r15, %rdi
callq 0x21a0
testl %ebx, %ebx
sete %bl
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/mtests.cpp
// Function: mres3[abi:cxx11]()
std::string mres3()
{
    return "g = Graph {A-std::pair{std::map{std::pair{Y, 1}}, 1}->B, "
           "B-std::pair{std::map{std::pair{Q, 0}}, 0}->C, C-std::pair{std::map{std::pair{X, 0}}, "
           "0}->A, D-std::pair{std::map{std::pair{M, 0}}, 0}->B, D-std::pair{std::map{std::pair{M, "
           "2}}, 2}->C, D-std::pair{std::map{std::pair{M, 0}}, 0}->E, "
           "E-std::pair{std::map{std::pair{N, 1}}, 1}->D}";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x11b07(%rip), %rsi     # 0x1c79d
leaq 0x11c4c(%rip), %rdx     # 0x1c8e9
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/mtests.cpp
// Function: mres4[abi:cxx11]()
std::string mres4()
{
    return "d = Graph {Graph {A-std::pair{std::map{std::pair{Y, 1}}, 1}->B, "
           "B-std::pair{std::map{std::pair{Q, 0}}, 0}->C, C-std::pair{std::map{std::pair{X, 0}}, "
           "0}->A}, Graph {D-std::pair{std::map{std::pair{M, 0}}, 0}->E, "
           "E-std::pair{std::map{std::pair{N, 1}}, 1}->D}-std::pair{std::map{std::pair{M, 0}, "
           "std::pair{W, 2}}, 0}->Graph {A-std::pair{std::map{std::pair{Y, 1}}, 1}->B, "
           "B-std::pair{std::map{std::pair{Q, 0}}, 0}->C, C-std::pair{std::map{std::pair{X, 0}}, "
           "0}->A}}";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x10e9a(%rip), %rsi     # 0x1c8f8
leaq 0x1105e(%rip), %rdx     # 0x1cac3
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: test0(std::ostream&)
void test0(std::ostream& ss)
{
    digraph<char, int> g;
    g.add('A', 'B', 0)
        .add('B', 'C', 1)
        .add('C', 'A', 0)
        .add('D', 'B', 0)
        .add('D', 'C', 0)
        .add('D', 'E', 1)
        .add('E', 'D', 0)
        .add('E', 'F', 0)
        .add('F', 'G', 0)
        .add('G', 'F', 1)
        .add('H', 'G', 0)
        .add('H', 'E', 0)
        .add('H', 'H', 1);

    ss << "g = " << g;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x14ee8
leaq 0x33(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x32(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x64(%rsp), %rcx
movl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x1781e
leaq 0x31(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0x30(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x60(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x2f(%rsp), %rsi
movb $0x43, (%rsi)
leaq 0x2e(%rsp), %rdx
movb $0x41, (%rdx)
leaq 0x5c(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x2d(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x2c(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x58(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x2b(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x2a(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x54(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x29(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x28(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x50(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x27(%rsp), %rsi
movb $0x45, (%rsi)
leaq 0x26(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x4c(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x25(%rsp), %rsi
movb $0x45, (%rsi)
leaq 0x24(%rsp), %rdx
movb $0x46, (%rdx)
leaq 0x48(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x23(%rsp), %rsi
movb $0x46, (%rsi)
leaq 0x22(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x44(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x21(%rsp), %rsi
movb $0x47, (%rsi)
leaq 0x20(%rsp), %rdx
movb $0x46, (%rdx)
leaq 0x40(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1f(%rsp), %rsi
movb $0x48, (%rsi)
leaq 0x1e(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x3c(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1d(%rsp), %rsi
movb $0x48, (%rsi)
leaq 0x1c(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x38(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
movb $0x48, %al
leaq 0x1b(%rsp), %rsi
movb %al, (%rsi)
leaq 0x1a(%rsp), %rdx
movb %al, (%rdx)
leaq 0x34(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0xe9e4(%rip), %rsi      # 0x1d341
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe986
callq 0x3504
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
jmp 0xe9a8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xe9ba
callq 0x3504
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: res2[abi:cxx11]()
std::string res2()
{
    return "dag of g = Graph {Graph {H-1->H}-0->Graph {F-0->G, G-1->F}, Graph {H-1->H}-0->Graph "
           "{D-1->E, "
           "E-0->D}, Graph {F-0->G, G-1->F}, Graph {D-1->E, E-0->D}-0->Graph {F-0->G, G-1->F}, "
           "Graph {D-1->E, E-0->D}-0->Graph {A-0->B, B-1->C, C-0->A}, Graph {A-0->B, B-1->C, "
           "C-0->A}}";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xd94d(%rip), %rsi      # 0x1cfbb
leaq 0xda4f(%rip), %rdx      # 0x1d0c4
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: test4(std::ostream&)
void test4(std::ostream& ss)
{
    digraph<char, int> g1, g2, g3;
    g1.add('A', 'A', 2);
    g1.add('A', 'D', 1);
    g1.add('A', 'B', 0);

    g2.add('A', 'B', 2);
    g2.add('B', 'B', 1);
    g2.add('A', 'C', 0);

    g3.add(g1).add(g2);

    ss << "test4: g3.add(g1).add(g2) = " << g3;
    // std::cout << "test4: g1= " << g1 << std::endl;
    // std::cout << "test4: g2= " << g2 << std::endl;
    // std::cout << "test4: g3= " << g3 << std::endl;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x14ee8
leaq 0x10(%rsp), %rdi
callq 0x14ee8
leaq 0x30(%rsp), %rdi
callq 0x14ee8
movb $0x41, %al
leaq 0xb(%rsp), %rsi
movb %al, (%rsi)
leaq 0xa(%rsp), %rdx
movb %al, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x2, (%rcx)
movq 0x20(%rsp), %rdi
callq 0x1781e
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x20(%rsp), %rdi
callq 0x1781e
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x20(%rsp), %rdi
callq 0x1781e
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x2, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x1781e
movb $0x42, %al
leaq 0xb(%rsp), %rsi
movb %al, (%rsi)
leaq 0xa(%rsp), %rdx
movb %al, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x1781e
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x1781e
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x156a0
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x156a0
leaq 0xcf80(%rip), %rsi      # 0x1d1ef
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x21a0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x10298
callq 0x3504
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x102a7
callq 0x3504
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x102b6
callq 0x3504
addq $0x40, %rsp
popq %rbx
retq
jmp 0x102d2
jmp 0x102d2
jmp 0x102d2
jmp 0x102d2
jmp 0x102d2
jmp 0x102d2
movq %rax, %rbx
jmp 0x102e4
movq %rax, %rbx
jmp 0x102f3
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x102e4
callq 0x3504
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x102f3
callq 0x3504
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x10302
callq 0x3504
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: test11(std::ostream&)
void test11(std::ostream& ss)
{
    digraph<char, int> g;
    g.add('A', 'B', 0).add('B', 'C', 3).add('C', 'D', 0).add('D', 'E', 0);
    g.add('A', 'I', 0).add('I', 'J', 4).add('J', 'E', 5);

    digraph<char, int> r = chain(g, false);
    ss << "chain(" << g << ", false) = " << r;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x14ee8
leaq 0x4(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x3(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x28(%rsp), %rcx
movl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x1781e
leaq 0x2(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0x1(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x24(%rsp), %rcx
movl $0x3, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
movq %rsp, %rsi
movb $0x43, (%rsi)
leaq 0x7(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x6(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x5(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x1c(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1c(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x4(%rsp), %rdx
movb $0x49, (%rdx)
leaq 0x28(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x3(%rsp), %rsi
movb $0x49, (%rsi)
leaq 0x2(%rsp), %rdx
movb $0x4a, (%rdx)
leaq 0x24(%rsp), %rcx
movl $0x4, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1(%rsp), %rsi
movb $0x4a, (%rsi)
movq %rsp, %rdx
movb $0x45, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x5, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x16a8f
leaq 0xb26a(%rip), %rsi      # 0x1daa2
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq %rax, %rbx
leaq 0xb24d(%rip), %rsi      # 0x1daa9
movl $0xb, %edx
movq %rax, %rdi
callq 0x21a0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x12885
callq 0x3504
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x12894
callq 0x3504
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x128aa
jmp 0x128aa
jmp 0x128aa
jmp 0x128aa
jmp 0x128aa
jmp 0x128aa
jmp 0x128aa
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x128bc
callq 0x3504
movq %rbx, %rdi
callq 0x2250
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x128ad
callq 0x3504
jmp 0x128ad
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: res11[abi:cxx11]()
std::string res11()
{
    return "chain(Graph {A-0->B, A-0->I, B-3->C, C-0->D, D-0->E, E, I-4->J, J-5->E}, false) = "
           "Graph {A, "
           "B-3->C, "
           "C-0->D, D, E, I-4->J, J}";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xb1cb(%rip), %rsi      # 0x1dab5
leaq 0xb240(%rip), %rdx      # 0x1db31
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: test12(std::ostream&)
void test12(std::ostream& ss)
{
    digraph<char, int> g;
    g.add('A', 'B', 0).add('B', 'C', 3).add('C', 'D', 0).add('D', 'E', 0);
    g.add('A', 'I', 0).add('I', 'J', 4).add('J', 'E', 5);

    digraph<char, int> r = chain(g, true);
    ss << "chain(" << g << ", true) = " << r;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x14ee8
leaq 0x4(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x3(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x28(%rsp), %rcx
movl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x1781e
leaq 0x2(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0x1(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x24(%rsp), %rcx
movl $0x3, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
movq %rsp, %rsi
movb $0x43, (%rsi)
leaq 0x7(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x6(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x5(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x1c(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1c(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x4(%rsp), %rdx
movb $0x49, (%rdx)
leaq 0x28(%rsp), %rcx
movl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x3(%rsp), %rsi
movb $0x49, (%rsi)
leaq 0x2(%rsp), %rdx
movb $0x4a, (%rdx)
leaq 0x24(%rsp), %rcx
movl $0x4, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x1(%rsp), %rsi
movb $0x4a, (%rsi)
movq %rsp, %rdx
movb $0x45, (%rdx)
leaq 0x20(%rsp), %rcx
movl $0x5, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x1781e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x16a8f
leaq 0xad5d(%rip), %rsi      # 0x1daa2
movl $0x6, %edx
movq %rbx, %rdi
callq 0x21a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq %rax, %rbx
leaq 0xade1(%rip), %rsi      # 0x1db4a
movl $0xa, %edx
movq %rax, %rdi
callq 0x21a0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x14f39
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x12d92
callq 0x3504
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x12da1
callq 0x3504
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x12db7
jmp 0x12db7
jmp 0x12db7
jmp 0x12db7
jmp 0x12db7
jmp 0x12db7
jmp 0x12db7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x12dc9
callq 0x3504
movq %rbx, %rdi
callq 0x2250
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x12dba
callq 0x3504
jmp 0x12dba
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: res13[abi:cxx11]()
std::string res13()
{
    return "graph h   : Graph {A-0->B, B-0->C, B-0->G, C-0->D, D, E-0->F, F-0->G, G-0->H, H}\n"
           "roots(h)  : std::vector{A, E}\n"
           "leafs(h)  : std::vector{D, H}\n"
           "Schedule {1:D, 2:C, 3:H, 4:G, 5:B, 6:A, 7:F, 8:E}, cost: 11\n"
           "Schedule {1:D, 2:H, 3:C, 4:G, 5:B, 6:F, 7:A, 8:E}, cost: 13\n";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xa234(%rip), %rsi      # 0x1dc13
leaq 0xa332(%rip), %rdx      # 0x1dd18
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/tests.cpp
// Function: res15[abi:cxx11]()
std::string res15()
{
    return "graph h   : Graph {A-0->B, B-0->C, B-1->G, C-1->B, C-0->D, D-0->U, E-0->F, F-0->G, "
           "G-2->F, G-0->H, "
           "H, U-1->D}\n"
           "deep-first    : Schedule {1:U, 2:D, 3:H, 4:G, 5:F, 6:C, 7:B, 8:A, 9:E}, cost: 20\n"
           "breadth-first : Schedule {1:H, 2:U, 3:D, 4:G, 5:F, 6:C, 7:B, 8:E, 9:A}, cost: 18\n";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x9309(%rip), %rsi      # 0x1de09
leaq 0x9412(%rip), %rdx      # 0x1df19
callq 0x3130
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/digraph.hh
// Function: digraph<char, int>::add(digraph<char, int> const&)
digraph& add(const digraph& g)
    {
        for (auto& n : g.nodes()) {
            add(n);
            for (auto& c : g.connections(n)) {
                add(n, c.first, c.second);
            }
        }
        return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq (%rsi), %r12
movq 0x18(%r12), %r15
addq $0x8, %r12
cmpq %r12, %r15
je 0x15754
leaq 0x20(%r15), %r13
movb 0x20(%r15), %al
movq (%rbx), %r14
movb %al, 0xf(%rsp)
movq %r14, %rdi
leaq 0xf(%rsp), %rbp
movq %rbp, %rsi
callq 0x3d48
addq $0x30, %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x178ea
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
movq %rax, %rbp
movq 0x18(%rax), %r14
addq $0x8, %rbp
cmpq %rbp, %r14
je 0x15740
leaq 0x20(%r14), %rdx
leaq 0x24(%r14), %rcx
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x1781e
movq %r14, %rdi
callq 0x21b0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x1571d
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %r12, %rax
jne 0x156cb
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: void splitgraph<char, int>(digraph<char, int> const&, std::function<bool (char const&)>, digraph<char, int>&, digraph<char, int>&)
void splitgraph(const digraph<N, A>& G, std::function<bool(const N&)> left, digraph<N, A>& L, digraph<N, A>& R)
{
    for (auto n : G.nodes()) {
        if (left(n)) {
            L.add(n);
            for (const auto& c : G.connections(n)) {
                if (left(c.first)) {
                    L.add(n, c.first, c.second);
                }
            }
        } else {
            R.add(n);
            for (const auto& c : G.connections(n)) {
                if (!left(c.first)) {
                    R.add(n, c.first, c.second);
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq 0x18(%rax), %r13
addq $0x8, %rax
movq %rax, 0x20(%rsp)
cmpq %rax, %r13
je 0x1590e
movq %rsi, %r15
leaq 0x5(%rsp), %rbp
movb 0x20(%r13), %al
movb %al, 0x5(%rsp)
cmpq $0x0, 0x10(%r15)
je 0x1591d
movq %r15, %rdi
movq %rbp, %rsi
callq *0x18(%r15)
movb 0x5(%rsp), %cl
testb %al, %al
je 0x15869
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movb %cl, 0x6(%rsp)
movq %rbx, %rdi
leaq 0x6(%rsp), %r14
movq %r14, %rsi
callq 0x3d48
addq $0x30, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x178ea
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq %rbp, %rsi
callq 0x17ddc
movq %rax, %r12
movq 0x18(%rax), %rbx
addq $0x8, %r12
cmpq %r12, %rbx
je 0x158f8
cmpq $0x0, 0x10(%r15)
je 0x1591d
leaq 0x20(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
testb %al, %al
je 0x15854
leaq 0x24(%rbx), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1781e
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rbx
cmpq %r12, %rax
jne 0x15820
jmp 0x158f8
movq 0x18(%rsp), %rax
movq (%rax), %rbx
movb %cl, 0x7(%rsp)
movq %rbx, %rdi
leaq 0x7(%rsp), %r14
movq %r14, %rsi
callq 0x3d48
addq $0x30, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x178ea
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq %rbp, %rsi
callq 0x17ddc
movq %rax, %r12
movq 0x18(%rax), %rbx
addq $0x8, %r12
cmpq %r12, %rbx
je 0x158f8
cmpq $0x0, 0x10(%r15)
je 0x1591d
leaq 0x20(%rbx), %r14
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%r15)
testb %al, %al
jne 0x158e8
leaq 0x24(%rbx), %rcx
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x1781e
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rbx
cmpq %r12, %rax
jne 0x158b8
movq %r13, %rdi
callq 0x21b0
movq %rax, %r13
cmpq 0x20(%rsp), %rax
jne 0x157a4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: std::vector<digraph<char, int>, std::allocator<digraph<char, int>>> serialize<digraph<char, int>, int>(digraph<digraph<char, int>, int> const&)
inline std::vector<N> serialize(const digraph<N, A>& G)
{
    //------------------------------------------------------------------------
    // visit : a local std::function (simulated using a lambda) to visit a graph
    // g : the graph
    // n : the node
    // V : std::set of already visited nodes
    // S : serialized std::vector of nodes
    //------------------------------------------------------------------------
    using Visitfun = std::function<void(const digraph<N, A>&, const N&, std::set<N>&, std::vector<N>&)>;
    Visitfun visit = [&visit](const digraph<N, A>& g, const N& n, std::set<N>& V, std::vector<N>& S) {
        if (V.find(n) == V.end()) {
            V.insert(n);
            for (const auto& p : g.connections(n)) {
                visit(g, p.first, V, S);
            }
            S.push_back(n);
        }
    };

    std::vector<N> S;
    std::set<N>    V;
    for (const N& n : G.nodes()) {
        visit(G, n, V, S);
    }
    return S;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %rcx, (%rcx)
leaq 0x4782(%rip), %rdx      # 0x1a262
movq %rdx, 0x18(%rcx)
leaq 0x477d(%rip), %rdx      # 0x1a268
movq %rdx, 0x10(%rcx)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq (%rsi), %rbp
movq 0x18(%rbp), %r15
addq $0x8, %rbp
cmpq %rbp, %r15
je 0x15b5d
movq %rsi, %r14
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
cmpq $0x0, 0x18(%rsp)
je 0x15b92
leaq 0x20(%r15), %rdx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rcx
movq %rbx, %r8
callq *0x20(%rsp)
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %rbp, %rax
jne 0x15b31
leaq 0x28(%rsp), %rdi
callq 0x18ac2
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x15b80
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2090
jmp 0x15bd1
jmp 0x15b9b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x18ac2
movq %rbx, %rdi
callq 0x164aa
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x15bc9
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x2250
movq %rax, %rdi
callq 0x31c5
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/stdprinting.hh
// Function: std::ostream& operator<<<char>(std::ostream&, std::vector<char, std::allocator<char>> const&)
inline std::ostream& operator<<(std::ostream& file, const std::vector<N>& V)
{
    std::string sep = "";

    file << "std::vector{";
    for (const N& e : V) {
        file << sep << e;
        sep = ", ";
    }
    return file << "}";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x54b1(%rip), %rdx      # 0x1c0c7
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3130
leaq 0x733c(%rip), %rsi      # 0x1df66
movl $0xc, %edx
movq %rbx, %rdi
callq 0x21a0
movq (%r14), %rbp
movq 0x8(%r14), %r13
cmpq %r13, %rbp
je 0x16c9d
leaq 0x7(%rsp), %r14
leaq 0x5421(%rip), %r15      # 0x1c070
leaq 0x8(%rsp), %r12
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a0
movb (%rbp), %cl
movb %cl, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movq 0x10(%rsp), %rdx
movl $0x2, %r8d
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x2200
incq %rbp
cmpq %r13, %rbp
jne 0x16c54
leaq 0x65b7(%rip), %rsi      # 0x1d25b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16cc5
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16cd9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16cf0
callq 0x2150
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/grame-cncm[P]digraph/./dglib/stdprinting.hh
// Function: std::ostream& operator<<<char>(std::ostream&, std::set<char, std::less<char>, std::allocator<char>> const&)
inline std::ostream& operator<<(std::ostream& file, const std::set<N>& S)
{
    std::string sep = "";

    file << "std::set{";
    for (const N& e : S) {
        file << sep << e;
        sep = ", ";
    }
    return file << "}";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x58cf(%rip), %rdx      # 0x1c0c7
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3130
leaq 0x7767(%rip), %rsi      # 0x1df73
movl $0x9, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x16889
leaq 0x7(%rsp), %r12
leaq 0x583e(%rip), %r13      # 0x1c070
leaq 0x8(%rsp), %rbp
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a0
movb 0x20(%r15), %cl
movb %cl, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21a0
movq 0x10(%rsp), %rdx
movl $0x2, %r8d
movq %rbp, %rdi
xorl %esi, %esi
movq %r13, %rcx
callq 0x2200
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %r14, %rax
jne 0x16837
leaq 0x69cb(%rip), %rsi      # 0x1d25b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x168b1
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x168c5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x168dc
callq 0x2150
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14ee8
movq %r14, 0x10(%rsp)
movq (%r14), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
movq %rax, 0x8(%rsp)
cmpq %rax, %r15
je 0x169a6
leaq 0x7(%rsp), %r12
movb 0x20(%r15), %al
movq (%rbx), %r14
movb %al, 0x7(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d48
addq $0x30, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x178ea
leaq 0x20(%r15), %r13
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
movq %rax, %rbp
movq 0x18(%rax), %r14
addq $0x8, %rbp
cmpq %rbp, %r14
je 0x16990
leaq 0x20(%r14), %rsi
leaq 0x24(%r14), %rcx
movq (%rbx), %rdi
movq %r13, %rdx
callq 0x1781e
movq %r14, %rdi
callq 0x21b0
movq %rax, %r14
cmpq %rbp, %rax
jne 0x1696d
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq 0x8(%rsp), %rax
jne 0x16920
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x169bc
jmp 0x169bc
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x169cd
callq 0x3504
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rsi
movq (%rbx), %rax
movq 0x28(%rsi), %rcx
cmpq 0x28(%rax), %rcx
jne 0x16a7e
movq %rdi, %r14
movq 0x18(%rsi), %rdi
addq $0x8, %rsi
movq 0x18(%rax), %rdx
callq 0x1a7e8
testb %al, %al
je 0x16a7e
movq (%r14), %rbp
movq 0x18(%rbp), %r15
addq $0x8, %rbp
movb $0x1, %al
cmpq %rbp, %r15
je 0x16a80
leaq 0x20(%r15), %r13
movq (%r14), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
movq %rax, %r12
movq (%rbx), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
movq 0x28(%r12), %rcx
cmpq 0x28(%rax), %rcx
jne 0x16a7e
movq 0x18(%r12), %rdi
addq $0x8, %r12
movq 0x18(%rax), %rdx
movq %r12, %rsi
callq 0x1a838
testb %al, %al
je 0x16a7e
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %rbp, %rax
jne 0x16a21
movb $0x1, %al
jmp 0x16a80
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x168e4
movq %rbx, %rdi
callq 0x14ee8
movq (%r12), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
movq %rax, 0x10(%rsp)
cmpq %rax, %r15
je 0x16ba0
movq %r12, 0x8(%rsp)
leaq 0x20(%r15), %r13
cmpb $0x0, 0x4(%rsp)
jne 0x16b0c
movb (%r13), %al
movq (%rbx), %r14
movb %al, 0x3(%rsp)
movq %r14, %rdi
leaq 0x3(%rsp), %rsi
callq 0x3d48
addq $0x30, %r14
movq %r14, %rdi
leaq 0x3(%rsp), %rsi
callq 0x178ea
movq (%r12), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
cmpq $0x1, 0x28(%rax)
jne 0x16b85
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq %r13, %rsi
callq 0x17ddc
movq %rax, %r12
movq 0x18(%rax), %rbp
addq $0x8, %r12
cmpq %r12, %rbp
je 0x16b85
leaq 0x20(%rbp), %r14
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x17ddc
cmpq $0x1, 0x28(%rax)
jne 0x16b75
leaq 0x24(%rbp), %rcx
movq (%rbx), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1781e
movq %rbp, %rdi
callq 0x21b0
movq %rax, %rbp
cmpq %r12, %rax
jne 0x16b47
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
jne 0x16ad8
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x16baf
callq 0x3504
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x16bdb
jmp 0x16bca
jmp 0x16bca
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x16bdb
callq 0x3504
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x16bea
callq 0x3504
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbp
leaq 0x10(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%rsi), %r13
movq 0x18(%r13), %r14
leaq 0x8(%r13), %rbx
cmpq %rbx, %r14
je 0x16d9b
movq %rsi, %r15
movq %rbp, (%rsp)
leaq 0x8(%rsp), %r12
leaq 0x20(%r14), %rsi
movq (%r15), %rdi
addq $0x30, %rdi
callq 0x17ddc
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0x16d80
leaq 0x20(%rbp), %rsi
movq %r12, %rdi
callq 0x17950
incl (%rax)
movq %rbp, %rdi
callq 0x21b0
movq %rax, %rbp
cmpq %r13, %rax
jne 0x16d62
movq %r14, %rdi
callq 0x21b0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x16d42
movq (%r15), %r13
movq 0x18(%r13), %r14
movq (%rsp), %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
addq $0x8, %r13
cmpq %r13, %r14
je 0x16dfd
leaq 0x8(%rsp), %r15
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x17950
cmpl $0x0, (%rax)
jne 0x16ded
movq 0x8(%rbp), %rsi
cmpq 0x10(%rbp), %rsi
je 0x16de2
movb (%r12), %al
movb %al, (%rsi)
incq 0x8(%rbp)
jmp 0x16ded
movq %rbp, %rdi
movq %r12, %rdx
callq 0x1a89a
movq %r14, %rdi
callq 0x21b0
movq %rax, %r14
cmpq %r13, %rax
jne 0x16db8
leaq 0x8(%rsp), %rdi
callq 0x176c6
movq %rbp, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16e2e
movq %rax, %r14
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x16e31
callq 0x2150
jmp 0x16e31
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x176c6
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5260(%rip), %rdx      # 0x1c0c7
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3130
leaq 0x711d(%rip), %rsi      # 0x1df98
movl $0xa, %edx
movq %rbx, %rdi
callq 0x21a0
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x16f4a
leaq 0x20(%r14), %rbp
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x21a0
movq 0x28(%r14), %rdx
xorl %esi, %esi
testq %rdx, %rdx
je 0x16ee7
movb (%r12), %dil
movq %rbp, %rcx
xorl %r8d, %r8d
cmpb %dil, 0x20(%rdx)
setl %r8b
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x16ec0
cmpq %rbp, %rcx
je 0x16ee7
cmpb 0x20(%rcx), %dil
jl 0x16ee7
movl 0x24(%rcx), %esi
movq %rax, %rdi
callq 0x2240
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x51c7(%rip), %rsi      # 0x1c0c8
callq 0x21a0
movb (%r12), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
leaq 0x7(%rsp), %rsi
callq 0x21a0
movq 0x10(%rsp), %rdx
movl $0x2, %r8d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
leaq 0x5137(%rip), %rcx      # 0x1c070
callq 0x2200
incq %r12
cmpq %r13, %r12
jne 0x16e9c
leaq 0x630a(%rip), %rsi      # 0x1d25b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16f72
callq 0x2150
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16f86
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16f9d
callq 0x2150
movq %rbx, %rdi
callq 0x2250