LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check8()
bool check8()
{
    std::stringstream ss;
    test8(ss);
    bool ok = (0 == ss.str().compare(res8()));
    if (ok) {
        std::cout << "test8 OK " << std::endl;
    } else {
        std::cout << "test8 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res8() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xc2ca
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xc59b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xc6c4
movq 0x169a3(%rip), %rdi     # 0x22fd0
leaq 0xa2df(%rip), %rsi      # 0x16913
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x16988(%rip), %rdi     # 0x22fd0
leaq 0x98ee(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x16946(%rip), %rdi     # 0x22fd0
leaq 0x98b8(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc59b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xc6df
movq 0x16905(%rip), %rdi     # 0x22fd0
leaq 0xa237(%rip), %rsi      # 0x16909
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc727
jmp 0xc727
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xc71b
jmp 0xc718
jmp 0xc727
jmp 0xc727
jmp 0xc718
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xc72a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check9()
bool check9()
{
    std::stringstream ss;
    test9(ss);
    bool ok = (0 == ss.str().compare(res9()));
    if (ok) {
        std::cout << "test9 OK " << std::endl;
    } else {
        std::cout << "test9 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res9() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xc73c
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xca0b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xcb34
movq 0x16533(%rip), %rdi     # 0x22fd0
leaq 0x9f7c(%rip), %rsi      # 0x16a20
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x16518(%rip), %rdi     # 0x22fd0
leaq 0x947e(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x164d6(%rip), %rdi     # 0x22fd0
leaq 0x9448(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xca0b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xcb4f
movq 0x16495(%rip), %rdi     # 0x22fd0
leaq 0x9ed4(%rip), %rsi      # 0x16a16
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xcb97
jmp 0xcb97
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xcb8b
jmp 0xcb88
jmp 0xcb97
jmp 0xcb97
jmp 0xcb88
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xcb9a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe2d6
leaq 0x4(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x3(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x28(%rsp), %rcx
andl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x102c4
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 0x102c4
movq %rsp, %rsi
movb $0x43, (%rsi)
leaq 0x7(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x20(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x6(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x5(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x1c(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x1c(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x4(%rsp), %rdx
movb $0x49, (%rdx)
leaq 0x28(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
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 0x102c4
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 0x102c4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xf7c4
leaq 0x9aa9(%rip), %rsi      # 0x16a5e
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x9a94(%rip), %rsi      # 0x16a65
movq %rax, %rdi
callq 0x2140
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x30(%rsp), %rdi
callq 0x2efc
leaq 0x10(%rsp), %rdi
callq 0x2efc
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xd010
jmp 0xd010
jmp 0xd010
jmp 0xd010
jmp 0xd010
jmp 0xd010
jmp 0xd010
movq %rax, %rbx
jmp 0xd022
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2efc
leaq 0x10(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check11()
bool check11()
{
    std::stringstream ss;
    test11(ss);
    bool ok = (0 == ss.str().compare(res11()));
    if (ok) {
        std::cout << "test11 OK " << std::endl;
    } else {
        std::cout << "test11 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res9() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xce95
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xd034
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xd15d
movq 0x15f0a(%rip), %rdi     # 0x22fd0
leaq 0x9a2c(%rip), %rsi      # 0x16af9
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x15eef(%rip), %rdi     # 0x22fd0
leaq 0x8e55(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x15ead(%rip), %rdi     # 0x22fd0
leaq 0x8e1f(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xca0b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd178
movq 0x15e6c(%rip), %rdi     # 0x22fd0
leaq 0x9983(%rip), %rsi      # 0x16aee
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd1c0
jmp 0xd1c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xd1b4
jmp 0xd1b1
jmp 0xd1c0
jmp 0xd1c0
jmp 0xd1b1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd1c3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe2d6
leaq 0x4(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x3(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x28(%rsp), %rcx
andl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x102c4
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 0x102c4
movq %rsp, %rsi
movb $0x43, (%rsi)
leaq 0x7(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x20(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x6(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x5(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x1c(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x1c(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x4(%rsp), %rdx
movb $0x49, (%rdx)
leaq 0x28(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
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 0x102c4
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 0x102c4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xf7c4
leaq 0x9768(%rip), %rsi      # 0x16a5e
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x97f4(%rip), %rsi      # 0x16b06
movq %rax, %rdi
callq 0x2140
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x30(%rsp), %rdi
callq 0x2efc
leaq 0x10(%rsp), %rdi
callq 0x2efc
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xd351
jmp 0xd351
jmp 0xd351
jmp 0xd351
jmp 0xd351
jmp 0xd351
jmp 0xd351
movq %rax, %rbx
jmp 0xd363
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2efc
leaq 0x10(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check12()
bool check12()
{
    std::stringstream ss;
    test12(ss);
    bool ok = (0 == ss.str().compare(res12()));
    if (ok) {
        std::cout << "test12 OK " << std::endl;
    } else {
        std::cout << "test12 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res12() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xd1d5
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xd375
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xd49e
movq 0x15bc9(%rip), %rdi     # 0x22fd0
leaq 0x9784(%rip), %rsi      # 0x16b92
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x15bae(%rip), %rdi     # 0x22fd0
leaq 0x8b14(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x15b6c(%rip), %rdi     # 0x22fd0
leaq 0x8ade(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xd375
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd4b9
movq 0x15b2b(%rip), %rdi     # 0x22fd0
leaq 0x96db(%rip), %rsi      # 0x16b87
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd501
jmp 0xd501
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xd4f5
jmp 0xd4f2
jmp 0xd501
jmp 0xd501
jmp 0xd4f2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd504
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check13()
bool check13()
{
    std::stringstream ss;
    test13(ss);
    bool ok = (0 == ss.str().compare(res13()));
    if (ok) {
        std::cout << "test13 OK " << std::endl;
    } else {
        std::cout << "test13 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res13() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xd516
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xd81b
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xd944
movq 0x15723(%rip), %rdi     # 0x22fd0
leaq 0x942c(%rip), %rsi      # 0x16ce0
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x15708(%rip), %rdi     # 0x22fd0
leaq 0x866e(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x156c6(%rip), %rdi     # 0x22fd0
leaq 0x8638(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xd81b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd95f
movq 0x15685(%rip), %rdi     # 0x22fd0
leaq 0x9383(%rip), %rsi      # 0x16cd5
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd9a7
jmp 0xd9a7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xd99b
jmp 0xd998
jmp 0xd9a7
jmp 0xd9a7
jmp 0xd998
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xd9aa
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: test14(std::ostream&)
void test14(std::ostream& ss)
{
    // roots and leaves
    digraph<char, int> h;
    h.add('A', 'B', 0).add('B', 'C', 0).add('C', 'D', 0).add('B', 'G', 1).add('C', 'B', 1);
    h.add('E', 'F', 0).add('F', 'G', 0).add('G', 'H', 0).add('G', 'F', 2);

    ss << "graph h   : " << h << std::endl;
    ss << dfcyclesschedule(h) << ", cost: " << schedulingcost(h, dfcyclesschedule(h)) << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xe2d6
leaq 0x14(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x13(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x80(%rsp), %rcx
andl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x102c4
leaq 0x12(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0x11(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x38(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x10(%rsp), %rsi
movb $0x43, (%rsi)
leaq 0xf(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x34(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0xe(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0x17(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x30(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x16(%rsp), %rsi
movb $0x43, (%rsi)
leaq 0x15(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x2c(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x2c(%rsp), %rsi
movb $0x45, (%rsi)
leaq 0x14(%rsp), %rdx
movb $0x46, (%rdx)
leaq 0x80(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x13(%rsp), %rsi
movb $0x46, (%rsi)
leaq 0x12(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x38(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x11(%rsp), %rsi
movb $0x47, (%rsi)
leaq 0x10(%rsp), %rdx
movb $0x48, (%rdx)
leaq 0x34(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0xf(%rsp), %rsi
movb $0x47, (%rsi)
leaq 0xe(%rsp), %rdx
movb $0x46, (%rdx)
leaq 0x30(%rsp), %rcx
movl $0x2, (%rcx)
movq 0x18(%rsp), %rdi
callq 0x102c4
leaq 0x9083(%rip), %rsi      # 0x16b9f
movq %rbx, %rdi
callq 0x2140
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
movq %rax, %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfe9e
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0xfb3b
leaq 0x9064(%rip), %rsi      # 0x16bc6
movq %rax, %rdi
callq 0x2140
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xfe9e
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xfd28
movq %rbx, %rdi
movl %eax, %esi
callq 0x2210
movq %rax, %rdi
callq 0x20b0
leaq 0x38(%rsp), %rdi
callq 0xfdcc
leaq 0x80(%rsp), %rdi
callq 0xfdcc
leaq 0x20(%rsp), %rdi
callq 0x2efc
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
jmp 0xdbdf
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
jmp 0xdc00
movq %rax, %rbx
jmp 0xdbf1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfdcc
leaq 0x80(%rsp), %rdi
callq 0xfdcc
jmp 0xdc03
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check14()
bool check14()
{
    std::stringstream ss;
    test14(ss);
    bool ok = (0 == ss.str().compare(res14()));
    if (ok) {
        std::cout << "test14 OK " << std::endl;
    } else {
        std::cout << "test14 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res14() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xd9bc
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xdc15
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xdd3e
movq 0x15329(%rip), %rdi     # 0x22fd0
leaq 0x90e8(%rip), %rsi      # 0x16d96
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x1530e(%rip), %rdi     # 0x22fd0
leaq 0x8274(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x152cc(%rip), %rdi     # 0x22fd0
leaq 0x823e(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdc15
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xdd59
movq 0x1528b(%rip), %rdi     # 0x22fd0
leaq 0x903f(%rip), %rsi      # 0x16d8b
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xdda1
jmp 0xdda1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xdd95
jmp 0xdd92
jmp 0xdda1
jmp 0xdda1
jmp 0xdd92
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xdda4
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check15()
bool check15()
{
    std::stringstream ss;
    test15(ss);
    bool ok = (0 == ss.str().compare(res15()));
    if (ok) {
        std::cout << "test15 OK " << std::endl;
    } else {
        std::cout << "test15 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res15() << std::endl;
    }
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
leaq 0x48(%rsp), %rdi
callq 0x20e0
leaq 0x58(%rsp), %rdi
callq 0xddb6
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xe0e6
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2030
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x20a0
testl %ebx, %ebx
je 0xe20f
movq 0x14e58(%rip), %rdi     # 0x22fd0
leaq 0x8d62(%rip), %rsi      # 0x16ee1
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x14e3d(%rip), %rdi     # 0x22fd0
leaq 0x7da3(%rip), %rsi      # 0x15f3d
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x14dfb(%rip), %rdi     # 0x22fd0
leaq 0x7d6d(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xe0e6
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xe22a
movq 0x14dba(%rip), %rdi     # 0x22fd0
leaq 0x8cb9(%rip), %rsi      # 0x16ed6
callq 0x2140
movq %rax, %rdi
callq 0x20b0
testl %ebx, %ebx
sete %bl
leaq 0x48(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xe272
jmp 0xe272
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xe266
jmp 0xe263
jmp 0xe272
jmp 0xe272
jmp 0xe263
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xe275
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: digraph<digraph<char, int>, int> mapnodes<digraph<char, int>, digraph<char, int>, int>(digraph<digraph<char, int>, int> const&, std::function<digraph<char, int> (digraph<char, int> const&)>)
inline digraph<M, A> mapnodes(const digraph<N, A>& g, std::function<M(const N&)> foo)
{
    digraph<M, A>  r;
    std::map<N, M> cache;
    // create a new graph with the transformed nodes
    for (const auto& n1 : g.nodes()) {
        M n2 = foo(n1);
        r.add(n2);
        cache.insert(std::make_pair(n1, n2));
    }

    // copy the connections
    for (const auto& n : g.nodes()) {
        for (const auto& cnx : g.connections(n)) {
            r.add(cache[n], cache[cnx.first], cnx.second);
        }
    }
    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x112ce
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x10(%rsp)
movq (%r14), %rax
movq 0x18(%rax), %rbp
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %r15
leaq 0x68(%rsp), %r14
cmpq 0x8(%rsp), %rbp
je 0xe887
leaq 0x20(%rbp), %r12
movq %r15, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x125a6
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x11ce8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1130c
leaq 0x20(%rsp), %rdi
callq 0x2efc
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x12822
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x12628
movq %r14, %rdi
callq 0x125be
leaq 0x30(%rsp), %rdi
callq 0x2efc
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xe80e
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rax
addq $0x8, %rcx
movq %rcx, (%rsp)
leaq 0x38(%rsp), %r12
cmpq (%rsp), %rax
je 0xe911
movq %rax, 0x8(%rsp)
leaq 0x20(%rax), %r14
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x123d4
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0xe905
movq %r12, %rdi
movq %r14, %rsi
callq 0x125d8
movq %rax, %r15
leaq 0x20(%rbp), %rsi
movq %r12, %rdi
callq 0x125d8
leaq 0x30(%rbp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x113ac
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xe8c7
movq 0x8(%rsp), %rdi
callq 0x2170
jmp 0xe8a0
leaq 0x38(%rsp), %rdi
callq 0x12a92
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe95c
jmp 0xe95c
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2efc
jmp 0xe950
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x125be
leaq 0x30(%rsp), %rdi
callq 0x2efc
jmp 0xe95f
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x12a92
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2efc
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq (%rsi), %r14
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xe9fa
leaq 0x20(%r15), %r12
movsbl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x112fa
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x10938
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0xe9ed
leaq 0x20(%rbp), %rdx
leaq 0x24(%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe302
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xe9c8
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xe99b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq (%rdi), %rcx
movq 0x18(%rcx), %rax
addq $0x8, %rcx
movq %rcx, 0x18(%rsp)
leaq 0x7(%rsp), %r13
cmpq 0x18(%rsp), %rax
je 0xeb2f
movq %rax, 0x20(%rsp)
movb 0x20(%rax), %al
movb %al, 0x7(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x12adc
movsbl 0x7(%rsp), %esi
testb %al, %al
je 0xeac5
movq %r14, %rdi
callq 0x112fa
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x10938
movq %rax, %r12
movq 0x18(%rax), %rbp
addq $0x8, %r12
cmpq %r12, %rbp
je 0xeb20
leaq 0x20(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12adc
testb %al, %al
je 0xeab8
leaq 0x24(%rbp), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xe302
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xea8a
movq 0x10(%rsp), %rdi
callq 0x112fa
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x10938
movq %rax, %r12
movq 0x18(%rax), %rbp
addq $0x8, %r12
cmpq %r12, %rbp
je 0xeb20
leaq 0x20(%rbp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12adc
testb %al, %al
jne 0xeb13
leaq 0x24(%rbp), %rcx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xe302
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xeae7
movq 0x20(%rsp), %rdi
callq 0x2170
jmp 0xea3f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: std::vector<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>, std::allocator<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>>> parallelize<digraph<char, int>, int>(digraph<digraph<char, int>, int> const&)
inline std::vector<std::vector<N>> parallelize(const digraph<N, A>& g)
{
    //-----------------------------------------------------------
    // Find the level of a node n -> {m1,m2,...} such that
    //		level(n -> {})			= 0
    //		level(n -> {m1,m2,...})	= 1 + std::max(level(mi))
    //-----------------------------------------------------------
    using Levelfun = std::function<int(const N&, std::map<N, int>&)>;

    Levelfun level = [&g, &level](const N& n1, std::map<N, int>& levelcache) -> int {
        auto p = levelcache.find(n1);
        if (p != levelcache.end()) {
            return p->second;
        } else {
            int l = -1;
            for (const auto& e : g.connections(n1)) {
                l = std::max(l, level(e.first, levelcache));
            }
            return levelcache[n1] = l + 1;
        }
    };

    std::map<N, int> levelcache;
    // compute the level of each node in the graph
    int l = -1;
    for (const N& n : g.nodes()) {
        l = std::max(l, level(n, levelcache));
    }
    // create a graph for each level and place
    // each node in the appropriate level
    std::vector<std::vector<N>> v;
    v.resize(l + 1);
    for (const N& n : g.nodes()) {
        v[levelcache[n]].push_back(n);
    }

    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %rsi, (%r15)
movq %r15, 0x8(%r15)
leaq 0x4004(%rip), %rax      # 0x12b66
leaq 0x10(%rsp), %rcx
andl $0x0, (%rcx)
movq %rax, 0x18(%r15)
andq $0x0, 0x8(%rcx)
leaq 0x3ff2(%rip), %rax      # 0x12b6c
movq %rax, 0x10(%r15)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
movq %rsi, (%rsp)
movq (%rsi), %r14
movq 0x18(%r14), %r13
addq $0x8, %r14
pushq $-0x1
popq %r12
leaq 0x8(%rsp), %rbp
cmpq %r14, %r13
je 0xebcb
leaq 0x20(%r13), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x12af0
cmpl %eax, %r12d
cmovlel %eax, %r12d
movq %r13, %rdi
callq 0x2170
movq %rax, %r13
jmp 0xeba3
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
incl %r12d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12b04
movq (%rsp), %rax
movq (%rax), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
leaq 0x8(%rsp), %r14
cmpq %r13, %r15
je 0xec2b
leaq 0x20(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x11fee
movslq (%rax), %rax
imulq $0x18, %rax, %rdi
addq (%rbx), %rdi
movq %r12, %rsi
callq 0x12b3a
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xebf8
leaq 0x8(%rsp), %rdi
callq 0x11534
leaq 0x38(%rsp), %rdi
callq 0x14342
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xec58
movq %rax, %r14
jmp 0xec63
movq %rax, %r14
movq %rbx, %rdi
callq 0xf3b0
leaq 0x8(%rsp), %rdi
callq 0x11534
leaq 0x38(%rsp), %rdi
callq 0x14342
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: std::vector<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>, std::allocator<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>>> rparallelize<digraph<char, int>, int>(digraph<digraph<char, int>, int> const&)
inline std::vector<std::vector<N>> rparallelize(const digraph<N, A>& G)
{
    std::vector<std::vector<N>> P = parallelize(G);
    int                         i = 0;
    int                         j = P.size() - 1;

    while (i < j) {
        swap(P[i], P[j]);
        ++i;
        --j;
    }

    return P;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xeb3e
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
decl %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq %r14d, %r14
cmpq %r14, %r12
jge 0xecd1
movq (%rbx), %rax
leaq (%rax,%r15), %rdi
imulq $0x18, %r14, %rsi
addq %rax, %rsi
callq 0x13042
incq %r12
addq $0x18, %r15
decl %r14d
jmp 0xecaa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
andq $0x0, 0x8(%r14)
movq %rsi, %r15
movq %rdi, %rbx
movq %r14, (%r14)
leaq 0x4374(%rip), %rax      # 0x1307c
movq %rax, 0x18(%r14)
leaq 0x436f(%rip), %rax      # 0x13082
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %rbp
movq 0x18(%rbp), %r13
addq $0x8, %rbp
leaq 0x28(%rsp), %r12
cmpq %rbp, %r13
je 0xed73
leaq 0x20(%r13), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %rbx, %r8
callq 0x13068
movq %r13, %rdi
callq 0x2170
movq %rax, %r13
jmp 0xed4c
leaq 0x28(%rsp), %rdi
callq 0x11594
leaq 0x8(%rsp), %rdi
callq 0x14342
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x11594
movq %rbx, %rdi
callq 0xf38e
leaq 0x8(%rsp), %rdi
callq 0x14342
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/./dglib/stdprinting.hh
// Function: std::ostream& operator<<<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>>(std::ostream&, std::vector<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>, std::allocator<std::vector<digraph<char, int>, std::allocator<digraph<char, int>>>>> 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6276(%rip), %rsi      # 0x15081
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2080
leaq 0x8101(%rip), %rsi      # 0x16f22
movq %rbx, %rdi
callq 0x2140
movq (%r15), %r14
movq 0x8(%r15), %r13
leaq 0x10(%rsp), %r15
leaq 0x61ee(%rip), %r12      # 0x1502a
cmpq %r13, %r14
je 0xee68
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
movq %rax, %rdi
movq %r14, %rsi
callq 0xeeac
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
addq $0x18, %r14
jmp 0xee3c
leaq 0x73a8(%rip), %rsi      # 0x16217
movq %rbx, %rdi
callq 0x2140
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xee97
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/./dglib/digraphop.hh
// Function: digraph<char, int> subgraph<char, int>(digraph<char, int> const&, std::set<char, std::less<char>, std::allocator<char>> const&)
digraph<N, A> subgraph(const digraph<N, A>& G, const std::set<N>& S)
{
    digraph<N, A> R;     // the (R)esulting graph
    std::set<N>   W{S};  // nodes (W)aiting to be processed
    std::set<N>   P;     // nodes already (P)rocessed
    while (!W.empty()) {
        std::set<N> M;  // (M)ore nodes to process at next iteration
        for (auto n : W) {
            R.add(n);     // add n to the resulting graph
            P.insert(n);  // mark n as processed
            for (const auto& a : G.connections(n)) {
                R.add(n, a.first, a.second);       // add its adjacent nodes
                if (P.find(a.first) == P.end()) {  // is it new ?
                    M.insert(a.first);             // we will have to process it
                }
            }
        }
        W = M;
    }
    return R;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
callq 0xe2d6
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x52f6
leaq 0x80(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x18(%rsp), %r13
leaq 0x7(%rsp), %rbp
cmpq $0x0, 0x70(%rsp)
je 0xf560
andl $0x0, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
andq $0x0, 0x40(%rsp)
movq 0x60(%rsp), %r12
leaq 0x50(%rsp), %rax
cmpq %rax, %r12
je 0xf546
movsbl 0x20(%r12), %esi
movb %sil, 0x7(%rsp)
movq %rbx, %rdi
callq 0x112fa
leaq 0x78(%rsp), %rdi
movq %rbp, %rsi
callq 0x3770
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x10938
movq %rax, %r14
movq %r12, 0x10(%rsp)
movq 0x18(%rax), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xf534
leaq 0x20(%r15), %r12
leaq 0x24(%r15), %rcx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xe302
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x13428
leaq 0x80(%rsp), %rcx
cmpq %rcx, %rax
jne 0xf527
movq %r13, %rdi
movq %r12, %rsi
callq 0x3770
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xf4e7
movq 0x10(%rsp), %rdi
callq 0x2170
movq %rax, %r12
jmp 0xf49c
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x1347a
movq %r13, %rdi
callq 0x33c4
jmp 0xf46b
leaq 0x78(%rsp), %rdi
callq 0x33c4
leaq 0x48(%rsp), %rdi
callq 0x33c4
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf5b7
jmp 0xf596
jmp 0xf596
jmp 0xf596
jmp 0xf596
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x33c4
leaq 0x78(%rsp), %rdi
callq 0x33c4
leaq 0x48(%rsp), %rdi
callq 0x33c4
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2efc
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5a9c(%rip), %rsi      # 0x15081
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2080
leaq 0x7934(%rip), %rsi      # 0x16f2f
movq %rbx, %rdi
callq 0x2140
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x10(%rsp), %r15
leaq 0x5a13(%rip), %r13      # 0x1502a
cmpq %r14, %r12
je 0xf64d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
movsbl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x2190
movq %r15, %rdi
movq %r13, %rsi
callq 0x2230
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
jmp 0xf617
leaq 0x6bc3(%rip), %rsi      # 0x16217
movq %rbx, %rdi
callq 0x2140
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xf67c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xe2d6
movq %r14, (%rsp)
movq (%r14), %r14
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xf715
movsbl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x112fa
leaq 0x20(%r15), %r12
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x10938
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0xf708
leaq 0x20(%rbp), %rsi
leaq 0x24(%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0xe302
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xf6e3
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xf6b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf72b
jmp 0xf72b
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2efc
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r14
movq (%rdi), %rdi
movq %rsi, (%rsp)
movq (%rsi), %rsi
callq 0x136eb
testb %al, %al
je 0xf776
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rbx
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
sete %bpl
je 0xf765
leaq 0x20(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x10938
movq %rax, %r13
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x10938
movq %r13, %rdi
movq %rax, %rsi
callq 0x136f5
testb %al, %al
jne 0xf765
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xf781
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf691
movq %rbx, %rdi
callq 0xe2d6
movq (%r14), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x8(%rsp)
cmpq 0x10(%rsp), %r15
je 0xf8a5
leaq 0x20(%r15), %r12
cmpb $0x0, 0x4(%rsp)
jne 0xf826
movsbl (%r12), %esi
movq %rbx, %rdi
callq 0x112fa
movq %r14, %rdi
movq %r12, %rsi
callq 0x10938
cmpq $0x1, 0x28(%rax)
jne 0xf890
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x10938
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0xf890
leaq 0x20(%rbp), %r14
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %r14, %rsi
callq 0x10944
cmpq $0x1, 0x28(%rax)
jne 0xf883
leaq 0x24(%rbp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe302
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xf850
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
movq 0x8(%rsp), %r14
jmp 0xf803
leaq 0x20(%rsp), %rdi
callq 0x2efc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xf8d9
jmp 0xf8ca
jmp 0xf8ca
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2efc
leaq 0x20(%rsp), %rdi
callq 0x2efc
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, (%rsp)
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %rbx
movq 0x18(%rbx), %r12
addq $0x8, %rbx
leaq 0x8(%rsp), %r15
cmpq %rbx, %r12
je 0xfa30
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x10938
movq %rax, %r13
movq 0x18(%rax), %rbp
addq $0x8, %r13
cmpq %r13, %rbp
je 0xfa23
leaq 0x20(%rbp), %rsi
movq %r15, %rdi
callq 0x103b8
incl (%rax)
movq %rbp, %rdi
callq 0x2170
movq %rax, %rbp
jmp 0xfa03
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
jmp 0xf9e6
xorps %xmm0, %xmm0
movq (%rsp), %rax
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%r14), %rbx
movq 0x18(%rbx), %r14
addq $0x8, %rbx
leaq 0x8(%rsp), %r15
cmpq %rbx, %r14
je 0xfa81
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x103b8
cmpl $0x0, (%rax)
jne 0xfa74
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x137d6
movq %r14, %rdi
callq 0x2170
movq %rax, %r14
jmp 0xfa4f
leaq 0x8(%rsp), %rdi
callq 0x10120
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfaae
movq %rax, %r14
movq (%rsp), %rdi
callq 0x138f2
jmp 0xfab1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x10120
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq (%rsi), %r13
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r13, %r15
je 0xfb1b
leaq 0x20(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x10938
cmpq $0x0, 0x28(%rax)
jne 0xfb0e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x137d6
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
jmp 0xfae8
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x138f2
movq %r14, %rdi
callq 0x2220