LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::read_graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void graph_t::read_graph(string path)
{
    ifstream fin;
    fin.open(path.c_str(), ios::in);
    if(!fin.good()) {
        printf("Can't open the file [%s]\n", path.c_str());
        exit(1);
    }
    size_t N, M;
    fin >> N >> M;
    init_size(N);
    for(int i = 0; i < M; ++i) {
        node_id_t src, dst;
        fin >> src >> dst;
        //TODO could this cause issues?
        if(src < N && dst < N) {
            insert_edge(src, dst);
        }
    }
    fin.close();
    i_init_internals();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2280
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x2150
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x38(%rsp,%rax)
jne 0x18e37
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2100
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2100
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x18cca
xorl %r13d, %r13d
leaq 0x18(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
cmpq %r13, 0x10(%rsp)
jbe 0x18e0a
movq %r14, %rdi
movq %r15, %rsi
callq 0x23c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x23c0
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rax
cmpq %rsi, %rax
jbe 0x18e05
movl (%rsp), %edx
cmpq %rdx, %rax
jbe 0x18e05
movq %rbx, %rdi
callq 0x18b56
incq %r13
jmp 0x18dca
leaq 0x18(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x18d0e
leaq 0x18(%rsp), %rdi
callq 0x2060
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rsi
leaq 0xfd4e(%rip), %rdi      # 0x28b8f
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rdi
callq 0x22c0
jmp 0x18e54
jmp 0x18e54
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::print_mcbs()
void graph_t::print_mcbs()
{
    for(int c = 0; c < mcb.cycle_vec.size(); ++c) {
        printf("Cycle [%d]:\n", c);
        for(int e = 0; e < mcb.cycle_vec[c].size(); ++e) {
            printf("    [%d]===[%d]\n", mcb.cycle_vec[c][e].first, mcb.cycle_vec[c][e].second);
        }        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
pushq $0x18
popq %r13
leaq 0xfced(%rip), %r15      # 0x28bb6
xorl %r12d, %r12d
movq 0x80(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x18f2e
leaq 0xfcc2(%rip), %rdi      # 0x28ba9
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
imulq $0x18, %r12, %rbp
xorl %r14d, %r14d
movq 0x78(%rbx), %rcx
movq (%rcx,%rbp), %rax
movq 0x8(%rcx,%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x18f29
movl (%rax,%r14,8), %esi
movl 0x4(%rax,%r14,8), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %r14
jmp 0x18ef8
incq %r12
jmp 0x18ecc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::has_edge(std::pair<unsigned int, unsigned int> const&)
bool graph_t::has_edge(const edge_t& e)
{
    edge_t e1 = e;
    edge_t e2; e2.first = e1.second; e2.second = e1.first;
    return (edge_set.find(e1) != edge_set.end() ||
            edge_set.find(e2) != edge_set.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rsi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
rorq $0x20, %rax
movq %rax, (%rsp)
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x184c8
movq %rax, %r14
addq $0x38, %r15
movb $0x1, %al
cmpq %r15, %r14
jne 0x191fe
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x184c8
cmpq %r14, %rax
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::find_sssp(unsigned int, std::vector<int, std::allocator<int>>&)
void graph_t::find_sssp(node_id_t s, vector<int>& out_vec)
{
    queue<node_id_t> Q;
    Q.push(s);
    out_vec[s] = 0;
    while(!Q.empty()) {
        node_id_t v = Q.front(); Q.pop();
        vector<node_id_t> nbr_vec = get_nbrs(v);
        for(int i = 0; i < nbr_vec.size(); ++i) {
            node_id_t nbr = nbr_vec[i];
            if(out_vec[nbr] == -1) {
                out_vec[nbr] = out_vec[v] + 1;
                Q.push(nbr);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4a40
movq %r12, %rdi
movq %r15, %rsi
callq 0x62da
movl 0x4(%rsp), %eax
movq (%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movq 0x38(%rsp), %rax
cmpq %rax, 0x58(%rsp)
je 0x192cb
movl (%rax), %ebp
movq %r15, %rdi
callq 0x650e
imulq $0x18, %rbp, %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r12, %rdi
callq 0x4ba0
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x192c1
movl (%rax,%r14,4), %eax
movl %eax, (%rsp)
movq (%rbx), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x192bc
movl (%rcx,%rbp,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movq %r15, %rdi
movq %r13, %rsi
callq 0x62da
incq %r14
jmp 0x19283
movq %r12, %rdi
callq 0x56ec
jmp 0x19256
leaq 0x28(%rsp), %rdi
callq 0x5280
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x192e6
movq %rax, %rbx
jmp 0x192f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56ec
leaq 0x28(%rsp), %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::insert_edge_update_bc_experimental(unsigned int, unsigned int, bcc_stat_t&, int, int)
void graph_t::insert_edge_update_bc_experimental(node_id_t src,
                          node_id_t dst,
                          bcc_stat_t& bcc_stat,
                          int max_iter_d1,
                          int max_iter_d2)
{
    /*
     * 1. edge must be in the graph so that bcc extraction works properly
     * 2. the subgraph in the bcc must not have the edge (done inside bcc_delta_t::compute_bc)
     */
    timer tm;//
    
    insert_edge(src, dst);    
    bcc_delta_t bcc;
    tm.start();//
    find_edge_bcc(bcc, src, dst);
    tm.stop();//
    bcc_stat.bcc_num_nodes = bcc.bcc_subgraph.nodes_map.size();
    bcc_stat.bcc_num_edges = bcc.bcc_subgraph.edge_set.size();
    bcc_stat.bcc_find_time = tm.interval();//
    tm.start();
    if(max_iter_d1 != -1 || max_iter_d2 != -1)
        bcc.compute_bc_maxiter_exp(bc_map, src, dst, bcc_stat, max_iter_d1, max_iter_d2);
    else
        bcc.compute_bc_exp(bc_map, src, dst, bcc_stat, max_iter_d1, max_iter_d2);
    tm.stop();//
    bcc_stat.bc_update_time = tm.interval();//
    
    bcc.bcc_subgraph.remove_edge(src, dst);
    bcc.bcc_subgraph.find_pruning_counts_exp(src, 
                        dst, bcc_stat.tot_d0_iter, 
                        bcc_stat.tot_d1_iter, 
                        bcc_stat.tot_d2_iter);
    bcc.bcc_subgraph.insert_edge(src, dst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
movl %r9d, %r13d
movl %r8d, 0x14(%rsp)
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
callq 0x18b56
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x19d1c
leaq 0x18(%rsp), %rdi
callq 0xb094
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xc424
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xb09c
movl 0x80(%rsp), %eax
movl %eax, (%r14)
movl 0xc0(%rsp), %eax
movl %eax, 0x4(%r14)
movq %r12, %rdi
callq 0xb0a8
movsd %xmm0, 0x38(%r14)
movq %r12, %rdi
callq 0xb094
movl %r13d, %eax
movl 0x14(%rsp), %r9d
andl %r9d, %eax
addq $0xd8, %r15
cmpl $-0x1, %eax
je 0x193c1
movl %r13d, (%rsp)
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0xce96
jmp 0x193dd
orl $-0x1, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %r9
movq %r15, %rsi
movl %ebp, %edx
movl %ebx, %ecx
movq %r14, %r8
callq 0xcbe6
leaq 0x68(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xb09c
movq %r12, %rdi
callq 0xb0a8
movsd %xmm0, 0x40(%r14)
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1762e
leaq 0x50(%r14), %rcx
leaq 0x54(%r14), %r8
addq $0x58, %r14
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r14, %r9
callq 0x17dec
movq %r15, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1756e
leaq 0x38(%rsp), %rdi
callq 0x19d82
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x19d82
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::approx_bcc_iter_tm(unsigned int, unsigned int, double&, int)
void graph_t::approx_bcc_iter_tm(node_id_t src,
                                 node_id_t dst,
                                 double& avg_iter_time,
                                 int num_iter)
{
    timer tm;
    
    bcc_scratch_t bcc;
    find_edge_bcc(bcc, src, dst);
    if(num_iter == -1) {
        num_iter = bcc.bcc_subgraph.size();
    }
    
    tr1_map_t(double) bc_map;
    bcc.bcc_subgraph.i_fill_map<double>(bc_map, 0);
    tm.start();
    bcc.compute_bc(bc_map, num_iter);
    tm.stop();
    
    avg_iter_time = tm.interval()/num_iter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp            # imm = 0x528
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
leaq 0x58(%rsp), %r13
movq %r13, %rdi
callq 0x19da4
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xfb24
cmpl $-0x1, %r14d
jne 0x194b4
leaq 0x88(%rsp), %rdi
callq 0x176f6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rsi
leaq 0x7(%rsp), %rdx
leaq 0x6(%rsp), %rcx
leaq 0x5(%rsp), %r8
callq 0xb770
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorpd %xmm0, %xmm0
callq 0x18120
leaq 0x38(%rsp), %rdi
callq 0xb094
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %r14d, %edx
callq 0x1010e
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0xb09c
movq %r15, %rdi
callq 0xb0a8
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0xb070
leaq 0x58(%rsp), %rdi
callq 0x19e0a
addq $0x528, %rsp            # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1954c
movq %rax, %rbx
jmp 0x1955e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb070
leaq 0x58(%rsp), %rdi
callq 0x19e0a
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::init_bc()
void graph_t::init_bc()
{
    if(!bc_computed) {
        bc_vec = brandes_bc(*this);
        for(int i = 0; i < bc_vec.size(); ++i) {
            bc_map.insert(make_pair(i, bc_vec[i]));
        }
        bc_computed = true;
    }    
}

// Assembly:
cmpb $0x0, 0xb8(%rdi)
jne 0x19618
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8fa3
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1a0a8
movq %r14, %rdi
callq 0x5754
leaq 0xd8(%rbx), %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq 0xc0(%rbx), %rax
movq 0xc8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x19604
movsd (%rax,%r13,8), %xmm0
movl %r13d, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb838
incq %r13
jmp 0x195c6
movb $0x1, 0xb8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/iter_info_t.cc
// Function: iter_info_t::init_all(unsigned long)
void iter_info_t::init_all(size_t N)
{
    fill_vec<vector<node_id_t> >(P, N, vector<node_id_t>());
    fill_vec<int>(sigma_vec, N, 0);
    fill_vec<int>(dist_vec, N, -1);
    fill_vec<int>(sigma_inc_vec, N, 0);
    
    fill_vec<double>(delta_vec, N, 0);
    fill_vec<double>(Delta_vec, N, 0);

    fill_vec<bool>(visited_vec, N, false);
    S.clear();
    
//    fill_vec<int>(new_sigma_vec, N, 0);
//    fill_vec<double>(new_delta_vec, N, 0);
//    fill_vec<double>(new_Delta_vec, N, 0);
    
//    fill_vec<vector<node_id_t> >(old_P, N, vector<node_id_t>());
//    fill_vec<int>(old_sigma_vec, N, 0);
//    fill_vec<int>(old_dist_vec, N, -1);
//    fill_vec<double>(old_delta_vec, N, 0);
//    fill_vec<double>(old_Delta_vec, N, 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0x7506
movq %rsp, %rdi
callq 0x56ec
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a1f7
leaq 0x30(%rbx), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
callq 0x1a1f7
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a1f7
leaq 0x48(%rbx), %rdi
xorps %xmm0, %xmm0
movq %r14, %rsi
callq 0x4756
leaq 0x60(%rbx), %rdi
xorps %xmm0, %xmm0
movq %r14, %rsi
callq 0x4756
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x76b2
movq 0x100(%rbx), %rax
cmpq %rax, 0x108(%rbx)
je 0x1a198
movq %rax, 0x108(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56ec
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/unit_tests.h
// Function: fill_test_graph(graph_t&)
void fill_test_graph(graph_t& graph)
{
    graph.init_size(20);
    graph.insert_edge(0,1);
    graph.insert_edge(1,2);
    graph.insert_edge(2,3);
    graph.insert_edge(3,0);
    graph.insert_edge(0,4);
    graph.insert_edge(4,5);
    graph.insert_edge(5,6);
    graph.insert_edge(6,7);
    graph.insert_edge(7,8);
    graph.insert_edge(8,4);
    graph.insert_edge(5,9);
    graph.insert_edge(9,8);
    graph.insert_edge(3,10);
    graph.insert_edge(10,11);
    graph.insert_edge(11,12);
    graph.insert_edge(12,13);
    graph.insert_edge(13,14);
    graph.insert_edge(14,15);
    graph.insert_edge(15,10);
    graph.insert_edge(2,16);
    graph.insert_edge(16,17);
    graph.insert_edge(17,18);
    graph.insert_edge(2,19);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x14
popq %rsi
callq 0x18cca
pushq $0x1
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x18b56
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x18b56
pushq $0x3
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x18b56
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x18b56
pushq $0x4
popq %r15
movq %rbx, %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x18b56
pushq $0x5
popq %r12
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x18b56
pushq $0x6
popq %r13
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x18b56
pushq $0x7
popq %rbp
movq %rbx, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x18b56
pushq $0x8
popq %r13
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x18b56
movq %rbx, %rdi
movl %r13d, %esi
movl %r15d, %edx
callq 0x18b56
pushq $0x9
popq %rbp
movq %rbx, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x18b56
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x18b56
pushq $0xa
popq %r15
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x18b56
pushq $0xb
popq %rbp
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x18b56
pushq $0xc
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x18b56
pushq $0xd
popq %rbp
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x18b56
pushq $0xe
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x18b56
pushq $0xf
popq %rbp
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x18b56
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x18b56
pushq $0x10
popq %rbp
movq %rbx, %rdi
pushq $0x2
popq %r15
movl %r15d, %esi
movl %ebp, %edx
callq 0x18b56
pushq $0x11
popq %r14
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x18b56
pushq $0x12
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x18b56
pushq $0x13
popq %rdx
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18b56
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/unit_tests.h
// Function: test__fast_brandes_BC()
bool test__fast_brandes_BC()
{
    bool passed = false;
    printf("Testing [brandes_BC] ...\t");
    graph_t g;
    g.read_graph(string("Erdos02.lcc.net"));
    //fill_test_graph(g);
    vector<double> BC_vec;
    fast_brandes_BC(g, BC_vec);
    vector<double> ref_BC_vec = brandes_bc(g);
    passed = true;
    for(node_id_t v = 0; v < BC_vec.size(); ++v) {
        if((BC_vec[v] - ref_BC_vec[v]) > EPS) {
            passed = false;
        }
        //printf("[%f]\t\t[%f]\n", BC_vec[v], ref_BC_vec[v]);
    }
    if(passed) {
        printf("PASSED\n");
    } else {
        printf("FAILED\n");
    }
    
    return passed;
}

// Assembly:
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
leaq 0xe857(%rip), %rdi      # 0x28c20
xorl %eax, %eax
callq 0x2030
leaq 0x58(%rsp), %rdi
callq 0x1d14e
leaq 0xe859(%rip), %rsi      # 0x28c3a
leaq 0x38(%rsp), %rdi
movq %rsp, %rdx
callq 0x1d278
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x18d4c
leaq 0x38(%rsp), %rdi
callq 0x20d0
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x58(%rsp), %rdi
callq 0x272c
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
pushq $-0x1
popq %rdx
callq 0x8fa3
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %esi, %esi
movb $0x1, %bl
movq 0x20(%rsp), %rdx
movsd 0xe7ae(%rip), %xmm0     # 0x28c00
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x1a472
movsd (%rax,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
setbe %dil
andb %dil, %bl
incl %esi
jmp 0x1a452
leaq 0xea21(%rip), %rax      # 0x28e9a
leaq 0xea13(%rip), %rdi      # 0x28e93
andb $0x1, %bl
cmovneq %rax, %rdi
callq 0x2360
leaq 0x20(%rsp), %rdi
callq 0x5754
movq %rsp, %rdi
callq 0x5754
leaq 0x58(%rsp), %rdi
callq 0x1d2b4
movl %ebx, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
retq
jmp 0x1a4b5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5754
jmp 0x1a4d4
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20d0
jmp 0x1a4d4
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1d2b4
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/unit_tests.h
// Function: test__Update_BC()
bool test__Update_BC()
{
    bool passed = false;
    printf("Testing [Update_BC] ...\t");
    vector<double> BC_vec;
    graph_t g;
    edge_t e = make_pair(100, 3455);
    
    g.read_graph(string("Erdos02.lcc.net"));
    //fill_test_graph(g);
    
    e = *g.edge_set.begin();
    g.remove_edge(e.first, e.second);
    //printf("(%d, %d)\n", e.first, e.second);
       
    fast_brandes_BC(g, BC_vec);
    Update_BC(BC_vec, g, BCC, e);
    
    g.insert_edge(e.first, e.second);
    vector<double> ref_BC_vec = brandes_bc(g);
    passed = true;
    for(node_id_t v = 0; v < BC_vec.size(); ++v) {
        if(abs((BC_vec[v] - ref_BC_vec[v])) > EPS) {
            passed = false;
            printf("(%d) --\t[%f]\t\t[%f]\n", v, BC_vec[v], ref_BC_vec[v]);
        }
        //printf("(%d) --\t[%f]\t\t[%f]\n", v, BC_vec[v], ref_BC_vec[v]);
    }
    if(passed) {
        printf("PASSED\n");
    } else {
        printf("FAILED\n");
    }
    return passed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
leaq 0xe55c(%rip), %rdi      # 0x28c62
xorl %eax, %eax
callq 0x2030
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1d14e
leaq 0xe50d(%rip), %rsi      # 0x28c3a
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d278
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x18d4c
leaq 0x38(%rsp), %rdi
callq 0x20d0
leaq 0x58(%rsp), %rdi
movq 0x48(%rdi), %rax
movl 0x20(%rax), %ebx
movl 0x24(%rax), %r14d
movl %ebx, %esi
movl %r14d, %edx
callq 0x18bfe
leaq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0x272c
movq %r14, %rcx
shlq $0x20, %rcx
orq %rbx, %rcx
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
pushq $0x1
popq %r8
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x2888
leaq 0x58(%rsp), %rdi
movl %ebx, %esi
movl %r14d, %edx
callq 0x18b56
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
pushq $-0x1
popq %rdx
callq 0x8fa3
xorl %r14d, %r14d
movb $0x1, %bl
movapd 0xe446(%rip), %xmm3     # 0x28c10
movsd 0xe42e(%rip), %xmm4     # 0x28c00
leaq 0xe4a2(%rip), %r15      # 0x28c7b
movl %r14d, %r14d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x1a838
movsd (%rax,%r14,8), %xmm0
movq 0x20(%rsp), %rax
movsd (%rax,%r14,8), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
andpd %xmm3, %xmm2
ucomisd %xmm4, %xmm2
jbe 0x1a833
movq %r15, %rdi
movl %r14d, %esi
movb $0x2, %al
callq 0x2030
movsd 0xe3d7(%rip), %xmm4     # 0x28c00
movapd 0xe3df(%rip), %xmm3     # 0x28c10
xorl %ebx, %ebx
incl %r14d
jmp 0x1a7d9
leaq 0xe65b(%rip), %rax      # 0x28e9a
leaq 0xe64d(%rip), %rdi      # 0x28e93
andb $0x1, %bl
cmovneq %rax, %rdi
callq 0x2360
leaq 0x20(%rsp), %rdi
callq 0x5754
leaq 0x58(%rsp), %rdi
callq 0x1d2b4
movq %rsp, %rdi
callq 0x5754
movl %ebx, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1a895
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20d0
jmp 0x1a898
jmp 0x1a895
movq %rax, %rbx
jmp 0x1a8a2
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1d2b4
movq %rsp, %rdi
callq 0x5754
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/main.cc
// Function: fill_path_vec[abi:cxx11]()
vector<string> fill_path_vec()
{
    vector<string> vec;
    string path_f  = "/home/jamourft/Desktop/Research/Betweenness-Centrality/data/fj_lcc_graphs/";
    string graphs_arr[] = 
        {   
          "Erdos02.lcc.net"
        , "Erdos972.lcc.net"
        , "Cagr.lcc.net"
        , "Eva.lcc.net"
        , "Epa.lcc.net"
        , "Contact.lcc.net"
        , "Wiki-Vote.lcc.net"
        };
    
    for(int i = 0; i < 7; ++i) {
        string s = path_f + graphs_arr[i];
        vec.push_back(s);
    }
    return vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xc649(%rip), %rsi      # 0x28d3b
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1d278
leaq 0xc532(%rip), %rsi      # 0x28c3a
leaq 0x50(%rsp), %r14
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
callq 0x1d278
leaq 0x70(%rsp), %r15
leaq 0xc660(%rip), %rsi      # 0x28d86
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
leaq 0x90(%rsp), %r15
leaq 0xc655(%rip), %rsi      # 0x28d97
leaq 0xe(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
leaq 0xb0(%rsp), %r15
leaq 0xc646(%rip), %rsi      # 0x28da4
leaq 0xd(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
leaq 0xd0(%rsp), %r15
leaq 0xc636(%rip), %rsi      # 0x28db0
leaq 0xc(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
leaq 0xf0(%rsp), %r15
leaq 0xc626(%rip), %rsi      # 0x28dbc
leaq 0xb(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
leaq 0x110(%rsp), %r15
leaq 0xc61a(%rip), %rsi      # 0x28dcc
leaq 0xa(%rsp), %rdx
movq %r15, %rdi
callq 0x1d278
xorl %r12d, %r12d
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
cmpq $0xe0, %r12
je 0x1c801
leaq (%rsp,%r12), %rdx
addq $0x50, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d4a7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d406
movq %r14, %rdi
callq 0x20d0
addq $0x20, %r12
jmp 0x1c7cc
movl $0xc0, %r14d
leaq (%rsp,%r14), %rdi
addq $0x50, %rdi
callq 0x20d0
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1c807
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c844
jmp 0x1c844
jmp 0x1c844
jmp 0x1c844
jmp 0x1c844
movq %rax, %r12
addq $-0x20, %r15
movq %r15, %rdi
callq 0x20d0
cmpq %r14, %r15
jne 0x1c847
jmp 0x1c893
movq %rax, %r12
jmp 0x1c893
movq %rax, %r12
jmp 0x1c89d
movq %rax, %r12
jmp 0x1c876
movq %rax, %r12
leaq 0x30(%rsp), %rdi
callq 0x20d0
movl $0xc0, %r14d
leaq (%rsp,%r14), %rdi
addq $0x50, %rdi
callq 0x20d0
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1c87c
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x1d486
movq %r12, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: shared_vertex(muc_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
bool shared_vertex(muc_t& muc, cycle_t& cycle)
{
    bool res = false;
    for(int i = 0; i < cycle.size(); ++i) {
        if(   muc.muc_subgraph.nodes_map.find(cycle[i].first) != muc.muc_subgraph.nodes_map.end() 
           || muc.muc_subgraph.nodes_map.find(cycle[i].second) != muc.muc_subgraph.nodes_map.end())
            return true;
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rdi), %r15
pushq $-0x1
popq %r12
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rbp
subq %rsi, %rbp
sarq $0x3, %rbp
incq %r12
cmpq %r12, %rbp
jbe 0x1f8dd
addq %r13, %rsi
movq %r15, %rdi
callq 0x1825c
movq 0x68(%r14), %rcx
movq 0x70(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x1f8dd
movq (%rbx), %rax
leaq (%rax,%r13), %rsi
addq $0x4, %rsi
addq $0x8, %r13
movq %r15, %rdi
callq 0x1825c
movq 0x68(%r14), %rcx
movq 0x70(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x1f889
cmpq %r12, %rbp
seta %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: shared_vertex(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
bool shared_vertex(cycle_t& c1, cycle_t& c2)
{
   bool res = false;
    for(int i = 0; i < c1.size(); ++i) {
        for(int j = 0; j < c2.size(); ++j) {
            if(   c1[i].first   == c2[j].first
               || c1[i].first   == c2[j].second
               || c1[i].second  == c2[j].first
               || c1[i].second  == c2[j].second) {
                return true;
            }
        }
    }
    return res;    
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
sarq $0x3, %rax
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
xorl %edi, %edi
cmpq %rax, %rdi
je 0x1f94d
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x1f948
movl (%rcx,%rdi,8), %r11d
movl (%rdx,%r8,8), %r10d
cmpl %r10d, %r11d
je 0x1f94d
movl 0x4(%rdx,%r8,8), %r9d
cmpl %r9d, %r11d
je 0x1f94d
movl 0x4(%rcx,%rdi,8), %r11d
cmpl %r10d, %r11d
je 0x1f94d
incq %r8
cmpl %r9d, %r11d
jne 0x1f918
jmp 0x1f94d
incq %rdi
jmp 0x1f910
cmpq %rdi, %rax
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: graph_t::merge_muc_cycle(muc_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void graph_t::merge_muc_cycle(muc_t& muc, cycle_t& cycle)
{
    for(int i = 0; i < cycle.size(); ++i) {
        node_id_t src, dst;
        src = cycle[i].first;
        dst = cycle[i].second;
        muc.muc_subgraph.insert_edge(src, dst);
        node_to_muc_vec[src] = muc.id;
        node_to_muc_vec[dst] = muc.id;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x60(%rsi), %r12
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x2057a
movl (%rax,%r15,8), %r13d
movl 0x4(%rax,%r15,8), %ebp
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x1756e
movl 0x308(%r14), %eax
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movl %eax, (%rcx,%r13,4)
movl %eax, (%rcx,%rbp,4)
incq %r15
jmp 0x20536
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: muc_t::insert_conn_vertex(unsigned int, unsigned int)
void muc_t::insert_conn_vertex(node_id_t id, node_id_t nbr) {
    if(conn_vertex_map.find(id) != conn_vertex_map.end()) {
        conn_vertex_map[id].push_back(nbr);
    } else {
        vector<node_id_t> vec;
        vec.push_back(nbr);
        conn_vertex_map.insert(make_pair(id, vec));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movl %edx, 0x8(%rsp)
movq %rax, %rsi
callq 0x22ed2
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x205df
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xb1de
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x478c
jmp 0x2066a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rsi
callq 0x478c
movl 0xc(%rsp), %eax
leaq 0x30(%rsp), %r14
movl %eax, -0x8(%r14)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x4ba0
movl 0x28(%rsp), %eax
leaq 0x50(%rsp), %r15
movl %eax, -0x8(%r15)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x18366
movq %r15, %rdi
callq 0x56ec
movq %r14, %rdi
callq 0x56ec
leaq 0x10(%rsp), %rdi
callq 0x56ec
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x56ec
movq %r14, %rdi
callq 0x56ec
jmp 0x20691
jmp 0x2068e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56ec
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: graph_t::print_mucs(bool)
void graph_t::print_mucs(bool with_nodes)
{
    for(int i = 0; i < muc_vec.size(); ++i) {
        if(!muc_vec[i].valid)
            continue;
        printf("MUC [%d] ====================================\n", i);
        printf("Connection vertices: ");
        for(muc_t::conn_vert_map_t::iterator
            it =  muc_vec[i].conn_vertex_map.begin();
            it != muc_vec[i].conn_vertex_map.end();
            ++it) {
            printf("[%d |G|=%d] ", it->first, muc_vec[i].subgraph_map[it->first].size());
        }
        printf("\n");
        printf("Bridges: ");
        for(muc_t::conn_vert_map_t::iterator
            it =  muc_vec[i].conn_vertex_map.begin();
            it != muc_vec[i].conn_vertex_map.end();
            ++it) {
            for(vector<node_id_t>::iterator it2 = it->second.begin();
                it2 != it->second.end(); ++it2) {
                printf("[%d == %d] ", it->first, *it2);
            }
            
        }
        printf("\n");
        muc_vec[i].muc_subgraph.print_graph(with_nodes);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x568, %edi            # imm = 0x568
movzbl %sil, %eax
movl %eax, 0x1c(%rsp)
leaq 0x8(%rsp), %r14
leaq 0x8ba4(%rip), %r15      # 0x29272
leaq 0x8b86(%rip), %r12      # 0x2925b
xorl %esi, %esi
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rax
subq %rcx, %rax
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0x2082c
imulq $0x568, %rsi, %rbp      # imm = 0x568
cmpb $0x1, 0x30c(%rcx,%rbp)
jne 0x20824
leaq 0x8b0a(%rip), %rdi      # 0x29216
movq %rsi, 0x20(%rsp)
xorl %eax, %eax
callq 0x2030
leaq 0x8b26(%rip), %rdi      # 0x29245
xorl %eax, %eax
callq 0x2030
movq 0x60(%rbx), %rdi
addq %rbp, %rdi
callq 0x22d80
movq %rax, %rsi
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x60(%rbx), %rdi
movq 0x8(%rdi,%rbp), %rax
movq 0x10(%rdi,%rbp), %rcx
cmpq (%rax,%rcx,8), %rsi
je 0x20789
addq %rbp, %rdi
movl (%rsi), %r13d
addq $0x30, %rdi
callq 0x22dc4
movq %rax, %rdi
callq 0x176f6
movq %r12, %rdi
movl %r13d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x25d38
movq 0x8(%rsp), %rsi
jmp 0x2073f
pushq $0xa
popq %rdi
callq 0x2300
leaq 0x8ad0(%rip), %rdi      # 0x29268
xorl %eax, %eax
callq 0x2030
movq 0x60(%rbx), %rdi
addq %rbp, %rdi
callq 0x22d80
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x60(%rbx), %rcx
movq 0x8(%rcx,%rbp), %rdx
movq 0x10(%rcx,%rbp), %rcx
cmpq (%rdx,%rcx,8), %rax
je 0x207fd
movq 0x8(%rax), %r13
cmpq 0x10(%rax), %r13
je 0x207ee
movl (%rax), %esi
movl (%r13), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
addq $0x4, %r13
movq 0x8(%rsp), %rax
jmp 0x207cd
movq %r14, %rdi
callq 0x25d38
movq 0x8(%rsp), %rax
jmp 0x207b5
pushq $0xa
popq %rdi
callq 0x2300
movq 0x60(%rbx), %rax
leaq (%rax,%rbp), %rdi
addq $0x60, %rdi
movl 0x1c(%rsp), %esi
callq 0x176fc
movl $0x568, %edi            # imm = 0x568
movq 0x20(%rsp), %rsi
incq %rsi
jmp 0x206d7
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: graph_t::merge_muc_muc(muc_t&, muc_t&)
void graph_t::merge_muc_muc(muc_t& muc1, muc_t& muc2)
{
    //1. copy the graph of muc2 into muc1
    //2. for each bridge edge, if the other end becomes in the graph, add the edge
    //3. mark muc2 as invalid
    //4. ASSUME muc1.id is valid, and update node_to_muc_vec for vertices in muc2
    //   to hold the id of muc1
    muc1.muc_subgraph.nodes_map.insert(
                muc2.muc_subgraph.nodes_map.begin(),
                muc2.muc_subgraph.nodes_map.end());
    muc1.muc_subgraph.edge_set.insert(
                muc2.muc_subgraph.edge_set.begin(),
                muc2.muc_subgraph.edge_set.end());
    for(muc_t::conn_vert_map_t::iterator it = muc2.conn_vertex_map.begin();
                                         it != muc2.conn_vertex_map.end(); 
                                         ++it) {
        node_id_t conn_vert = it->first;
        for(int i = 0; i < it->second.size(); ++i) {
            if(muc1.muc_subgraph.nodes_map.find(it->second[i]) != muc1.muc_subgraph.nodes_map.end()) {
                muc1.muc_subgraph.insert_edge(conn_vert, it->second[i]);
            }
        }
    }
    muc2.valid = false;
    for(graph_hash_t::nodes_map_t::iterator it = muc2.muc_subgraph.nodes_map.begin();
                                            it != muc2.muc_subgraph.nodes_map.end();
                                            ++it) {
        node_to_muc_vec[it->first] = muc1.id;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x60(%rsi), %r13
leaq 0x60(%rdx), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb11c
movq 0x68(%rbx), %rcx
movq 0x70(%rbx), %rsi
leaq (%rcx,%rsi,8), %r8
movq (%r8), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq 0x22f20
leaq 0x90(%r14), %rdi
movq 0xa8(%rbx), %rsi
leaq 0x98(%rbx), %rdx
callq 0x25b96
movq %rbx, %rdi
callq 0x22d80
movq %rsp, %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x20919
movl (%rax), %r12d
xorl %ebp, %ebp
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rbp, %rax
jbe 0x2090b
leaq (%rcx,%rbp,4), %rsi
movq %r13, %rdi
callq 0x1825c
movq 0x68(%r14), %rcx
movq 0x70(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x20902
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax,%rbp,4), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x1756e
incq %rbp
movq (%rsp), %rax
jmp 0x208be
movq %rsp, %rdi
callq 0x25d38
movq (%rsp), %rax
jmp 0x208ab
movb $0x0, 0x30c(%rbx)
movq 0x10(%rsp), %rdi
callq 0xb11c
movq %rsp, %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq 0x68(%rbx), %rcx
movq 0x70(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x20962
movl 0x308(%r14), %ecx
movl (%rax), %eax
movq 0x18(%r15), %rdx
movl %ecx, (%rdx,%rax,4)
movq %r12, %rdi
callq 0xbdd6
movq (%rsp), %rax
jmp 0x20936
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/qube.cc
// Function: graph_t::get_num_mucs()
size_t graph_t::get_num_mucs()
{
    size_t res = 0;
    for(int i = 0; i < muc_vec.size(); ++i) {
        if(muc_vec[i].valid) {
            ++res;
        }
    }
    return res;
}

// Assembly:
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rax
subq %rsi, %rax
movl $0x568, %ecx            # imm = 0x568
cqto
idivq %rcx
addq $0x30c, %rsi            # imm = 0x30C
xorl %ecx, %ecx
subq $0x1, %rax
jb 0x20b53
movzbl (%rsi), %edx
addq %rdx, %rcx
addq $0x568, %rsi            # imm = 0x568
jmp 0x20b3e
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::insert_edge(unsigned int, unsigned int)
void subgraph_t::insert_edge(node_id_t src, node_id_t dst)
{
    edge_t e1, e2;
    e1.first   = src;
    e1.second  = dst;
    e2.first   = dst;
    e2.second  = src;
    if(edge_set.find(e1) != edge_set.end() || edge_set.find(e2) != edge_set.end())
        return;
    else
        edge_set.insert(e1);
    nodes_vec[src].push_back(dst);
    nodes_vec[dst].push_back(src);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
leaq 0x10(%rsp), %rsi
movl %ebp, (%rsi)
movl %edx, 0x4(%rsi)
movl %edx, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x184c8
movq %rax, %r15
leaq 0x20(%rbx), %rax
cmpq %rax, %r15
jne 0x26153
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x184c8
cmpq %r15, %rax
jne 0x26153
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18558
movl %ebp, %eax
imulq $0x18, %rax, %rdi
addq (%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x478c
movl (%r14), %eax
imulq $0x18, %rax, %rdi
addq (%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x478c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::print_graph(bool)
void subgraph_t::print_graph(bool with_nodes)
{
    printf("Edges: \n");
    for(set<edge_t >::iterator it = edge_set.begin(); it != edge_set.end(); it++) {
        printf("[%d] === [%d]\n", it->first, it->second);
    }
    if(with_nodes) {
        printf("Nodes with edge lists: \n");
        for(int i = 0; i < nodes_vec.size(); ++i) {
            printf("[%d]\t-- ", i);
            for(int j = 0; j < nodes_vec[i].size(); j++) {
                printf("[%d] ", nodes_vec[i][j]);
            }
            printf("\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x291e(%rip), %rdi      # 0x28b6f
callq 0x2360
movq 0x30(%rbx), %r15
leaq 0x20(%rbx), %r12
leaq 0x28ec(%rip), %r14      # 0x28b51
cmpq %r12, %r15
je 0x26289
movl 0x20(%r15), %esi
movl 0x24(%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
jmp 0x26265
testb %bpl, %bpl
je 0x2630a
leaq 0x28e2(%rip), %rdi      # 0x28b77
callq 0x2360
leaq 0x28c8(%rip), %r15      # 0x28b69
pushq $0xa
popq %rbp
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r12, %rax
jbe 0x2630a
leaq 0x289e(%rip), %rdi      # 0x28b60
movl %r12d, %esi
xorl %eax, %eax
callq 0x2030
imulq $0x18, %r12, %r14
xorl %r13d, %r13d
movq (%rbx), %rcx
movq (%rcx,%r14), %rax
movq 0x8(%rcx,%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x262fe
movl (%rax,%r13,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %r13
jmp 0x262d3
movl %ebp, %edi
callq 0x2300
incq %r12
jmp 0x262a7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::conn_comp_sizes(std::vector<int, std::allocator<int>>&)
void subgraph_t::conn_comp_sizes(vector<int>& out_vec)
{
    out_vec.clear();
    vector<bool> visited_vec;
    i_fill_map<bool>(visited_vec, false);
    for(int n_id = 0; n_id < visited_vec.size(); ++n_id) {
        if(!visited_vec[n_id]) {
            node_id_t s = n_id;
            visited_vec[n_id] = true;
            out_vec.push_back(1);
            //do a BFS from s, count the number of vertices, and mark the visited
            queue<node_id_t> q;
            q.push(s);
            while(!q.empty()) {
                node_id_t node = q.front(); q.pop();
                vector<node_id_t> nbr_vec = get_nbrs(node);
                for(int i = 0; i < nbr_vec.size(); ++i) {
                    node_id_t nbr = nbr_vec[i];
                    if(!visited_vec[nbr]) {
                        visited_vec[nbr] = true;
                        q.push(nbr);
                        out_vec.back() = out_vec.back()+1;
                    }
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x26398
movq %rax, 0x8(%rbx)
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
callq 0x26a0c
xorl %esi, %esi
leaq 0x18(%rsp), %r12
leaq 0x58(%rsp), %r13
leaq 0x40(%rsp), %rbp
movq %rsp, %r15
movq 0x28(%rsp), %rax
movl 0x30(%rsp), %ecx
subq 0x18(%rsp), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rsi, %rax
jbe 0x264e2
movq %r12, %rdi
movq %rsi, 0x8(%rsp)
callq 0x4b82
testq %rdx, (%rax)
jne 0x264d5
movq 0x8(%rsp), %rsi
movl %esi, 0x4(%rsp)
movq %r12, %rdi
callq 0x4b82
orq %rdx, (%rax)
movl $0x1, 0x58(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x16ec8
movq %r13, %rdi
callq 0x4a40
movq %r13, %rdi
leaq 0x4(%rsp), %rsi
callq 0x62da
movq 0x68(%rsp), %rax
cmpq %rax, 0x88(%rsp)
je 0x264cd
movl (%rax), %r14d
movq %r13, %rdi
callq 0x650e
imulq $0x18, %r14, %rsi
movq 0x10(%rsp), %rax
addq (%rax), %rsi
movq %rbp, %rdi
callq 0x4ba0
xorl %r14d, %r14d
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x264c0
movl (%rax,%r14,4), %esi
movl %esi, (%rsp)
movq %r12, %rdi
callq 0x4b82
testq %rdx, (%rax)
jne 0x264bb
movl (%rsp), %esi
movq %r12, %rdi
callq 0x4b82
orq %rdx, (%rax)
movq %r13, %rdi
movq %r15, %rsi
callq 0x62da
movq 0x8(%rbx), %rax
incl -0x4(%rax)
incq %r14
jmp 0x26471
movq %rbp, %rdi
callq 0x56ec
jmp 0x26440
movq %r13, %rdi
callq 0x5280
movq 0x8(%rsp), %rsi
incq %rsi
jmp 0x263d3
leaq 0x18(%rsp), %rdi
callq 0x4e52
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26508
jmp 0x2650d
jmp 0x26508
jmp 0x26508
jmp 0x26508
movq %rax, %rbx
jmp 0x2652d
movq %rax, %rbx
jmp 0x26523
jmp 0x26516
jmp 0x26516
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x56ec
leaq 0x58(%rsp), %rdi
callq 0x5280
leaq 0x18(%rsp), %rdi
callq 0x4e52
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::find_sssp(unsigned int, std::vector<int, std::allocator<int>>&)
void subgraph_t::find_sssp(node_id_t s, vector<int>& out_vec)
{
    out_vec.clear();
    i_fill_map<int>(out_vec, -1);
    queue<node_id_t> Q;
    Q.push(s);
    out_vec[s] = 0;
    while(!Q.empty()) {
        node_id_t v = Q.front(); Q.pop();
        vector<node_id_t> nbr_vec = get_nbrs(v);
        for(int i = 0; i < nbr_vec.size(); ++i) {
            node_id_t nbr = nbr_vec[i];
            if(out_vec[nbr] == -1) {
                out_vec[nbr] = out_vec[v] + 1;
                Q.push(nbr);
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movl %esi, (%rsp)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x26566
movq %rax, 0x8(%rbx)
pushq $-0x1
popq %rdx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x26982
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4a40
movq %rsp, %rsi
movq %r15, %rdi
callq 0x62da
movl (%rsp), %eax
movq (%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x4(%rsp), %r13
movq 0x38(%rsp), %rax
cmpq %rax, 0x58(%rsp)
je 0x2661d
movl (%rax), %ebp
movq %r15, %rdi
callq 0x650e
imulq $0x18, %rbp, %rsi
movq 0x8(%rsp), %rax
addq (%rax), %rsi
movq %r12, %rdi
callq 0x4ba0
xorl %r14d, %r14d
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x26613
movl (%rax,%r14,4), %eax
movl %eax, 0x4(%rsp)
movq (%rbx), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x2660e
movl (%rcx,%rbp,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movq %r15, %rdi
movq %r13, %rsi
callq 0x62da
incq %r14
jmp 0x265d4
movq %r12, %rdi
callq 0x56ec
jmp 0x265a7
leaq 0x28(%rsp), %rdi
callq 0x5280
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26638
movq %rax, %rbx
jmp 0x2664a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56ec
leaq 0x28(%rsp), %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::find_pruning_counts_exp(unsigned int, unsigned int, int&, int&, int&)
void subgraph_t::find_pruning_counts_exp(node_id_t src,
                                        node_id_t dst,
                                        int& d0_cnt,
                                        int& d1_cnt,
                                        int& d2_cnt)
{
    vector<int> d_src_vec, d_dst_vec;
    find_sssp(src, d_src_vec);
    find_sssp(dst, d_dst_vec);
    d0_cnt = 0;
    d1_cnt = 0;
    d2_cnt = 0;
    for(int i = 0; i < nodes_vec.size(); ++i) {
        node_id_t s = i;
        int diff = d_src_vec[s] - d_dst_vec[s];
        int abs_diff = abs(diff);
        switch(abs_diff) {
            case 0:  d0_cnt++; break;
            case 1:  d1_cnt++; break;
            default: d2_cnt++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x26540
movq %rsp, %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0x26540
andl $0x0, (%r15)
andl $0x0, (%r14)
andl $0x0, (%rbx)
movq 0x8(%r12), %rax
subq (%r12), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq 0x20(%rsp), %rcx
xorl %edx, %edx
movq (%rsp), %rsi
cmpq %rdx, %rax
jbe 0x266f9
movl (%rcx,%rdx,4), %r8d
subl (%rsi,%rdx,4), %r8d
movl %r8d, %edi
negl %edi
cmovsl %r8d, %edi
movq %r15, %r8
testl %edi, %edi
je 0x266f1
movq %r14, %r8
cmpl $0x1, %edi
je 0x266f1
movq %rbx, %r8
incl (%r8)
incq %rdx
jmp 0x266c9
movq %rsp, %rdi
callq 0x5720
leaq 0x20(%rsp), %rdi
callq 0x5720
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5720
leaq 0x20(%rsp), %rdi
callq 0x5720
movq %rbx, %rdi
callq 0x23d0
nop