LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/_bc.cc
// Function: parallel_brandes(graph_t&, std::vector<double, std::allocator<double>>&)
void parallel_brandes(
        graph_t&        graph,
        vector<double>& BC_vec
        )
{
    //1. make a component (fill a subgraph)
    //2. loop through all sources
    BC_vec.resize(graph.size());
    fill(BC_vec.begin(), BC_vec.end(), 0.0);
    
    component_t comp;
    comp.comp_type = GRAPH;
    comp.subgraph.fill_graph(graph);
    
    // we want to do brandes_iter from each node in the graph
    // each thread will be responsible for doing brandes_iter from
    // a subset of the nodes in the graph
    //1. divide the nodes in the graph to vectors, each has a subset of nodes 
    //   a thread is responsible for
    //2. call brandes_block to get the contribution of the thread's nodes to the
    //   final BC value (fork and join)
    //3. accumulate the results in BC_vec

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
callq 0x18d3c
movq %r14, %rdi
movq %rax, %rsi
callq 0x45f0
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x45a1
andq $0x0, (%rax)
addq $0x8, %rax
jmp 0x4592
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4622
movl $0x2, 0x228(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26858
leaq 0x8(%rsp), %rdi
callq 0x46de
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x46de
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/_bc_mem.cc
// Function: Update_BC_mem(std::vector<double, std::allocator<double>>&, graph_t&, comp_type_t, std::pair<unsigned int, unsigned int>, std::vector<iter_info_t, std::allocator<iter_info_t>>&)
void Update_BC_mem(
        vector<double>&         BC_vec,
        graph_t&                graph,
        comp_type_t             comp_type,
        edge_t                  e,
        vector<iter_info_t>&    iter_info_vec
        )
{
    if(comp_type == GRAPH) {
        component_t comp;
        comp.comp_type = GRAPH;
        comp.subgraph.fill_graph(graph);
        vector<double> dBC_vec;
        iCentral_mem(dBC_vec, comp, e, iter_info_vec);
        for(int i = 0; i < dBC_vec.size(); ++i) {
            BC_vec[i] += dBC_vec[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
cmpl $0x2, %edx
jne 0x69bc
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x4622
movl $0x2, 0x228(%r13)
movq %r13, %rdi
movq %r12, %rsi
callq 0x26858
xorpd %xmm0, %xmm0
movq %rsp, %rdi
movapd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x69ef
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq (%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x69aa
movsd (%rax,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x6991
movq %rsp, %rdi
callq 0x5754
leaq 0x20(%rsp), %rdi
callq 0x46de
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5754
jmp 0x69dd
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x46de
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/_bc_mem.cc
// Function: iCentral_mem(std::vector<double, std::allocator<double>>&, component_t&, std::pair<unsigned int, unsigned int>, std::vector<iter_info_t, std::allocator<iter_info_t>>&)
void iCentral_mem(
        vector<double>&         dBC_vec,
        component_t&            comp,
        edge_t                  e,
        vector<iter_info_t>&    iter_info_vec
        )
{
    fill_vec<double>(dBC_vec, comp.subgraph.size(), 0.0);
    vector<int> d_src_vec, d_dst_vec;
    comp.subgraph.find_sssp(e.first, d_src_vec);
    comp.subgraph.find_sssp(e.second, d_dst_vec);    
    for(node_id_t s = 0; s < comp.subgraph.size(); ++s) {
        if(d_src_vec[s] != d_dst_vec[s]) {
            iCentral_iter_mem(dBC_vec, comp, s, e, iter_info_vec[s]);
        }

    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x2622a
xorps %xmm0, %xmm0
movq %r12, %rdi
movq %rax, %rsi
callq 0x4756
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl %r14d, %esi
callq 0x26540
movq %r14, %rsi
shrq $0x20, %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x26540
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2622a
movl %r13d, %r13d
cmpq %r13, %rax
jbe 0x6a9b
movq 0x20(%rsp), %rax
movl (%rax,%r13,4), %eax
movq (%rsp), %rcx
cmpl (%rcx,%r13,4), %eax
je 0x6a96
imulq $0x118, %r13, %r8       # imm = 0x118
addq (%rbx), %r8
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
movq %r14, %rcx
callq 0x6ada
incl %r13d
jmp 0x6a58
movq %rsp, %rdi
callq 0x5720
leaq 0x20(%rsp), %rdi
callq 0x5720
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6abd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5720
leaq 0x20(%rsp), %rdi
callq 0x5720
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bc.cc
// Function: brandes_bc(graph_t&, int)
vector<double> brandes_bc(graph_t& graph_in, int max_iter)
{
    vector<double> bc_vec;
    bc_vec.resize(graph_in.size());
    fill(bc_vec.begin(), bc_vec.end(), 0.0);
    if(max_iter == -1) {
        for(node_id_t s = 0; s < graph_in.size(); ++s) {
            brandes_iter(graph_in, s, bc_vec);
        }
        for(node_id_t i = 0; i < bc_vec.size(); ++i) {
            bc_vec[i] = bc_vec[i]/2;
        }
    } else {
        int num_iter = min(max_iter, (int)graph_in.size());
        for(node_id_t s = 0; s < num_iter; ++s) {
            brandes_iter(graph_in, s, bc_vec);
        }
    }

    return bc_vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x18d3c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45f0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x8fe8
andq $0x0, (%rax)
addq $0x8, %rax
jmp 0x8fd9
cmpl $-0x1, %ebp
je 0x9015
movq %r14, %rdi
callq 0x18d3c
cmpl %ebp, %eax
cmovll %eax, %ebp
xorl %r15d, %r15d
cmpl %r15d, %ebp
je 0x9068
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x908f
incl %r15d
jmp 0x8ffd
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x18d3c
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0x9037
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x908f
incl %ebp
jmp 0x9017
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
movsd 0x1efe1(%rip), %xmm0    # 0x28030
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x9068
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incl %edx
jmp 0x904f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x907c
jmp 0x907c
jmp 0x907c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5754
movq %r14, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bc.cc
// Function: brandes_bc_hash_out(graph_t&, int)
brandes_bc_hash_out(graph_t& graph_in, int max_iter)
{
    tr1_map_t(double) bc_vec;
    for(int i = 0; i < graph_in.nodes_vec.size(); ++i) {
        bc_vec.insert(make_pair(i, 0.0));
    }

    if(max_iter == -1) {
        for(node_id_t s = 0; s < graph_in.size(); ++s) {
            brandes_iter_hash_out(graph_in, s, bc_vec);
        }
        for(node_id_t i = 0; i < bc_vec.size(); ++i) {
            bc_vec[i] = bc_vec[i]/2;
        }
    } else {
        int num_iter = min(max_iter, (int)graph_in.size());
        for(node_id_t s = 0; s < num_iter; ++s) {
            brandes_iter_hash_out(graph_in, s, bc_vec);
        }
    }

    return bc_vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
pushq $0xa
popq %rsi
leaq 0x20(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x7(%rsp), %r8
movq %r15, %rdx
movq %r12, %rcx
callq 0xb770
xorl %r13d, %r13d
pushq $0x18
popq %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x94d7
movl %r13d, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb838
incq %r13
jmp 0x94a8
movl 0x8(%rsp), %ebp
cmpl $-0x1, %ebp
je 0x950c
movq %r14, %rdi
callq 0x18d3c
cmpl %ebp, %eax
cmovll %eax, %ebp
xorl %r15d, %r15d
cmpl %r15d, %ebp
je 0x957b
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x95a8
incl %r15d
jmp 0x94f0
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x18d3c
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0x952e
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x95a8
incl %ebp
jmp 0x950e
xorl %eax, %eax
leaq 0x20(%rsp), %r14
movl %eax, 0x20(%rsp)
movl %eax, %eax
cmpq %rax, 0x18(%rbx)
jbe 0x957b
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb00c
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb00c
movsd 0x8(%rsp), %xmm0
mulsd 0x1eac1(%rip), %xmm0    # 0x28030
movsd %xmm0, (%rax)
movl 0x20(%rsp), %eax
incl %eax
jmp 0x9535
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9595
jmp 0x9595
jmp 0x9595
jmp 0x9595
movq %rax, %r14
movq %rbx, %rdi
callq 0xb070
movq %r14, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bc.cc
// Function: incremental_brandes(graph_t&, unsigned int, unsigned int, std::vector<double, std::allocator<double>>&)
void incremental_brandes(graph_t& graph_in,
        node_id_t src,
        node_id_t dst,
        vector<double>& bc_vec)
{
    vector<int> d_src_vec, d_dst_vec;
    d_src_vec.resize(graph_in.size());
    d_dst_vec.resize(graph_in.size());
    fill(d_src_vec.begin(), d_src_vec.end(), -1);
    fill(d_dst_vec.begin(), d_dst_vec.end(), -1);
    graph_in.find_sssp(src, d_src_vec);
    graph_in.find_sssp(dst, d_dst_vec);
    
    //fill(bc_vec.begin(), bc_vec.end(), 0);
    
    for(node_id_t s = 0; s < graph_in.size(); ++s) {
        if(d_src_vec[s] != d_dst_vec[s]) { 
            brandes_delta_iter(graph_in,
                    s, 
                    src, 
                    dst, 
                    d_src_vec[s], 
                    d_dst_vec[s], 
                    bc_vec);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x18d3c
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r15, %rdi
callq 0x18d3c
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rcx, %rax
je 0x9a1e
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x9a10
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x9a36
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x9a28
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x19208
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x19208
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x18d3c
movl %r12d, %r12d
cmpq %r12, %rax
jbe 0x9a98
movq 0x30(%rsp), %rax
movl (%rax,%r12,4), %r8d
movq 0x10(%rsp), %rax
movl (%rax,%r12,4), %r9d
cmpl %r9d, %r8d
je 0x9a93
movq %rbx, (%rsp)
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x9ada
incl %r12d
jmp 0x9a58
leaq 0x10(%rsp), %rdi
callq 0x5720
leaq 0x30(%rsp), %rdi
callq 0x5720
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9abb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5720
leaq 0x30(%rsp), %rdi
callq 0x5720
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bc.cc
// Function: brandes_bc_hash(graph_hash_t&, int)
brandes_bc_hash(graph_hash_t& graph_in, int max_iter)
{
    tr1_map_t(double) bc_vec;
    graph_in.i_fill_map<double>(bc_vec, 0);
    //means do all iterations
    if(max_iter == -1) {
        for(graph_hash_t::nodes_map_t::iterator it = graph_in.nodes_map.begin();
                it != graph_in.nodes_map.end(); 
                ++it) {
            node_id_t s = it->first;
            brandes_iter(graph_in, s, bc_vec);
        }
    } else {
        int cnt = 0;
        for(graph_hash_t::nodes_map_t::iterator it = graph_in.nodes_map.begin();
                it != graph_in.nodes_map.end(); 
                ++it) {
            node_id_t s = it->first;
            ++cnt;
            brandes_iter(graph_in, s, bc_vec);
            if(cnt == max_iter)
                break;
        }
    }
    
    if(max_iter == -1) {
        for(tr1_map_t(double)::iterator it = bc_vec.begin();
                it != bc_vec.end();
                ++it) {
            it->second = it->second/2;
        }
    }
    return bc_vec;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
pushq $0xa
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
callq 0xb770
xorpd %xmm0, %xmm0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18120
cmpl $-0x1, %r14d
je 0xab9d
movq %r15, %rdi
callq 0xb11c
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
leal -0x1(%r14), %ebp
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0xabdd
movl (%rax), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xac53
subl $0x1, %ebp
jb 0xabdd
movq %r12, %rdi
callq 0xbdd6
movq 0x10(%rsp), %rax
jmp 0xab6e
movq %r15, %rdi
callq 0xb11c
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0xabdd
movl (%rax), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xac53
movq %r12, %rdi
callq 0xbdd6
movq 0x10(%rsp), %rax
jmp 0xabb3
cmpl $-0x1, %r14d
je 0xabf3
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0xb14e
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0xabe3
movsd 0x8(%rax), %xmm0
mulsd 0x1d40e(%rip), %xmm0    # 0x28030
movsd %xmm0, 0x8(%rax)
movq %r14, %rdi
callq 0xbe06
movq 0x10(%rsp), %rax
jmp 0xac07
jmp 0xac40
jmp 0xac40
jmp 0xac40
jmp 0xac40
jmp 0xac40
movq %rax, %r14
movq %rbx, %rdi
callq 0xb070
movq %r14, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bcc_delta.cc
// Function: bcc_delta_t::print()
void bcc_delta_t::print()
{
    bcc_subgraph.print_graph(false);
    printf("Art. point and graph sizes:\n");
    for(art_pt_map_t::iterator it = art_pt_map.begin();
        it != art_pt_map.end();
        ++it) {
        printf("[%d]: ", it->first);
        for(int i = 0; i < it->second.size(); ++i) {
            printf("%d ", it->second[i]);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x30, %rdi
xorl %esi, %esi
callq 0x176fc
leaq 0x1be08(%rip), %rdi     # 0x28193
callq 0x2360
movq %rbx, %rdi
callq 0xf10e
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x1bddd(%rip), %r15     # 0x28188
leaq 0x1bddd(%rip), %r12     # 0x2818f
pushq $0xa
popq %rbp
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0xc414
movl (%rax), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0xc3fe
movl (%rax,%r13,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2030
incq %r13
jmp 0xc3d2
movl %ebp, %edi
callq 0x2300
movq %r14, %rdi
callq 0xf43c
movq 0x8(%rsp), %rax
jmp 0xc3b5
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/bcc_delta.cc
// Function: bcc_delta_t::i_iteration(unsigned int, unsigned int, unsigned int, int, int, std::tr1::unordered_map<unsigned int, double, std::tr1::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, double>>>&)
void bcc_delta_t::i_iteration(node_id_t s,
                        node_id_t src,
                        node_id_t dst,
                        int d_src,
                        int d_dst,
                        tr1_map_t(double)& bc_vec)
{
    //make sure that @src is the closer to source node
    if(d_src > d_dst) {
        node_id_t       tmp_v;
        int             tmp_i;
        tmp_v = src; src = dst; dst = tmp_v;
        tmp_i = d_src; d_src = d_dst; d_dst = tmp_i;
    }
    
    if(d_dst - d_src == 1) {
        //dbg_iteration(s, src, dst, d_src, d_dst, bc_vec);
        i_iteration_1(s, src, dst, d_src, d_dst, bc_vec);
        //i_iteration_2(s, src, dst, d_src, d_dst, bc_vec);
    } else {
        //dbg_iteration(s, src, dst, d_src, d_dst, bc_vec);
        i_iteration_2(s, src, dst, d_src, d_dst, bc_vec);
    }
}

// Assembly:
cmpl %r9d, %r8d
jle 0xcbb4
movl %r8d, %r10d
movl %edx, %eax
jmp 0xcbbe
movl %r9d, %r10d
movl %r8d, %r9d
movl %ecx, %eax
movl %edx, %ecx
subl %r9d, %r10d
cmpl $0x1, %r10d
jne 0xcbdc
pushq %rax
movq 0x10(%rsp), %rdx
movq %rdx, (%rsp)
movl %ecx, %edx
movl %eax, %ecx
callq 0xd23e
popq %rax
retq
movl %ecx, %edx
movl %eax, %ecx
jmp 0xd9d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bicon.cc
// Function: graph_t::find_art_points(std::vector<unsigned int, std::allocator<unsigned int>>&)
void graph_t::find_art_points(vector<node_id_t>& out_vec)
{
    node_id_t u;
    vector<int> color_vec;
    vector<int> low_vec;
    vector<int> d_vec;
    vector<node_id_t> pred_vec;
    int time;
    
    u = 0;
    color_vec.resize(size());
    low_vec.resize(size());
    d_vec.resize(size());
    pred_vec.resize(size());
    fill(color_vec.begin(), color_vec.end(), 0);
    fill(low_vec.begin(), low_vec.end(), -1);
    fill(d_vec.begin(), d_vec.end(), -1);
    fill(pred_vec.begin(), pred_vec.end(), -1);
    
    i_art_point_dfs_visitor(u, color_vec, low_vec, d_vec, pred_vec, time, out_vec);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x18d3c
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1141a
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq %rcx, %rax
je 0x10881
andl $0x0, (%rax)
addq $0x4, %rax
jmp 0x10873
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq %rcx, %rax
je 0x10899
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x1088b
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
je 0x108b1
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x108a3
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x108c8
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x108ba
leaq 0x84(%rsp), %rax
leaq 0x60(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rsp, %r9
movq %r14, %rdi
xorl %esi, %esi
pushq %rbx
pushq %rax
callq 0x10952
popq %rax
popq %rcx
movq %rsp, %rdi
callq 0x56ec
leaq 0x20(%rsp), %rdi
callq 0x5720
leaq 0x40(%rsp), %rdi
callq 0x5720
leaq 0x60(%rsp), %rdi
callq 0x5720
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56ec
leaq 0x20(%rsp), %rdi
callq 0x5720
leaq 0x40(%rsp), %rdi
callq 0x5720
leaq 0x60(%rsp), %rdi
callq 0x5720
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bicon.cc
// Function: graph_t::find_bicon_comp(std::vector<graph_hash_t, std::allocator<graph_hash_t>>&)
void graph_t::find_bicon_comp(vector<graph_hash_t>& out_vec)
{
    node_id_t u;
    vector<int> color_vec;
    vector<int> low_vec;
    vector<int> d_vec;
    vector<node_id_t> pred_vec;
    stack<edge_t> edge_stack;
    int time;
    
    u = 0;
    color_vec.resize(size());
    low_vec.resize(size());
    d_vec.resize(size());
    pred_vec.resize(size());
    fill(color_vec.begin(), color_vec.end(), 0);
    fill(low_vec.begin(), low_vec.end(), -1);
    fill(d_vec.begin(), d_vec.end(), -1);
    fill(pred_vec.begin(), pred_vec.end(), -1);
    
    i_bcc_dfs_visitor(u,
                    color_vec,
                    low_vec,
                    d_vec,
                    pred_vec,
                    edge_stack,
                    time,
                    out_vec);   
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0x1144c
movq %r14, %rdi
callq 0x18d3c
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xafb8
movq %r14, %rdi
callq 0x18d3c
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1141a
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
cmpq %rcx, %rax
je 0x10b84
andl $0x0, (%rax)
addq $0x4, %rax
jmp 0x10b76
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpq %rcx, %rax
je 0x10b9c
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x10b8e
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
je 0x10bb4
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x10ba6
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x10bcb
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x10bbd
subq $0x8, %rsp
leaq 0x84(%rsp), %rax
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r14, %rdi
xorl %esi, %esi
pushq %rbx
pushq %rax
pushq %r15
callq 0x10c80
addq $0x20, %rsp
leaq 0x80(%rsp), %rdi
callq 0x11822
movq %rsp, %rdi
callq 0x56ec
leaq 0x20(%rsp), %rdi
callq 0x5720
leaq 0x40(%rsp), %rdi
callq 0x5720
leaq 0x60(%rsp), %rdi
callq 0x5720
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x10c52
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x11822
movq %rsp, %rdi
callq 0x56ec
leaq 0x20(%rsp), %rdi
callq 0x5720
leaq 0x40(%rsp), %rdi
callq 0x5720
leaq 0x60(%rsp), %rdi
callq 0x5720
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/bicon.cc
// Function: graph_t::find_bridge_edges(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void graph_t::find_bridge_edges(vector<edge_t>& out_vec)
{
    out_vec.clear();
    
    vector<graph_hash_t> bcc_vec;
    find_bicon_comp(bcc_vec);
    
    for(int i = 0; i < bcc_vec.size(); ++i) {
        if(bcc_vec[i].size() == 2) {
            edge_t e;
            e = *bcc_vec[i].edge_set.begin();
            out_vec.push_back(e);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1137b
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x10aca
xorl %r15d, %r15d
movl $0x2a8, %r12d           # imm = 0x2A8
leaq 0x18(%rsp), %r14
xorl %r13d, %r13d
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x113ec
addq %r15, %rdi
callq 0x176f6
cmpq $0x2, %rax
jne 0x113e0
movq (%rsp), %rax
movq 0x48(%rax,%r15), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x117e2
incq %r13
addq $0x2a8, %r15            # imm = 0x2A8
jmp 0x1139f
movq %rsp, %rdi
callq 0x11800
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x11406
jmp 0x11406
movq %rax, %rbx
movq %rsp, %rdi
callq 0x11800
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/experiments.cc
// Function: fuad_ideal_speedup(double, int, int, int, int, int)
double fuad_ideal_speedup(double iter_frac,
        int BCC_n,
        int BCC_m,
        int G_n,
        int G_m,
        int inc_bfs_ratio)
{
   double res;
   int BCC_s = BCC_n + BCC_m;
   int G_s = G_n + G_m;
   res =  1.0/(((double)BCC_n/G_n) * iter_frac * ((double)BCC_s/G_s));
   res = res * 100.0/inc_bfs_ratio; 
   return res;
}

// Assembly:
addl %edi, %esi
addl %edx, %ecx
movd %esi, %xmm1
movd %edi, %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd %xmm2, %xmm1
movd %ecx, %xmm2
movd %edx, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
cvtdq2pd %xmm3, %xmm2
divpd %xmm2, %xmm1
mulsd %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
mulsd %xmm0, %xmm1
movsd 0x1539c(%rip), %xmm0    # 0x28040
divsd %xmm1, %xmm0
mulsd 0x15500(%rip), %xmm0    # 0x281b0
cvtsi2sd %r8d, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/experiments.cc
// Function: gen_rand_edges(int, graph_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void gen_rand_edges(int num_edges,
        graph_t& graph,
        vector<edge_t>& out_vec)
{
    out_vec.clear();
    for(int i = 0; i < num_edges; ++i) {
        edge_t rand_edge;
        node_id_t src, dst;
        do {
            src = rand()%graph.size();
            dst = rand()%graph.size();
            rand_edge.first    = src;
            rand_edge.second   = dst;
        } while(graph.has_edge(rand_edge) ||
                find(out_vec.begin(), out_vec.end(), rand_edge) != out_vec.end());
        out_vec.push_back(rand_edge);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x12cdb
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
testl %edi, %edi
cmovlel %ebp, %edi
movl %edi, 0xc(%rsp)
leaq 0x10(%rsp), %r15
cmpl 0xc(%rsp), %ebp
je 0x12d6f
andq $0x0, 0x10(%rsp)
callq 0x2070
movslq %eax, %r12
movq %r14, %rdi
callq 0x18d3c
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
callq 0x2070
movslq %eax, %r13
movq %r14, %rdi
callq 0x18d3c
movq %rax, %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movl %r12d, 0x10(%rsp)
movl %edx, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x191b4
testb %al, %al
jne 0x12cf7
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r15, %rdx
callq 0x1658d
cmpq 0x8(%rbx), %rax
jne 0x12cf7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x117e2
incl %ebp
jmp 0x12ceb
addq $0x18, %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/experiments.cc
// Function: gen_rand_edges_deletions(int, graph_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void gen_rand_edges_deletions(int num_edges,
        graph_t& graph,
        vector<edge_t>& out_vec)
{
    vector<edge_t> bridges_vec;
    graph.find_bridge_edges(bridges_vec);
    //NOTE:insert each edge twice -- e(v1, v2) e(v2, v1)
    int num_bridges = bridges_vec.size();
    for(int i = 0; i < num_bridges; ++i) {
        bridges_vec.push_back(make_pair(bridges_vec[i].second, bridges_vec[i].first));
    }
    out_vec.clear();
    int num_edges_graph = graph.edge_set.size();
    set<edge_t>::const_iterator it(graph.edge_set.begin());
    for(int i = 0; i < num_edges; ++i) {
        edge_t rand_edge;
        do {
            //select an edge at random
            it = graph.edge_set.begin();
            advance(it, rand()%num_edges_graph);
            rand_edge = *it;
        } while(find(bridges_vec.begin(), bridges_vec.end(), rand_edge) != bridges_vec.end());
        out_vec.push_back(rand_edge);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movl %edi, %ebp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x1135e
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %rbx
subq (%r15), %rbx
shrq $0x3, %rbx
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
leaq 0x8(%rsp), %r12
cmpq %r13, %rbx
je 0x12dfb
movq 0x20(%rsp), %rax
movl (%rax,%r13,8), %ecx
movl 0x4(%rax,%r13,8), %eax
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x16674
incq %r13
jmp 0x12dcc
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x12e0d
movq %rax, 0x8(%rcx)
movl 0x58(%r14), %r13d
xorl %ebx, %ebx
testl %ebp, %ebp
cmovlel %ebx, %ebp
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
cmpl %ebp, %ebx
je 0x12e80
andq $0x0, 0x18(%rsp)
movq 0x48(%r14), %rax
movq %rax, 0x8(%rsp)
callq 0x2070
cltd
idivl %r13d
movq %r15, %rdi
movl %edx, %esi
callq 0x16376
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %r12, %rdx
callq 0x1658d
cmpq 0x28(%rsp), %rax
jne 0x12e2c
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x117e2
incl %ebx
jmp 0x12e22
leaq 0x20(%rsp), %rdi
callq 0x16656
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12ea1
jmp 0x12ea1
jmp 0x12ea1
jmp 0x12ea1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x16656
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::init_maps()
void graph_hash_t::init_maps()
{
    i_fill_map<vector<node_id_t> >(P, vector<node_id_t>());
    i_fill_map<int>(path_cnt_vec, 0);
    i_fill_map<int>(new_path_cnt_vec, 0);
    i_fill_map<int>(dist_vec, -1);
    i_fill_map<double>(pair_dep_vec, 0);
    i_fill_map<double>(new_pair_dep_vec, 0);
    i_fill_map<double>(sigma_t_map, 0);
    i_fill_map<double>(new_sigma_t_map, 0);
    i_fill_map<int>(path_cnt_inc_vec, 0);
    i_fill_map<bool>(visited_vec, false);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0x17f86
movq %rsp, %rdi
callq 0x56ec
leaq 0x90(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1808c
leaq 0xc0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1808c
leaq 0xf0(%rbx), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x1808c
leaq 0x120(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x18120
leaq 0x150(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x18120
leaq 0x1b0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x18120
leaq 0x1e0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x18120
leaq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1808c
leaq 0x210(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x181c8
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56ec
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::insert_edge(unsigned int, unsigned int)
void graph_hash_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);
    
    insert_node(src);
    insert_node(dst);
    nodes_map[src].nbrs_vec.push_back(dst);
    nodes_map[dst].nbrs_vec.push_back(src);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
leaq 0x18(%rsp), %rsi
movl %r14d, (%rsi)
movl %edx, 0x4(%rsi)
movl %edx, 0x10(%rsp)
movl %r14d, 0x14(%rsp)
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x184c8
movq %rax, %r12
leaq 0x38(%rbx), %rax
cmpq %rax, %r12
jne 0x17620
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x184c8
cmpq %r12, %rax
jne 0x17620
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x18558
movq %rbx, %rdi
movl %r14d, %esi
callq 0x174b0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x174b0
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf182
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x478c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf182
movq %rax, %rdi
movq %r14, %rsi
callq 0x478c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::remove_edge(unsigned int, unsigned int)
void graph_hash_t::remove_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    edge_set.erase(edge);
    edge = make_pair(dst, src);
    edge_set.erase(edge);
    
    vector<node_id_t>& v1 = nodes_map[src].nbrs_vec;
    vector<node_id_t>& v2 = nodes_map[dst].nbrs_vec;
    v1.erase(std::remove(v1.begin(), v1.end(), dst), v1.end());
    v2.erase(std::remove(v2.begin(), v2.end(), src), v2.end());    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r15
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
leaq 0xc(%rsp), %r14
movl %edx, (%r14)
movq %r12, %rax
shlq $0x20, %rax
movl %esi, %ecx
orq %rax, %rcx
leaq 0x10(%rsp), %r13
movq %rcx, (%r13)
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1868a
movl %r12d, (%r13)
movl %ebp, 0x4(%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1868a
movq %r15, %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0xf182
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf182
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x18854
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x182aa
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %r12, %rdx
callq 0x18854
movq 0x8(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x182aa
addq $0x18, %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/graph_hash_t.cc
// Function: graph_hash_t::print_graph(bool)
void graph_hash_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(tr1::unordered_map<node_id_t, node_t>::iterator it = nodes_map.begin(); it != nodes_map.end(); it++) {
            printf("[%d]\t-- ", it->first);
            for(int i = 0; i < it->second.nbrs_vec.size(); i++) {
                printf("[%d] ", it->second.nbrs_vec[i]);
            }
            printf("\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x11459(%rip), %rdi     # 0x28b6f
callq 0x2360
movq 0x48(%rbx), %r15
leaq 0x38(%rbx), %r12
leaq 0x11427(%rip), %r14     # 0x28b51
cmpq %r12, %r15
je 0x1774e
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 0x1772a
testb %bpl, %bpl
je 0x177e9
leaq 0x11419(%rip), %rdi     # 0x28b77
callq 0x2360
movq %rbx, %rdi
callq 0xb11c
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x113e2(%rip), %r15     # 0x28b60
leaq 0x113e4(%rip), %r12     # 0x28b69
pushq $0xa
popq %rbp
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x177e9
movl (%rax), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x177d1
movl (%rax,%r13,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2030
incq %r13
jmp 0x177a5
movl %ebp, %edi
callq 0x2300
movq %r14, %rdi
xorl %esi, %esi
callq 0x182b0
movq 0x8(%rsp), %rax
jmp 0x17788
addq $0x18, %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/graph_hash_t.cc
// Function: graph_hash_t::has_edge(unsigned int, unsigned int)
bool graph_hash_t::has_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;
    bool res = false;
    if(   edge_set.find(e1) != edge_set.end()
       || edge_set.find(e2) != edge_set.end()) {
        res = true;
    }
    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movl %edx, (%rsp)
movl %esi, 0x4(%rsp)
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x184c8
addq $0x38, %r15
cmpq %r15, %rax
jne 0x17840
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x184c8
cmpq %r14, %rax
je 0x1784c
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x17842
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::find_sssp(unsigned int, std::tr1::unordered_map<unsigned int, int, std::tr1::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, int>>>&)
void graph_hash_t::find_sssp(node_id_t s, tr1_map_t(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 $0x88, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x14(%rsp), %r15
movl %esi, (%r15)
movq %rdx, %rdi
callq 0xf408
pushq $-0x1
popq %rdx
movq %r14, 0x18(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1808c
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x4a40
movq %r12, %rdi
movq %r15, %rsi
callq 0x62da
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
callq 0xb180
andl $0x0, (%rax)
leaq 0x38(%rsp), %r15
leaq 0x20(%rsp), %r14
leaq 0x10(%rsp), %r13
leaq 0xc(%rsp), %rbp
movq 0x48(%rsp), %rax
cmpq %rax, 0x68(%rsp)
je 0x17d6d
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x650e
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x173c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4ba0
xorl %r14d, %r14d
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x17d5b
movl (%rax,%r14,4), %eax
movl %eax, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xb180
cmpl $-0x1, (%rax)
jne 0x17d56
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xb180
movl (%rax), %r12d
movq %rbx, %rdi
movq %r13, %rsi
callq 0xb180
incl %r12d
movl %r12d, (%rax)
movq %r15, %rdi
movq %r13, %rsi
callq 0x62da
incq %r14
jmp 0x17cfe
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x56ec
jmp 0x17cc4
leaq 0x38(%rsp), %rdi
callq 0x5280
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17d8b
movq %rax, %rbx
jmp 0x17d9d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x56ec
leaq 0x38(%rsp), %rdi
callq 0x5280
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::fill_graph(graph_t&)
void graph_hash_t::fill_graph(graph_t& g)
{
    for(set<edge_t>::iterator it = g.edge_set.begin();
            it != g.edge_set.end();
            ++it) {
        insert_edge(it->first, it->second);
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %r15
addq $0x38, %rbx
cmpq %rbx, %r15
je 0x17de5
movl 0x20(%r15), %esi
movl 0x24(%r15), %edx
movq %r14, %rdi
callq 0x1756e
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
jmp 0x17dc3
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::find_pruning_counts_exp(unsigned int, unsigned int, int&, int&, int&)
void graph_hash_t::find_pruning_counts_exp(node_id_t src,
                                        node_id_t dst,
                                        int& d0_cnt,
                                        int& d1_cnt,
                                        int& d2_cnt)
{
    //IMP: the edge (src, dst) must not be in the graph
    //else doesn't make sense to count pruned BFS's
    bool insert = has_edge(src, dst);
    remove_edge(src, dst);
    tr1_map_t(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(graph_hash_t::nodes_map_t::iterator
                        it =  nodes_map.begin();
                        it != nodes_map.end();
                        ++it) {
        node_id_t s = it->first;
        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++;
        }
    }
    if(insert)
        insert_edge(src, dst);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, %r13
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
callq 0x177f8
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x1762e
leaq 0x68(%rsp), %rdi
pushq $0xa
popq %rbx
leaq 0x38(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rsi
callq 0xf72c
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0xf(%rsp), %r8
movq %rbx, %rsi
callq 0xf72c
leaq 0x68(%rsp), %rdx
movq %r14, %rdi
movl %r15d, %esi
callq 0x17c4e
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x17c4e
movb %r12b, 0x7(%rsp)
movl %r15d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
andl $0x0, (%r13)
movq 0x20(%rsp), %rax
andl $0x0, (%rax)
movq 0x18(%rsp), %rax
andl $0x0, (%rax)
movq %r14, %rdi
callq 0xb11c
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x17f20
movl (%rax), %eax
movl %eax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0xb180
movl (%rax), %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0xb180
subl (%rax), %ebp
movl %ebp, %eax
negl %eax
cmovsl %ebp, %eax
movq %r13, %rcx
testl %eax, %eax
je 0x17f0f
movq 0x20(%rsp), %rcx
cmpl $0x1, %eax
je 0x17f0f
movq 0x18(%rsp), %rcx
incl (%rcx)
movq %rbx, %rdi
callq 0xbdd6
movq 0x28(%rsp), %rax
jmp 0x17ec2
cmpb $0x0, 0x7(%rsp)
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %esi
je 0x17f37
movq %r14, %rdi
callq 0x1756e
leaq 0x38(%rsp), %rdi
callq 0xf15e
leaq 0x68(%rsp), %rdi
callq 0xf15e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17f66
movq %rax, %rbx
jmp 0x17f73
jmp 0x17f66
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf15e
leaq 0x68(%rsp), %rdi
callq 0xf15e
movq %rbx, %rdi
callq 0x23d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::insert_edge(unsigned int, unsigned int)
void graph_t::insert_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    if(edge_set.find(edge) != edge_set.end())
        return;
    edge = make_pair(dst, src);
    if(edge_set.find(edge) != edge_set.end())
        return;
    edge_set.insert(edge);
    nodes_vec[src].nbrs_vec.push_back(dst);
    nodes_vec[dst].nbrs_vec.push_back(src);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %r15, %rax
shlq $0x20, %rax
movl %esi, %r13d
orq %r13, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0x184c8
movq %rax, %r12
leaq 0x38(%rbx), %rax
cmpq %rax, %r12
jne 0x18bee
leaq 0x10(%rsp), %rsi
movl %r15d, (%rsi)
movl %ebp, 0x4(%rsi)
movq %r14, %rdi
callq 0x184c8
cmpq %r12, %rax
jne 0x18bee
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18558
imulq $0x18, %r13, %rdi
addq (%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x478c
movl (%r14), %eax
imulq $0x18, %rax, %rdi
addq (%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x478c
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/graph_t.cc
// Function: graph_t::remove_edge(unsigned int, unsigned int)
void graph_t::remove_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    edge_set.erase(edge);
    edge = make_pair(dst, src);
    edge_set.erase(edge);
    
    vector<node_id_t>& v1 = nodes_vec[src].nbrs_vec;
    vector<node_id_t>& v2 = nodes_vec[dst].nbrs_vec;
    v1.erase(std::remove(v1.begin(), v1.end(), dst), v1.end());
    v2.erase(std::remove(v2.begin(), v2.end(), src), v2.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, 0x8(%rsp)
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %r14d
movq %r14, %rax
shlq $0x20, %rax
movl %esi, %r12d
orq %r12, %rax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1868a
movl %ebp, (%r13)
movl %r15d, 0x4(%r13)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1868a
movq 0x8(%rsp), %rax
movq (%rax), %r13
imulq $0x18, %r12, %r12
leaq (%r12,%r13), %rbx
imulq $0x18, %r14, %r14
leaq (%r14,%r13), %r15
movq (%r13,%r12), %rdi
movq 0x8(%r13,%r12), %rsi
movq %rsp, %rdx
callq 0x18854
movq 0x8(%r13,%r12), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x182aa
movq (%r13,%r14), %rdi
movq 0x8(%r13,%r14), %rsi
leaq 0x4(%rsp), %rdx
callq 0x18854
movq 0x8(%r13,%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x182aa
addq $0x18, %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/graph_t.cc
// Function: graph_t::init_size(unsigned long)
void graph_t::init_size(size_t num_nodes)
{
    nodes_vec.resize(num_nodes);
    node_to_muc_vec.resize(num_nodes);
    fill(node_to_muc_vec.begin(), node_to_muc_vec.end(), INF);
    i_init_internals();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x19ce6
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1141a
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x18cfe
movl $0x5f5e100, (%rax)      # imm = 0x5F5E100
addq $0x4, %rax
jmp 0x18ced
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18d0e
nop