LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Create_Keys(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void Create_Keys(int record_num, vector<string> &key_list) {
    for (int index = 0; index < record_num; index++) {
        char c_key[KEY_SIZE+1] = "kkkkkkkkkk";
        stringstream key_ss;
        key_ss << index;
        string key(key_ss.str());
        memcpy(c_key, key.c_str(), key.length());
        string key_last = c_key;
        key_list.push_back(key_last);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, 0x18(%rsp)
movl %edi, %ebp
xorl %r12d, %r12d
testl %edi, %edi
cmovlel %r12d, %ebp
leaq 0x60(%rsp), %r13
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x40(%rsp), %rbx
cmpl %r12d, %ebp
je 0x6dbe
movabsq $0x6b6b6b6b6b6b6b6b, %rax # imm = 0x6B6B6B6B6B6B6B6B
movq %rax, 0x8(%rsp)
movl $0x6b6b6b, 0xf(%rsp)    # imm = 0x6B6B6B
movq %r13, %rdi
callq 0x62e0
leaq 0x70(%rsp), %rdi
movl %r12d, %esi
callq 0x66e0
movq %r14, %rdi
leaq 0x78(%rsp), %rsi
callq 0x6630
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r15, %rdi
callq 0x6390
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x7(%rsp), %rdx
callq 0x6150
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x87cc
movq %rbx, %rdi
callq 0x67f8
movq %r14, %rdi
callq 0x67f8
movq %r13, %rdi
callq 0x6350
incl %r12d
jmp 0x6d2d
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6dd2
movq %rax, %rbx
jmp 0x6df3
movq %rax, %rbx
jmp 0x6de9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x67f8
leaq 0x20(%rsp), %rdi
callq 0x67f8
leaq 0x60(%rsp), %rdi
callq 0x6350
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: fun_insert(void*)
void* fun_insert(void *arg) {
    thread_arg *t_args = (thread_arg*) arg;
    KVDS *db = t_args->db;
    int key_start = t_args->key_start;
    int key_end = t_args->key_end;
    vector<string> &key_list = *t_args->key_list;
    uint64_t *latency = t_args->latency;

    string *value = t_args->data;

    int value_size = VALUE_SIZE;
    int key_len = KEY_SIZE;
    Status s;

    for (int i = key_start; i < key_end + 1; i++) {
        string key = key_list[i];
        //string key = key_list[i-key_start];
        KVTime tv_start;
        s = db->Insert(key.c_str(), key_len, value->c_str(), value_size);
        KVTime tv_end;
        latency[i - key_start] = (uint64_t)(tv_end - tv_start);
        if (!s.ok()) {
            cout << "Insert key=" << key << "to DB failed!" << endl;
        }
    }
    return NULL;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movslq 0x8(%rdi), %r13
movslq 0xc(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rdi), %rbx
movq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rbp
shlq $0x5, %rbp
leaq 0x58(%rsp), %r15
leaq 0x28(%rsp), %r12
cmpq 0x20(%rsp), %r13
jg 0x6f1f
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq %rbp, %rsi
leaq 0x38(%rsp), %rdi
callq 0x6560
movq %r15, %rdi
callq 0x1f856
movq 0x38(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %r8
andl $0x0, (%rsp)
movq %r12, %rdi
movq 0x10(%rsp), %rsi
pushq $0xa
popq %rcx
movl $0x1000, %r9d           # imm = 0x1000
callq 0x13172
movl 0x28(%rsp), %r14d
movq %r12, %rdi
callq 0x1f856
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f8c2
movq %rax, (%rbx)
testl %r14d, %r14d
je 0x6ef5
movq 0x2d10b(%rip), %rdi     # 0x33fd0
leaq 0x192c0(%rip), %rsi     # 0x2018c
callq 0x6420
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x63d0
movq %rax, %rdi
leaq 0x192b0(%rip), %rsi     # 0x20198
callq 0x6420
movq %rax, %rdi
callq 0x61c0
movq %r12, %rdi
callq 0x1f8dc
movq %r15, %rdi
callq 0x1f8dc
leaq 0x38(%rsp), %rdi
callq 0x67f8
incq %r13
addq $0x20, %rbp
addq $0x8, %rbx
jmp 0x6e4f
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6f53
jmp 0x6f37
movq %rax, %rbx
jmp 0x6f49
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1f8dc
leaq 0x58(%rsp), %rdi
callq 0x1f8dc
leaq 0x38(%rsp), %rdi
callq 0x67f8
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Create_DB(benchmark_arg)
void Bench_Create_DB(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int db_size = bm_arg.db_size;
    int segment_K = bm_arg.segment_K;
    int shards_num = bm_arg.shards_num;
    int ds_type = bm_arg.ds_type;

    vector<string> key_list;
    if (Create_DB(file_path, db_size, segment_K, shards_num, ds_type) < 0) {
        cout << "Create DB Fail!!!" <<endl;
        return;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6560
movl 0x20(%r15), %ebx
movl 0x2c(%r15), %ebp
movl 0x30(%r15), %r14d
movl 0x34(%r15), %r15d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x6560
leaq 0x20(%rsp), %rdi
movl %ebx, %esi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
callq 0x6aa9
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x67f8
testl %ebx, %ebx
jns 0x7f96
movq 0x2c04e(%rip), %rdi     # 0x33fd0
leaq 0x184a1(%rip), %rsi     # 0x2042a
callq 0x6420
movq %rax, %rdi
callq 0x61c0
movq %rsp, %rdi
callq 0x8958
leaq 0x40(%rsp), %rdi
callq 0x67f8
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x67f8
jmp 0x7fc7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8958
leaq 0x40(%rsp), %rdi
callq 0x67f8
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Write(benchmark_arg)
void Bench_Write(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;
    int aggregate = bm_arg.aggregate;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num, aggregate);

    Bench_Insert(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r15
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x6560
movl 0x24(%r15), %ebp
movl 0x28(%r15), %ebx
movl 0x30(%r15), %r14d
movl 0x38(%r15), %r15d
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl %ebp, %edi
callq 0x6cf8
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x6560
leaq 0x18(%rsp), %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x6be7
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x67f8
movq %rsp, %rdx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x6f65
testq %r14, %r14
je 0x806c
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rsp, %rdi
callq 0x8958
leaq 0x38(%rsp), %rdi
callq 0x67f8
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x67f8
jmp 0x809d
jmp 0x809a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8958
leaq 0x38(%rsp), %rdi
callq 0x67f8
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Read(benchmark_arg)
void Bench_Read(benchmark_arg bm_arg)
{
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num);
    db->ClearReadCache();
    Bench_Get_Seq(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x6560
movl 0x24(%r14), %ebp
movl 0x28(%r14), %ebx
movl 0x30(%r14), %r14d
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl %ebp, %edi
callq 0x6cf8
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6560
leaq 0x20(%rsp), %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x6be7
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x67f8
movq %r14, %rdi
callq 0x13584
movq %rsp, %rdx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %ecx
callq 0x7670
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rsp, %rdi
callq 0x8958
leaq 0x40(%rsp), %rdi
callq 0x67f8
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x67f8
jmp 0x8673
jmp 0x8670
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8958
leaq 0x40(%rsp), %rdi
callq 0x67f8
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: main
int main(int argc, char** argv) {

    benchmark_arg bm_arg;

    if(Parse_Option(argc, argv, bm_arg) < 0) {
        usage();
        return -1;
    }

    switch(bm_arg.bench_type) {
        case CREATE:
            Bench_Create_DB(bm_arg);
            break;
        case WRITE:
            Bench_Write(bm_arg);
            break;
        case OVERWRITE:
            Bench_Overwrite(bm_arg);
            break;
        case READ:
            Bench_Read(bm_arg);
            break;
        default:
            break;
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdx
callq 0x7b29
testl %eax, %eax
js 0x86f5
movl 0x44(%rsp), %eax
xorl %ebx, %ebx
cmpq $0x3, %rax
ja 0x875f
leaq 0x17993(%rip), %rcx     # 0x20060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc8(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x897a
movq %r14, %rdi
callq 0x7fe1
jmp 0x8757
callq 0x6a8c
pushq $-0x1
popq %rbx
jmp 0x875f
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x897a
movq %r14, %rdi
callq 0x85c0
jmp 0x8757
leaq 0x108(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x897a
movq %r14, %rdi
callq 0x7f0e
jmp 0x8757
leaq 0x88(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x897a
movq %r14, %rdi
callq 0x80b7
movq %r14, %rdi
callq 0x67f8
leaq 0x8(%rsp), %rdi
callq 0x67f8
movl %ebx, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x87a5
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
jmp 0x87a5
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
jmp 0x87a5
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x67f8
jmp 0x87af
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x67f8
movq %rbx, %rdi
callq 0x66f0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: LatMgr::GetStatistics(Lat_Stats&)
void GetStatistics(Lat_Stats &lat_stats) {
        sort(lat_vec.begin(), lat_vec.end());
        //for (vector<uint64_t>::iterator iter=lat_vec.begin(); iter!= lat_vec.end(); ++iter)
        //{
        //    cout << "sorted latency is: " << *iter << endl;
        //}
        int len = lat_vec.size();
        int med_idx = len / 2;
        int P_50_idx = (int) (len * 0.5) - 1;
        int P_75_idx = (int) (len * 0.75) - 1;
        int P_99_idx = (int) (len * 0.99) - 1;
        int P_999_idx = (int) (len * 0.999) - 1;
        int P_9999_idx = (int) (len * 0.9999) - 1;

        lat_stats.med    = lat_vec[med_idx];
        lat_stats.P_50   = lat_vec[P_50_idx];
        lat_stats.P_75   = lat_vec[P_75_idx];
        lat_stats.P_99   = lat_vec[P_99_idx];
        lat_stats.P_999  = lat_vec[P_999_idx];
        lat_stats.P_9999 = lat_vec[P_9999_idx];
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0x8b05
movq (%r14), %rsi
movq 0x8(%r14), %rcx
subq %rsi, %rcx
shrq $0x3, %rcx
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
cvtsi2sd %ecx, %xmm0
movsd 0x177b6(%rip), %xmm1    # 0x20018
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %ecx
cltq
movq (%rsi,%rax,8), %rax
movq %rax, (%rbx)
movslq %ecx, %rax
movq -0x8(%rsi,%rax,8), %rax
movq %rax, 0x8(%rbx)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd 0x177b5(%rip), %xmm1    # 0x20040
mulpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
movd %xmm1, %eax
cltq
movq -0x8(%rsi,%rax,8), %rax
movq %rax, 0x10(%rbx)
pshufd $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movd %xmm1, %eax
cltq
movq -0x8(%rsi,%rax,8), %rax
mulpd 0x17796(%rip), %xmm0    # 0x20050
movq %rax, 0x18(%rbx)
cvttpd2dq %xmm0, %xmm0
movd %xmm0, %eax
cltq
movq -0x8(%rsi,%rax,8), %rax
movq %rax, 0x20(%rbx)
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %eax
cltq
movq -0x8(%rsi,%rax,8), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xd8, %rsp
leaq 0x8(%rsp), %rdi
callq 0x25fa
movb $0x41, 0x5(%rsp)
movb $0x42, 0x4(%rsp)
leaq 0x1c(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x12c18(%rip), %rsi     # 0x15004
leaq 0x50(%rsp), %rdi
callq 0x2626
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x12bfc(%rip), %rsi     # 0x15006
callq 0x2626
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
callq 0x2648
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2c30
leaq 0xa0(%rsp), %rcx
andl $0x0, 0x30(%rcx)
movq 0x8(%rsp), %rdi
leaq 0x5(%rsp), %rsi
leaq 0x4(%rsp), %rdx
callq 0x340c
leaq 0xa0(%rsp), %rdi
callq 0x2ee8
leaq 0x20(%rsp), %rdi
callq 0x2ee8
pushq $0x28
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0x50, %rdi
callq 0x20a0
addq $-0x28, %rbx
cmpq $-0x28, %rbx
jne 0x2477
movq 0x20b3b(%rip), %rdi     # 0x22fd0
leaq 0x13e61(%rip), %rsi     # 0x162fd
callq 0x2140
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2690
movq %rax, %rdi
callq 0x20b0
movq 0x20b13(%rip), %rdi     # 0x22fd0
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x27ff
leaq 0x10(%rsp), %rdi
callq 0x2efc
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x2ee8
jmp 0x24f3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2ee8
jmp 0x2502
movq %rax, %rbx
pushq $0x28
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x50, %rdi
callq 0x20a0
addq $-0x28, %r14
cmpq $-0x28, %r14
jne 0x2506
jmp 0x2533
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20a0
jmp 0x2533
jmp 0x2530
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20a80(%rip), %rdi     # 0x22fd0
leaq 0x12ab1(%rip), %rsi     # 0x15008
callq 0x2140
callq 0x6171
movl %eax, %ebx
callq 0x6b3a
movl %eax, %ebp
andb %bl, %bpl
callq 0x7581
movl %eax, %ebx
callq 0x7b75
movl %eax, %r14d
andb %bl, %r14b
andb %bpl, %r14b
callq 0x819d
movl %eax, %ebx
callq 0x89cc
movl %eax, %ebp
andb %bl, %bpl
callq 0xab40
movl %eax, %ebx
andb %bpl, %bl
andb %r14b, %bl
callq 0xb73a
movl %eax, %ebp
callq 0xbb39
movl %eax, %r14d
andb %bpl, %r14b
callq 0xc5bd
movl %eax, %ebp
andb %r14b, %bpl
callq 0xca2d
movl %eax, %r14d
andb %bpl, %r14b
andb %bl, %r14b
callq 0xcbac
movl %eax, %ebx
callq 0xd056
movl %eax, %ebp
andb %bl, %bpl
callq 0xd397
movl %eax, %ebx
andb %bpl, %bl
callq 0xd83d
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10c13(%rip), %rsi     # 0x15081
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2080
leaq 0x10bbc(%rip), %rsi     # 0x15040
movq %rbx, %rdi
callq 0x2140
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x10(%rsp), %r15
leaq 0x10b8a(%rip), %r13     # 0x1502a
cmpq %r14, %r12
je 0x44d5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2120
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x4519
movq %r15, %rdi
movq %r13, %rsi
callq 0x2230
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
jmp 0x44a0
leaq 0x11d3b(%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 0x4504
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/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, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0x10af9(%rip), %rsi     # 0x15081
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2080
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %r13
leaq 0x10ad2(%rip), %rbp     # 0x15082
leaq 0x12498(%rip), %rbx     # 0x16a4f
cmpq %r14, %r12
je 0x4604
movq %r15, %rdi
movq %r13, %rsi
callq 0x2120
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2140
movl 0x40(%r12), %esi
movq %rax, %rdi
callq 0x2210
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2230
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
jmp 0x45b7
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4646
movq %rax, %rbx
jmp 0x4653
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x30(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x43ee
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x553e
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b54
movq %rax, %r14
leaq 0x8(%rsp), %r15
cmpq %r15, %rax
je 0x5510
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x374e
cmpq %r15, %r14
setne %bl
movq %rsp, %rdi
callq 0x3364
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3364
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
callq 0x2030
movl %eax, %ebx
movq 0x1d782(%rip), %rdi     # 0x22fd0
movq %r12, %rsi
callq 0x2120
testl %ebx, %ebx
je 0x58ce
leaq 0xf972(%rip), %rsi      # 0x151d3
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x1d758(%rip), %r12     # 0x22fd0
leaq 0xf95d(%rip), %rsi      # 0x151dc
movq %r12, %rdi
callq 0x2140
movq %rax, %rdi
movq %r15, %rsi
callq 0x2120
leaq 0xf951(%rip), %r15      # 0x151ea
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq 0xf93a(%rip), %rsi      # 0x151ed
movq %r12, %rdi
callq 0x2140
movq %rax, %rdi
movq %r14, %rsi
callq 0x2120
movq %rax, %rdi
movq %r15, %rsi
jmp 0x58d8
leaq 0xf8f4(%rip), %rsi      # 0x151c9
movq %rax, %rdi
callq 0x2140
testl %ebx, %ebx
sete %bl
movq %rax, %rdi
callq 0x20b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe2d6
leaq 0x33(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0x32(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x64(%rsp), %rcx
andl $0x0, (%rcx)
movq (%r14), %rdi
callq 0x102c4
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 0x102c4
leaq 0x2f(%rsp), %rsi
movb $0x43, (%rsi)
leaq 0x2e(%rsp), %rdx
movb $0x41, (%rdx)
leaq 0x5c(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x2d(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x2c(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0x58(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x2b(%rsp), %rsi
movb $0x44, (%rsi)
leaq 0x2a(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0x54(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
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 0x102c4
leaq 0x27(%rsp), %rsi
movb $0x45, (%rsi)
leaq 0x26(%rsp), %rdx
movb $0x44, (%rdx)
leaq 0x4c(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x25(%rsp), %rsi
movb $0x45, (%rsi)
leaq 0x24(%rsp), %rdx
movb $0x46, (%rdx)
leaq 0x48(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x23(%rsp), %rsi
movb $0x46, (%rsi)
leaq 0x22(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x44(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
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 0x102c4
leaq 0x1f(%rsp), %rsi
movb $0x48, (%rsi)
leaq 0x1e(%rsp), %rdx
movb $0x47, (%rdx)
leaq 0x3c(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
leaq 0x1d(%rsp), %rsi
movb $0x48, (%rsi)
leaq 0x1c(%rsp), %rdx
movb $0x45, (%rdx)
leaq 0x38(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x8(%rsp), %rdi
callq 0x102c4
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 0x102c4
leaq 0xbc9b(%rip), %rsi      # 0x162fd
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x10(%rsp), %rdi
callq 0x2efc
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
jmp 0xa6a3
movq %rax, %rbx
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: check0()
bool check0()
{
    std::stringstream ss;
    test0(ss);
    bool ok = (0 == ss.str().compare(res0()));
    if (ok) {
        std::cout << "test0 OK " << std::endl;
    } else {
        std::cout << "test0 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res0() << 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 0xa480
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xa6b8
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 0xa7e1
movq 0x18886(%rip), %rdi     # 0x22fd0
leaq 0xb7e0(%rip), %rsi      # 0x15f31
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x1886b(%rip), %rdi     # 0x22fd0
leaq 0xb7d1(%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 0x18829(%rip), %rdi     # 0x22fd0
leaq 0xb79b(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xa6b8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xa7fc
movq 0x187e8(%rip), %rdi     # 0x22fd0
leaq 0xb738(%rip), %rsi      # 0x15f27
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 0xa844
jmp 0xa844
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xa838
jmp 0xa835
jmp 0xa844
jmp 0xa844
jmp 0xa835
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xa847
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: check1()
bool check1()
{
    std::stringstream ss;
    test1(ss);
    bool ok = (0 == ss.str().compare(res1()));
    if (ok) {
        std::cout << "test1 OK " << std::endl;
    } else {
        std::cout << "test1 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res1() << 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 0xa859
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xab1e
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 0xac47
movq 0x18420(%rip), %rdi     # 0x22fd0
leaq 0xb3a8(%rip), %rsi      # 0x15f5f
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x18405(%rip), %rdi     # 0x22fd0
leaq 0xb36b(%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 0x183c3(%rip), %rdi     # 0x22fd0
leaq 0xb335(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xab1e
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xac62
movq 0x18382(%rip), %rdi     # 0x22fd0
leaq 0xb300(%rip), %rsi      # 0x15f55
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 0xacaa
jmp 0xacaa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xac9e
jmp 0xac9b
jmp 0xacaa
jmp 0xacaa
jmp 0xac9b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xacad
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: check2()
bool check2()
{
    std::stringstream ss;
    test2(ss);
    bool ok = (0 == ss.str().compare(res2()));
    if (ok) {
        std::cout << "test2 OK " << std::endl;
    } else {
        std::cout << "test2 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res2() << 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 0xacbf
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xaf24
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 0xb04d
movq 0x1801a(%rip), %rdi     # 0x22fd0
leaq 0xb0ce(%rip), %rsi      # 0x1608b
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x17fff(%rip), %rdi     # 0x22fd0
leaq 0xaf65(%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 0x17fbd(%rip), %rdi     # 0x22fd0
leaq 0xaf2f(%rip), %rsi      # 0x15f49
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xaf24
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb068
movq 0x17f7c(%rip), %rdi     # 0x22fd0
leaq 0xb026(%rip), %rsi      # 0x16081
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 0xb0b0
jmp 0xb0b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xb0a4
jmp 0xb0a1
jmp 0xb0b0
jmp 0xb0b0
jmp 0xb0a1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb0b3
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: check3()
bool check3()
{
    std::stringstream ss;
    test3(ss);
    bool ok = (0 == ss.str().compare(res3()));
    if (ok) {
        std::cout << "test3 OK " << std::endl;
    } else {
        std::cout << "test3 FAIL " << std::endl;
        std::cout << "We got     \"" << ss.str() << '"' << std::endl;
        std::cout << "instead of \"" << res3() << '"' << 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 0xb0c5
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xb3c8
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 0xb507
movq 0x17b76(%rip), %rdi     # 0x22fd0
leaq 0xad24(%rip), %rsi      # 0x16185
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x17b5b(%rip), %rdi     # 0x22fd0
leaq 0xad15(%rip), %rsi      # 0x16191
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x17b0e(%rip), %rdi     # 0x22fd0
leaq 0xacd5(%rip), %rsi      # 0x1619e
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb3c8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb522
movq 0x17ac2(%rip), %rdi     # 0x22fd0
leaq 0xac66(%rip), %rsi      # 0x1617b
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 0xb56a
jmp 0xb56a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xb55e
jmp 0xb55b
jmp 0xb56a
jmp 0xb56a
jmp 0xb55b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb56d
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: 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 0xe2d6
leaq 0x10(%rsp), %rdi
callq 0xe2d6
leaq 0x30(%rsp), %rdi
callq 0xe2d6
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 0x102c4
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 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x20(%rsp), %rdi
callq 0x102c4
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 0x102c4
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 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xe97e
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xe97e
leaq 0xab0b(%rip), %rsi      # 0x161ab
movq %rbx, %rdi
callq 0x2140
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x38(%rsp), %rdi
callq 0x2efc
leaq 0x18(%rsp), %rdi
callq 0x2efc
leaq 0x28(%rsp), %rdi
callq 0x2efc
addq $0x40, %rsp
popq %rbx
retq
jmp 0xb6ef
jmp 0xb6ef
jmp 0xb6ef
jmp 0xb6ef
jmp 0xb6ef
jmp 0xb6ef
movq %rax, %rbx
jmp 0xb6fc
movq %rax, %rbx
jmp 0xb706
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2efc
leaq 0x18(%rsp), %rdi
callq 0x2efc
leaq 0x28(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check4()
bool check4()
{
    std::stringstream ss;
    test4(ss);
    bool ok = (0 == ss.str().compare(res4()));
    if (ok) {
        std::cout << "test4 OK " << std::endl;
    } else {
        std::cout << "test4 FAIL " << std::endl;
        std::cout << "We got     \"" << ss.str() << '"' << std::endl;
        std::cout << "instead of \"" << res4() << '"' << 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 0xb57f
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xb718
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 0xb857
movq 0x17826(%rip), %rdi     # 0x22fd0
leaq 0xaa72(%rip), %rsi      # 0x16223
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x1780b(%rip), %rdi     # 0x22fd0
leaq 0xa9c5(%rip), %rsi      # 0x16191
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x177be(%rip), %rdi     # 0x22fd0
leaq 0xa985(%rip), %rsi      # 0x1619e
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb718
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb872
movq 0x17772(%rip), %rdi     # 0x22fd0
leaq 0xa9b4(%rip), %rsi      # 0x16219
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 0xb8ba
jmp 0xb8ba
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xb8ae
jmp 0xb8ab
jmp 0xb8ba
jmp 0xb8ba
jmp 0xb8ab
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xb8bd
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: test5(std::ostream&)
void test5(std::ostream& ss)
{
    digraph<char, int> g1, g2, g3;

    g1.add('A', 'Z', 0);
    g1.add('A', 'B', 0);
    g1.add('B', 'C', 0);
    g1.add('C', 'A', 1);

    g1.add('Z', 'W', 0);
    g1.add('W', 'Z', 1);

    g1.add('A', 'Z', 0);
    g1.add('W', 'C', 1);

    splitgraph<char>(
        g1, [](const char& c) { return c < 'K'; }, g2, g3);

    ss << "test5: g1 = " << g1 << "; g2 = " << g2 << "; g3 = " << g3;
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe2d6
leaq 0x30(%rsp), %rdi
callq 0xe2d6
leaq 0x20(%rsp), %rdi
callq 0xe2d6
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x5a, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x42, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x42, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x43, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x41, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x5a, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x57, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x57, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x5a, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x41, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x5a, (%rdx)
leaq 0xc(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
leaq 0xb(%rsp), %rsi
movb $0x57, (%rsi)
leaq 0xa(%rsp), %rdx
movb $0x43, (%rdx)
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x102c4
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x2896(%rip), %rax      # 0xe2b6
movq %rax, 0x18(%rsi)
leaq 0x2893(%rip), %rax      # 0xe2be
movq %rax, 0x10(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0xea0c
leaq 0x40(%rsp), %rdi
callq 0x14342
leaq 0xa7db(%rip), %rsi      # 0x1622f
movq %rbx, %rdi
callq 0x2140
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0xa7cc(%rip), %rsi      # 0x1623c
movq %rax, %rdi
callq 0x2140
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0xa7b8(%rip), %rsi      # 0x16244
movq %rax, %rdi
callq 0x2140
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xe313
leaq 0x28(%rsp), %rdi
callq 0x2efc
leaq 0x38(%rsp), %rdi
callq 0x2efc
leaq 0x18(%rsp), %rdi
callq 0x2efc
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x14342
jmp 0xbaf1
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
jmp 0xbaee
movq %rax, %rbx
jmp 0xbafb
movq %rax, %rbx
jmp 0xbb05
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2efc
leaq 0x38(%rsp), %rdi
callq 0x2efc
leaq 0x18(%rsp), %rdi
callq 0x2efc
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/grame-cncm[P]digraph/tests.cpp
// Function: check5()
bool check5()
{
    std::stringstream ss;
    test5(ss);
    bool ok = (0 == ss.str().compare(res5()));
    if (ok) {
        std::cout << "test5 OK " << std::endl;
    } else {
        std::cout << "test5 FAIL " << std::endl;
        std::cout << "We got     \"" << ss.str() << '"' << std::endl;
        std::cout << "instead of \"" << res5() << '"' << 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 0xb8cf
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xbb17
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 0xbc56
movq 0x17427(%rip), %rdi     # 0x22fd0
leaq 0xa733(%rip), %rsi      # 0x162e3
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x1740c(%rip), %rdi     # 0x22fd0
leaq 0xa5c6(%rip), %rsi      # 0x16191
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x173bf(%rip), %rdi     # 0x22fd0
leaq 0xa586(%rip), %rsi      # 0x1619e
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xbb17
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xbc71
movq 0x17373(%rip), %rdi     # 0x22fd0
leaq 0xa675(%rip), %rsi      # 0x162d9
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 0xbcb9
jmp 0xbcb9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xbcad
jmp 0xbcaa
jmp 0xbcb9
jmp 0xbcb9
jmp 0xbcaa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xbcbc
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: check7()
bool check7()
{
    std::stringstream ss;
    test7(ss);
    bool ok = (0 == ss.str().compare(res7()));
    if (ok) {
        std::cout << "test7 OK " << std::endl;
    } else {
        std::cout << "test7 FAIL " << std::endl;
        std::cout << "We got     \"" << ss.str() << '"' << std::endl;
        std::cout << "instead of \"" << res7() << '"' << 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 0xbcce
leaq 0x60(%rsp), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x28(%rsp), %rdi
callq 0xc113
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 0xc252
movq 0x16e2b(%rip), %rdi     # 0x22fd0
leaq 0xa68d(%rip), %rsi      # 0x16839
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x16e10(%rip), %rdi     # 0x22fd0
leaq 0x9fca(%rip), %rsi      # 0x16191
callq 0x2140
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x16dc3(%rip), %rdi     # 0x22fd0
leaq 0x9f8a(%rip), %rsi      # 0x1619e
callq 0x2140
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc113
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2120
pushq $0x22
popq %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xc26d
movq 0x16d77(%rip), %rdi     # 0x22fd0
leaq 0xa5cf(%rip), %rsi      # 0x1682f
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 0xc2b5
jmp 0xc2b5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
jmp 0xc2a9
jmp 0xc2a6
jmp 0xc2b5
jmp 0xc2b5
jmp 0xc2a6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20a0
jmp 0xc2b8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2220