LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1dfcc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5be8
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
cmpq %rdx, %rdi
je 0xaa87
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x2110
cmpl $-0x1, %ebp
je 0xaab8
movq %r14, %rdi
callq 0x1dfcc
cmpl %ebp, %eax
cmovll %eax, %ebp
testl %ebp, %ebp
je 0xab0c
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0xab3f
incl %r15d
cmpl %r15d, %ebp
jne 0xaaa0
jmp 0xab0c
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1dfcc
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0xaada
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xab3f
incl %ebp
jmp 0xaaba
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0xab0c
sarq $0x3, %rcx
xorl %edx, %edx
movsd 0x25544(%rip), %xmm0    # 0x30038
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
movl %edx, %esi
cmpq %rsi, %rcx
ja 0xaaf4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab20
jmp 0xab20
jmp 0xab20
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xab37
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2250
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x4(%rsp), %rax
leaq 0x7(%rsp), %r10
leaq 0x6(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x5(%rsp), %r9
movl $0xa, %esi
pushq %rax
pushq %r10
callq 0xddfc
addq $0x10, %rsp
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0xb1fc
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x28(%rsp), %r12
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movl %r13d, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xdf0c
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r13
sarq $0x3, %rax
imulq %rbp, %rax
cmpq %r13, %rax
ja 0xb1c9
movl 0x8(%rsp), %ebp
cmpl $-0x1, %ebp
je 0xb235
movq %r14, %rdi
callq 0x1dfcc
cmpl %ebp, %eax
cmovll %eax, %ebp
testl %ebp, %ebp
je 0xb2ad
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0xb2da
incl %r15d
cmpl %r15d, %ebp
jne 0xb21d
jmp 0xb2ad
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x1dfcc
movl %ebp, %ecx
cmpq %rcx, %rax
jbe 0xb257
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xb2da
incl %ebp
jmp 0xb237
movl $0x0, 0x10(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0xb2ad
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd8ce
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd8ce
movsd 0x8(%rsp), %xmm0
mulsd 0x24d9f(%rip), %xmm0    # 0x30038
movsd %xmm0, (%rax)
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cmpq %rax, 0x18(%rbx)
ja 0xb26b
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb2c7
jmp 0xb2c7
jmp 0xb2c7
jmp 0xb2c7
movq %rax, %r14
movq %rbx, %rdi
callq 0xd912
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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)
xorl %eax, %eax
movq %rax, 0x40(%rsp)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x1dfcc
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0xd848
movq %r15, %rdi
callq 0x1dfcc
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd848
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
cmpq %rdx, %rdi
je 0xb9bf
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
cmpq %rdx, %rdi
je 0xb9e7
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x1e698
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x1e698
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x1dfcc
movl %r12d, %r12d
cmpq %r12, %rax
jbe 0xba49
movq 0x30(%rsp), %rax
movl (%rax,%r12,4), %r8d
movq 0x10(%rsp), %rax
movl (%rax,%r12,4), %r9d
cmpl %r9d, %r8d
je 0xba44
movq %rbx, (%rsp)
movq %r15, %rdi
movl %r12d, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xbabf
incl %r12d
jmp 0xba09
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xba60
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xba77
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xba86
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xbaa0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xbab7
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%rsp), %rax
leaq 0x5(%rsp), %r10
leaq 0x4(%rsp), %rdx
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
leaq 0x3(%rsp), %r9
movl $0xa, %esi
pushq %rax
pushq %r10
callq 0xddfc
addq $0x10, %rsp
xorpd %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d358
movq 0x8(%r14), %rax
movq (%rax), %r15
movq %rax, %r12
cmpl $-0x1, %ebp
je 0xd333
testq %r15, %r15
jne 0xd2e8
movq %rax, %r12
movq 0x8(%r12), %r15
addq $0x8, %r12
testq %r15, %r15
je 0xd2da
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r15
je 0xd37b
xorl %r13d, %r13d
movl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd403
incl %r13d
cmpl %ebp, %r13d
je 0xd37b
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xd323
movq 0x8(%r12), %r15
addq $0x8, %r12
jmp 0xd313
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r15
jne 0xd2f9
jmp 0xd37b
testq %r15, %r15
jne 0xd371
movq %rax, %r12
movq 0x8(%r12), %r15
addq $0x8, %r12
testq %r15, %r15
je 0xd33b
jmp 0xd371
movl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd403
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0xd36d
movq 0x8(%r12), %r15
addq $0x8, %r12
jmp 0xd35d
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r15
jne 0xd34b
cmpl $-0x1, %ebp
jne 0xd3da
movq 0x8(%rbx), %rdx
movq (%rdx), %rcx
movq %rdx, %rax
testq %rcx, %rcx
jne 0xd39f
movq %rdx, %rax
movq 0x8(%rax), %rcx
addq $0x8, %rax
testq %rcx, %rcx
je 0xd392
movq 0x10(%rbx), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq %rdx, %rcx
je 0xd3da
movsd 0x22c84(%rip), %xmm0    # 0x30038
movsd 0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rcx)
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xd3d5
movq 0x8(%rax), %rcx
addq $0x8, %rax
jmp 0xd3c6
cmpq %rdx, %rcx
jne 0xd3b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd3f0
jmp 0xd3f0
movq %rax, %r14
movq %rbx, %rdi
callq 0xd912
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1c4e6
leaq 0x215db(%rip), %rdi     # 0x301cb
callq 0x2350
movq 0x8(%rbx), %rax
movq (%rax), %r13
movq %rax, %r12
testq %r13, %r13
jne 0xec15
movq %rax, %r12
movq 0x8(%r12), %r13
addq $0x8, %r12
testq %r13, %r13
je 0xec07
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
je 0xec97
leaq 0x2159a(%rip), %r14     # 0x301c0
leaq 0x2159a(%rip), %r15     # 0x301c7
movl (%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x8(%r13), %rax
cmpq %rax, 0x10(%r13)
je 0xec6b
xorl %ebp, %ebp
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %rbp
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0xec47
movl $0xa, %edi
callq 0x22f0
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0xec89
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0xec79
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
jne 0xec2d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf78c
movl %r8d, %r10d
movl %edx, %eax
jmp 0xf796
movl %r9d, %r10d
movl %r8d, %r9d
movl %ecx, %eax
movl %edx, %ecx
subl %r9d, %r10d
cmpl $0x1, %r10d
jne 0xf7b4
pushq %rax
movq 0x10(%rsp), %rdx
movq %rdx, (%rsp)
movl %ecx, %edx
movl %eax, %ecx
callq 0x100fa
popq %rax
retq
movl %ecx, %edx
movl %eax, %ecx
jmp 0x10a7c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
xorl %eax, %eax
movq %rax, 0x70(%rsp)
movq %rax, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x1dfcc
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0xd848
movq %r14, %rdi
callq 0x1dfcc
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0xd848
movq %r14, %rdi
callq 0x1dfcc
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xd848
movq %r14, %rdi
callq 0x1dfcc
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1527c
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rdx
cmpq %rdx, %rdi
je 0x143a4
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2110
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rdx
cmpq %rdx, %rdi
je 0x143cc
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
cmpq %rdx, %rdi
je 0x143f4
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
cmpq %rdx, %rdi
je 0x1441b
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
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 0x144e4
addq $0x10, %rsp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1445b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x14472
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x14489
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x144a0
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x144c4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x27c9
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x151a9
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x146c2
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x1524b
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movabsq $-0x303030303030303, %r12 # imm = 0xFCFCFCFCFCFCFCFD
xorl %r13d, %r13d
addq %r15, %rdi
callq 0x1c4e0
cmpq $0x2, %rax
jne 0x15227
movq 0x10(%rsp), %rax
movq 0x48(%rax,%r15), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1521c
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x15227
movq %rbx, %rdi
movq %r14, %rdx
callq 0x16d4c
incq %r13
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x2a8, %r15            # imm = 0x2A8
cmpq %r13, %rax
ja 0x151e2
leaq 0x10(%rsp), %rdi
callq 0x15702
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x15267
jmp 0x15267
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15702
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1917c(%rip), %xmm0    # 0x30030
divsd %xmm1, %xmm0
mulsd 0x19328(%rip), %xmm0    # 0x301e8
xorps %xmm1, %xmm1
cvtsi2sd %r8d, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %edi, 0xc(%rsp)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x16ef2
movq %rax, 0x8(%rbx)
cmpl $0x0, 0xc(%rsp)
jle 0x16fa2
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq $0x0, 0x10(%rsp)
callq 0x2070
movslq %eax, %r12
movq %r14, %rdi
callq 0x1dfcc
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
callq 0x2070
movslq %eax, %r13
movq %r14, %rdi
callq 0x1dfcc
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 0x1e644
testb %al, %al
jne 0x16f0d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r15, %rdx
callq 0x1b3f6
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
jne 0x16f0d
cmpq 0x10(%rbx), %rax
je 0x16f8b
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x16f96
movq %rbx, %rdi
movq %r15, %rdx
callq 0x16d4c
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x16f04
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x30(%rsp)
movq %rsi, %r14
movl %edi, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x1518c
movq 0x18(%rsp), %r13
subq 0x10(%rsp), %r13
shrq $0x3, %r13
testl %r13d, %r13d
jle 0x17034
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0x10(%rsp), %rax
movl (%rax,%rbx,8), %ecx
movl 0x4(%rax,%rbx,8), %eax
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b4d0
incq %rbx
cmpq %rbx, %r13
jne 0x1700a
movq 0x30(%rsp), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x17046
movq %rax, 0x8(%rcx)
cmpl $0x0, 0xc(%rsp)
jle 0x170eb
movl 0x58(%r14), %r13d
xorl %ebp, %ebp
movq %rsp, %r15
movq $0x0, (%rsp)
movq 0x48(%r14), %r12
callq 0x2070
cltd
idivl %r13d
movslq %edx, %rbx
testl %ebx, %ebx
jle 0x17096
movq %r12, %rdi
callq 0x2290
movq %rax, %r12
decq %rbx
jne 0x17076
jmp 0x17098
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
incq %rbx
jne 0x17088
movq 0x20(%r12), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
callq 0x1b3f6
cmpq 0x18(%rsp), %rax
jne 0x17062
movq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x170d7
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x170df
movq %r15, %rdx
callq 0x16d4c
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x1705a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17102
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17117
jmp 0x17117
jmp 0x17117
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x17131
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdx)
callq 0x1d15a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c1c6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x90(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d2aa
leaq 0xc0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d2aa
leaq 0xf0(%rbx), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1d2aa
leaq 0x120(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d358
leaq 0x150(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d358
leaq 0x1b0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d358
leaq 0x1e0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d358
leaq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d2aa
leaq 0x210(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d41a
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c285
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x8(%rsp)
movl %edx, 0xc(%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 0x1d614
movq %rax, %r12
leaq 0x38(%rbx), %rax
cmpq %rax, %r12
jne 0x1c408
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1d614
cmpq %r12, %rax
jne 0x1c408
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x1d672
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1c28e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c28e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x126b8
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1c3c7
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1c3d4
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
callq 0x6f14
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x126b8
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1c3fb
movl 0x8(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1c408
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x6f14
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %r15
movl %esi, (%r15)
leaq 0x4(%rsp), %rbx
movl %edx, (%rbx)
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
leaq 0x30(%rdi), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1d7b2
movq %r13, %rdi
movq %rax, %rsi
callq 0x1d87e
movl (%rbx), %eax
movl (%r15), %ecx
movl %eax, (%r12)
movl %ecx, 0x4(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1d7b2
movq %r13, %rdi
movq %rax, %rsi
callq 0x1d87e
movq %r14, %rdi
movq %r15, %rsi
callq 0x126b8
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x126b8
movq %rax, %r14
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x1d923
cmpq 0x8(%r15), %rax
je 0x1c4b8
movq %rax, 0x8(%r15)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsp, %rdx
callq 0x1d923
cmpq 0x8(%r14), %rax
je 0x1c4d1
movq %rax, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x146b2(%rip), %rdi     # 0x30baf
callq 0x2350
movq 0x48(%rbx), %r14
leaq 0x38(%rbx), %r12
cmpq %r12, %r14
je 0x1c538
leaq 0x1467b(%rip), %r15     # 0x30b91
movl 0x20(%r14), %esi
movl 0x24(%r14), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x2290
movq %rax, %r14
cmpq %r12, %rax
jne 0x1c516
testb %bpl, %bpl
je 0x1c5ef
leaq 0x1466f(%rip), %rdi     # 0x30bb7
callq 0x2350
movq 0x8(%rbx), %rax
movq (%rax), %r13
movq %rax, %r12
testq %r13, %r13
jne 0x1c56d
movq %rax, %r12
movq 0x8(%r12), %r13
addq $0x8, %r12
testq %r13, %r13
je 0x1c55f
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
je 0x1c5ef
leaq 0x14622(%rip), %r14     # 0x30ba0
leaq 0x14624(%rip), %r15     # 0x30ba9
movl (%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x8(%r13), %rax
cmpq %rax, 0x10(%r13)
je 0x1c5c3
xorl %ebp, %ebp
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %rbp
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x1c59f
movl $0xa, %edi
callq 0x22f0
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0x1c5e1
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0x1c5d1
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
jne 0x1c585
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d614
addq $0x38, %r15
cmpq %r15, %rax
jne 0x1c646
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d614
cmpq %r14, %rax
je 0x1c652
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x1c648
// File: /workspace/github_cpp_makefile_star2_O3/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 0x48(%rsi), %r15
addq $0x38, %rbx
cmpq %rbx, %r15
je 0x1cf78
movq %rdi, %r14
movl 0x20(%r15), %esi
movl 0x24(%r15), %edx
movq %r14, %rdi
callq 0x1c320
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1cf58
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movl %edx, %eax
movq %rax, 0x10(%rsp)
shlq $0x20, %rax
movl %esi, %r13d
orq %r13, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x1d614
movq %rax, %r12
leaq 0x38(%r14), %rax
cmpq %rax, %r12
jne 0x1dd61
leaq 0x8(%rsp), %rsi
movl %ebp, (%rsi)
movl %ebx, 0x4(%rsi)
movq %r15, %rdi
callq 0x1d614
cmpq %r12, %rax
jne 0x1dd61
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1d672
movq (%r14), %rax
leaq (,%r13,2), %rcx
addq %r13, %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1dd28
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
movq 0x10(%rsp), %rcx
jmp 0x1dd39
movq %rsp, %r15
movq %r15, %rdx
callq 0x6f14
movl (%r15), %ecx
movq (%r14), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1dd57
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1dd61
leaq 0x4(%rsp), %rdx
callq 0x6f14
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, 0x8(%rsp)
leaq 0xc(%rsp), %rbx
movl %edx, (%rbx)
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x30(%rdi), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d7b2
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d87e
movl (%rbx), %eax
movl 0x8(%rsp), %ecx
movl %eax, (%r15)
movl %ecx, 0x4(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d7b2
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d87e
movl 0x8(%rsp), %eax
movq (%r14), %r15
leaq (%rax,%rax,2), %r12
movl (%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %r14
movq (%r15,%r12,8), %rdi
movq 0x8(%r15,%r12,8), %rsi
movq %rbx, %rdx
callq 0x1d923
cmpq 0x8(%r15,%r12,8), %rax
je 0x1de0c
leaq (%r15,%r12,8), %rcx
movq %rax, 0x8(%rcx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1d923
cmpq 0x8(%r14), %rax
je 0x1de27
movq %rax, 0x8(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f770
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1527c
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x1df62
subq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, %xmm0
shrq $0x2, %rcx
addq $0x4, %rcx
andq $-0x4, %rcx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x2, %xmm0
xorl %edx, %edx
movdqa 0x122e4(%rip), %xmm1    # 0x30170
movdqa 0x122ec(%rip), %xmm2    # 0x30180
movdqa 0x122f4(%rip), %xmm3    # 0x30190
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x1deee
movl $0x5f5e100, (%rax,%rdx,4) # imm = 0x5F5E100
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x1df05
movl $0x5f5e100, 0x4(%rax,%rdx,4) # imm = 0x5F5E100
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x1df42
movl $0x5f5e100, 0x8(%rax,%rdx,4) # imm = 0x5F5E100
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1df55
movl $0x5f5e100, 0xc(%rax,%rdx,4) # imm = 0x5F5E100
addq $0x4, %rdx
cmpq %rdx, %rcx
jne 0x1dea4
movq 0x8(%rbx), %rax
subq (%rbx), %rax
leaq 0x90(%rbx), %rdi
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
xorl %edx, %edx
callq 0x96c4
movb $0x0, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %r15, %rdi
movl $0x8, %edx
callq 0x2150
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x38(%rsp,%rax)
jne 0x1e0ff
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2100
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2100
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1de34
cmpq $0x0, 0x8(%rsp)
je 0x1e0ac
xorl %r13d, %r13d
leaq 0x18(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x23a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x23a0
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rax
cmpq %rsi, %rax
jbe 0x1e0a2
movl (%rsp), %edx
cmpq %rdx, %rax
jbe 0x1e0a2
movq %rbx, %rdi
callq 0x1dc86
incq %r13
cmpq %r13, 0x8(%rsp)
ja 0x1e06e
leaq 0x18(%rsp), %rdi
callq 0x2050
movq 0x8(%rbx), %rax
subq (%rbx), %rax
leaq 0x90(%rbx), %rdi
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
xorl %edx, %edx
callq 0x96c4
movb $0x0, 0xb8(%rbx)
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 0x12ac6(%rip), %rdi     # 0x30bcf
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x22c0
jmp 0x1e11e
jmp 0x1e11e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d614
movq %rax, %r14
addq $0x38, %r15
movb $0x1, %al
cmpq %r15, %r14
jne 0x1e68e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d614
cmpq %r14, %rax
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ad0
movq 0x30(%r15), %rcx
movq 0x40(%r15), %rax
addq $-0x4, %rax
cmpq %rax, %rcx
je 0x1e6fa
movl %ebp, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x50(%rsp)
jmp 0x1e712
leaq 0x20(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x75be
movl 0x4(%rsp), %ebp
movq 0x50(%rsp), %rcx
movl %ebp, %eax
movq (%rbx), %rdx
movl $0x0, (%rdx,%rax,4)
movq 0x30(%rsp), %rax
cmpq %rax, %rcx
je 0x1e833
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movl (%rax), %ebp
movq 0x40(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x1e74a
addq $0x4, %rax
jmp 0x1e77c
movq 0x38(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2250
movq 0x48(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x30(%rsp)
leaq (,%rbp,2), %rsi
addq %rbp, %rsi
shlq $0x3, %rsi
addq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6112
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
cmpq %rdi, %rax
je 0x1e811
xorl %r15d, %r15d
movl (%rdi,%r15,4), %ecx
movl %ecx, (%rsp)
movq (%rbx), %rdx
cmpl $-0x1, (%rdx,%rcx,4)
jne 0x1e7ff
movl (%rdx,%rbp,4), %esi
incl %esi
movl %esi, (%rdx,%rcx,4)
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rdx
addq $-0x4, %rdx
cmpq %rdx, %rcx
je 0x1e7ea
movl (%rsp), %edx
movl %edx, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x50(%rsp)
jmp 0x1e7ff
movq %r12, %rdi
movq %r13, %rsi
callq 0x75be
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
incq %r15
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x1e7af
testq %rdi, %rdi
je 0x1e823
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x30(%rsp), %rax
cmpq %rax, 0x50(%rsp)
jne 0x1e734
leaq 0x20(%rsp), %rdi
callq 0x690a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e84e
movq %rax, %rbx
jmp 0x1e86d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1e86d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x20(%rsp), %rdi
callq 0x690a
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x538, %rsp            # imm = 0x538
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0xa(%rsp), %rax
leaq 0xc(%rsp), %r10
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %r13
leaq 0x18(%rsp), %rcx
leaq 0xd(%rsp), %r8
leaq 0xb(%rsp), %r9
movl $0xa, %esi
movq %r13, %rdx
pushq %rax
pushq %r10
callq 0x6748
addq $0x10, %rsp
leaq 0x98(%rsp), %r15
movq %r15, %rdi
callq 0x152ae
leaq 0x340(%rsp), %rdi
callq 0x6192
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x130da
cmpl $-0x1, %r14d
jne 0x1eb5e
movq %r15, %rdi
callq 0x1c4e0
movq %rax, %r14
leaq 0xe(%rsp), %rax
leaq 0x18(%rsp), %rdi
leaq 0xb(%rsp), %rdx
leaq 0xd(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0xa(%rsp), %r9
movl $0xa, %esi
pushq %rax
pushq %r13
callq 0xddfc
addq $0x10, %rsp
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x1d358
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x2360
leaq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl %r14d, %edx
callq 0x139d2
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2360
xorps %xmm0, %xmm0
cvtsi2sdq -0x10(%rbx), %xmm0
cvtsi2sdq -0x8(%rbx), %xmm1
movsd 0x115bf(%rip), %xmm2    # 0x301a0
divsd %xmm2, %xmm1
cvtsi2sdq (%rbx), %xmm3
cvtsi2sdq 0x8(%rbx), %xmm4
addsd %xmm0, %xmm1
divsd %xmm2, %xmm4
addsd %xmm3, %xmm4
subsd %xmm1, %xmm4
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
divsd %xmm0, %xmm4
movq 0x10(%rsp), %rax
movsd %xmm4, (%rax)
leaq 0x18(%rsp), %rdi
callq 0xd912
leaq 0x340(%rsp), %rdi
callq 0x63d2
movq %r15, %rdi
callq 0x15650
leaq 0x68(%rsp), %rdi
callq 0x6858
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ec6e
movq %rax, %rbx
movq %r15, %rdi
callq 0x15650
jmp 0x1ec62
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6858
jmp 0x1ec8a
movq %rax, %rbx
jmp 0x1ec80
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd912
leaq 0x68(%rsp), %rdi
callq 0x1f7ce
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ed8c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xaa33
movq 0xc0(%rbx), %rdi
movq 0xd0(%rbx), %rsi
movaps (%r14), %xmm0
movups %xmm0, 0xc0(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0xd0(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x1ed1b
subq %rdi, %rsi
callq 0x2250
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ed1b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0xc0(%rbx), %rax
cmpq %rax, 0xc8(%rbx)
je 0x1ed78
leaq 0xd8(%rbx), %r14
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movsd (%rax,%r13,8), %xmm0
movl %r13d, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xdf0c
incq %r13
movq 0xc0(%rbx), %rax
movq 0xc8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x1ed3d
movb $0x1, 0xb8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop