LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fjamour[P]icentral/src/_bc.cc
// Function: fast_brandes_BC(graph_t&, std::vector<double, std::allocator<double>>&)
void fast_brandes_BC(
        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);
    
    iter_info_t iter_info;
    for(node_id_t s = 0; s < comp.subgraph.size(); ++s) {
        brandes_iter(BC_vec, comp, s, iter_info);
    }
}

// Assembly:
subq $0x3a8, %rsp            # imm = 0x3A8
movq %rdi, 0x3a0(%rsp)
movq %rsi, 0x398(%rsp)
movq 0x398(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x3a0(%rsp), %rdi
callq 0x56b40
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xf680
movq 0x398(%rsp), %rdi
callq 0xf760
movq %rax, 0x390(%rsp)
movq 0x398(%rsp), %rdi
callq 0xf790
movq %rax, 0x388(%rsp)
movq $0x0, 0x380(%rsp)
movq 0x390(%rsp), %rdi
movq 0x388(%rsp), %rsi
leaq 0x380(%rsp), %rdx
callq 0xf720
leaq 0x150(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xf7c0
movq 0x18(%rsp), %rdi
movl $0x2, 0x378(%rsp)
movq 0x3a0(%rsp), %rsi
callq 0x78110
jmp 0xa392
leaq 0x28(%rsp), %rdi
callq 0xf850
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, (%rsp)
leaq 0x150(%rsp), %rdi
callq 0x77430
movq %rax, 0x8(%rsp)
jmp 0xa3c0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
jae 0xa433
movq 0x398(%rsp), %rdi
movl 0x24(%rsp), %edx
leaq 0x150(%rsp), %rsi
leaq 0x28(%rsp), %rcx
callq 0xa470
jmp 0xa3ee
jmp 0xa3f0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa3a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0xa452
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf910
jmp 0xa452
leaq 0x28(%rsp), %rdi
callq 0xf910
leaq 0x150(%rsp), %rdi
callq 0xf9d0
addq $0x3a8, %rsp            # imm = 0x3A8
retq
leaq 0x150(%rsp), %rdi
callq 0xf9d0
movq 0x148(%rsp), %rdi
callq 0x9cf0
nopl (%rax)
// File: fjamour[P]icentral/src/_bc.cc
// Function: iCentral(std::vector<double, std::allocator<double>>&, component_t&, std::pair<unsigned int, unsigned int>, operation_t)
void iCentral(
        vector<double>& dBC_vec,
        component_t&    comp,
        edge_t          e,
        operation_t     op
        )
{
    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);
    iter_info_t iter_info;
    for(node_id_t s = 0; s < comp.subgraph.size(); ++s) {
        if(d_src_vec[s] != d_dst_vec[s]) {
            int dd = d_src_vec[s] - d_dst_vec[s]; //dd=d_v1-d_v2
            iCentral_iter(dBC_vec, comp, s, e, iter_info, dd, false ,op);
        }
    }
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, 0x1c0(%rsp)
movq %rdi, 0x1b8(%rsp)
movq %rsi, 0x1b0(%rsp)
movl %ecx, 0x1ac(%rsp)
movq 0x1b8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x1b0(%rsp), %rdi
callq 0x77430
movq 0x30(%rsp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
callq 0xfbe0
leaq 0x190(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xfc40
leaq 0x178(%rsp), %rdi
callq 0xfc40
movq 0x38(%rsp), %rdx
movq 0x1b0(%rsp), %rdi
movl 0x1c0(%rsp), %esi
callq 0x77ae0
jmp 0xaa4a
movq 0x1b0(%rsp), %rdi
movl 0x1c4(%rsp), %esi
leaq 0x178(%rsp), %rdx
callq 0x77ae0
jmp 0xaa68
leaq 0x50(%rsp), %rdi
callq 0xf850
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x1b0(%rsp), %rdi
callq 0x77430
movq %rax, 0x28(%rsp)
jmp 0xaa97
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jae 0xabb6
movl 0x4c(%rsp), %eax
movl %eax, %esi
leaq 0x190(%rsp), %rdi
callq 0xfc50
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %esi
leaq 0x178(%rsp), %rdi
callq 0xfc50
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
je 0xaba4
movl 0x4c(%rsp), %eax
movl %eax, %esi
leaq 0x190(%rsp), %rdi
callq 0xfc50
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %esi
leaq 0x178(%rsp), %rdi
callq 0xfc50
movq %rax, %rcx
movl 0x18(%rsp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
movl %eax, 0x48(%rsp)
movq 0x1b8(%rsp), %rdi
movq 0x1b0(%rsp), %rsi
movl 0x4c(%rsp), %edx
movq 0x1c0(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x48(%rsp), %r9d
movl 0x1ac(%rsp), %r8d
movq 0x40(%rsp), %rcx
movq %rsp, %rax
movl %r8d, 0x8(%rax)
movl $0x0, (%rax)
leaq 0x50(%rsp), %r8
callq 0xb4b0
jmp 0xab6c
jmp 0xaba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x170(%rsp)
movl %eax, 0x16c(%rsp)
jmp 0xabe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x170(%rsp)
movl %eax, 0x16c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xf910
jmp 0xabe2
jmp 0xaba6
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xaa7a
leaq 0x50(%rsp), %rdi
callq 0xf910
leaq 0x178(%rsp), %rdi
callq 0xfc70
leaq 0x190(%rsp), %rdi
callq 0xfc70
addq $0x1c8, %rsp            # imm = 0x1C8
retq
leaq 0x178(%rsp), %rdi
callq 0xfc70
leaq 0x190(%rsp), %rdi
callq 0xfc70
movq 0x170(%rsp), %rdi
callq 0x9cf0
nopl (%rax)
// File: fjamour[P]icentral/src/_bc.cc
// Function: iCentral_block(std::vector<double, std::allocator<double>>*, component_t*, std::pair<unsigned int, unsigned int>*, std::vector<unsigned int, std::allocator<unsigned int>>*, operation_t*)
void iCentral_block(
        vector<double>*     dBC_vec,
        component_t*        comp,
        edge_t*             e,
        vector<node_id_t>*  source_vec,
        operation_t*        op
        )
{
    fill_vec<double>(*dBC_vec, comp->subgraph.size(), 0.0);
    iter_info_t iter_info;
    for(int i = 0; i < source_vec->size(); ++i) {
        node_id_t s = (*source_vec)[i];
        iCentral_iter(*dBC_vec, *comp, s, *e, iter_info, -1, false, *op);
    }
}

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq %rcx, 0x168(%rsp)
movq %r8, 0x160(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x178(%rsp), %rdi
callq 0x77430
movq 0x20(%rsp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
callq 0xfbe0
leaq 0x48(%rsp), %rdi
callq 0xf850
movl $0x0, 0x44(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x168(%rsp), %rdi
callq 0xfd50
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xb76a
movq 0x168(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xfbc0
movl (%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x180(%rsp), %rdi
movq 0x178(%rsp), %rsi
movl 0x40(%rsp), %edx
movq 0x170(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x160(%rsp), %rax
movl (%rax), %r8d
movq 0x38(%rsp), %rcx
movq %rsp, %rax
movl %r8d, 0x8(%rax)
movl $0x0, (%rax)
leaq 0x48(%rsp), %r8
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
callq 0xb4b0
jmp 0xb73e
jmp 0xb740
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0xb6ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf910
jmp 0xb77c
leaq 0x48(%rsp), %rdi
callq 0xf910
addq $0x188, %rsp            # imm = 0x188
retq
movq 0x30(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq 0x268(%rsp), %rax
movq %rax, (%rsp)
movq 0x270(%rsp), %rdi
callq 0x56b40
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xf680
movq 0x268(%rsp), %rdi
callq 0xf760
movq %rax, 0x260(%rsp)
movq 0x268(%rsp), %rdi
callq 0xf790
movq %rax, 0x258(%rsp)
movq $0x0, 0x250(%rsp)
movq 0x260(%rsp), %rdi
movq 0x258(%rsp), %rsi
leaq 0x250(%rsp), %rdx
callq 0xf720
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf7c0
movq 0x8(%rsp), %rdi
movl $0x2, 0x248(%rsp)
movq 0x270(%rsp), %rsi
callq 0x78110
jmp 0xef3d
leaq 0x20(%rsp), %rdi
callq 0xf9d0
addq $0x278, %rsp            # imm = 0x278
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf9d0
movq 0x18(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rcx, 0x2b0(%rsp)
movq %rdi, 0x2a8(%rsp)
movq %rsi, 0x2a0(%rsp)
movl %edx, 0x29c(%rsp)
movq %r8, 0x290(%rsp)
cmpl $0x2, 0x29c(%rsp)
jne 0x1fc6f
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf7c0
movq 0x20(%rsp), %rdi
movl $0x2, 0x288(%rsp)
movq 0x2a0(%rsp), %rsi
callq 0x78110
jmp 0x1fb7a
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa00
movq 0x18(%rsp), %rdi
movq 0x2b0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x290(%rsp), %rcx
movq 0x30(%rsp), %rdx
leaq 0x60(%rsp), %rsi
callq 0x1fc90
jmp 0x1fbb4
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xfa10
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x1fc4d
movslq 0x2c(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xfa30
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x2a8(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xfa30
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fbbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1fc63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xfa50
jmp 0x1fc63
leaq 0x38(%rsp), %rdi
callq 0xfa50
leaq 0x60(%rsp), %rdi
callq 0xf9d0
jmp 0x1fc6f
leaq 0x60(%rsp), %rdi
callq 0xf9d0
jmp 0x1fc77
addq $0x2b8, %rsp            # imm = 0x2B8
retq
movq 0x58(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x90(%rsp), %rdi
callq 0x77430
movq 0x30(%rsp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
callq 0xfbe0
leaq 0x70(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xfc40
leaq 0x58(%rsp), %rdi
callq 0xfc40
movq 0x38(%rsp), %rdx
movq 0x90(%rsp), %rdi
movl 0xa0(%rsp), %esi
callq 0x77ae0
jmp 0x1fd15
movq 0x90(%rsp), %rdi
movl 0xa4(%rsp), %esi
leaq 0x58(%rsp), %rdx
callq 0x77ae0
jmp 0x1fd30
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rdi
callq 0x77430
movq %rax, 0x28(%rsp)
jmp 0x1fd55
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jae 0x1fe34
movl 0x48(%rsp), %eax
movl %eax, %esi
leaq 0x70(%rsp), %rdi
callq 0xfc50
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x48(%rsp), %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
callq 0xfc50
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
je 0x1fe22
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x21620
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %edx
movq %rax, %r8
movq 0x40(%rsp), %rcx
callq 0x1fe60
jmp 0x1fdfc
jmp 0x1fe22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xfc70
leaq 0x70(%rsp), %rdi
callq 0xfc70
jmp 0x1fe50
jmp 0x1fe24
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x1fd38
leaq 0x58(%rsp), %rdi
callq 0xfc70
leaq 0x70(%rsp), %rdi
callq 0xfc70
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x9cf0
nopw (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
movb $0x0, 0x93(%rsp)
callq 0xfa00
movq 0x98(%rsp), %rdi
callq 0x56b40
movq %rax, 0x48(%rsp)
jmp 0x2876c
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0xf680
jmp 0x2877d
movq 0x38(%rsp), %rdi
callq 0xf760
movq 0x38(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0xf790
movq %rax, 0x70(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xf720
jmp 0x287ba
cmpl $-0x1, 0x94(%rsp)
jne 0x288bd
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rdi
callq 0x56b40
movq %rax, 0x30(%rsp)
jmp 0x287ed
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq %rcx, %rax
jae 0x28846
movq 0x38(%rsp), %rdx
movq 0x98(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x28970
jmp 0x28814
jmp 0x28816
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x287d0
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0xfa50
jmp 0x28962
movl $0x0, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movl 0x60(%rsp), %eax
movq %rax, 0x20(%rsp)
callq 0xfa10
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x288bb
movq 0x38(%rsp), %rdi
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0xfa30
movq 0x38(%rsp), %rdi
movsd (%rax), %xmm0
movsd 0x52779(%rip), %xmm1    # 0x7b008
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x60(%rsp), %eax
movl %eax, %esi
callq 0xfa30
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x2884e
jmp 0x28939
movq 0x98(%rsp), %rdi
callq 0x56b40
movq %rax, 0x10(%rsp)
jmp 0x288d1
movq 0x10(%rsp), %rax
movl %eax, 0x58(%rsp)
leaq 0x94(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2d1a0
movq %rax, 0x8(%rsp)
jmp 0x288f3
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jae 0x28937
movq 0x38(%rsp), %rdx
movq 0x98(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x28970
jmp 0x28928
jmp 0x2892a
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x28906
jmp 0x28939
movb $0x1, 0x93(%rsp)
testb $0x1, 0x93(%rsp)
jne 0x28955
movq 0x38(%rsp), %rdi
callq 0xfa50
movq 0x40(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x9cf0
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x30, %rdi
xorl %esi, %esi
callq 0x527a0
leaq 0x4789b(%rip), %rdi     # 0x7b270
movb $0x0, %al
callq 0x9040
movq 0x10(%rsp), %rdi
callq 0x3acb0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10710
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10630
testb $0x1, %al
jne 0x33a1c
jmp 0x33ac0
leaq 0x30(%rsp), %rdi
callq 0x1e5f0
movl (%rax), %esi
leaq 0x4785e(%rip), %rdi     # 0x7b28d
movb $0x0, %al
callq 0x9040
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1e5f0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1eb00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x33aa3
leaq 0x30(%rsp), %rdi
callq 0x1e5f0
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0xfc50
movl (%rax), %esi
leaq 0x47805(%rip), %rdi     # 0x7b294
movb $0x0, %al
callq 0x9040
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x33a3e
leaq 0x48378(%rip), %rdi     # 0x7be22
movb $0x0, %al
callq 0x9040
leaq 0x30(%rsp), %rdi
callq 0x3acf0
jmp 0x339f0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x34b78
movl 0x28(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
subl 0x20(%rsp), %eax
cmpl $0x1, %eax
jne 0x34bb0
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x35790
jmp 0x34bd9
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x24(%rsp), %ecx
movl 0x20(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x36d20
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x42060
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x42080
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x40080
jmp 0x414e2
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x42090
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x415ba
movslq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x420b0
movq %rax, %rdi
callq 0x52790
movq %rax, (%rsp)
jmp 0x4152c
movq (%rsp), %rax
cmpq $0x2, %rax
jne 0x415a8
leaq 0x28(%rsp), %rdi
callq 0x41760
jmp 0x41542
movslq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x420b0
movq %rax, %rdi
addq $0x30, %rdi
callq 0x420d0
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x42100
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x41e30
jmp 0x4157b
movq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x42130
jmp 0x4158c
jmp 0x415a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x421a0
jmp 0x415c9
jmp 0x415aa
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x414ea
leaq 0x40(%rsp), %rdi
callq 0x421a0
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
movsd %xmm0, -0x8(%rsp)
movl %edi, -0xc(%rsp)
movl %esi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl -0xc(%rsp), %eax
addl -0x10(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x14(%rsp), %eax
addl -0x18(%rsp), %eax
movl %eax, -0x30(%rsp)
cvtsi2sdl -0xc(%rsp), %xmm1
cvtsi2sdl -0x14(%rsp), %xmm0
divsd %xmm0, %xmm1
mulsd -0x8(%rsp), %xmm1
cvtsi2sdl -0x2c(%rsp), %xmm0
cvtsi2sdl -0x30(%rsp), %xmm2
divsd %xmm2, %xmm0
mulsd %xmm0, %xmm1
movsd 0x3373b(%rip), %xmm0    # 0x7b010
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd 0x339b1(%rip), %xmm0    # 0x7b298
mulsd -0x28(%rsp), %xmm0
cvtsi2sdl -0x1c(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x42060
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x47a4e
leaq 0x44(%rsp), %rdi
callq 0x41760
callq 0x91a0
cltq
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x56b40
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x40(%rsp)
callq 0x91a0
cltq
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x56b40
movq %rax, %rcx
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x3c(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x57340
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x47a23
movq 0x50(%rsp), %rdi
callq 0x47550
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x473d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x44(%rsp), %rdx
callq 0x4db20
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x473d0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4dae0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x4794c
movq 0x50(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x42130
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x47934
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x60, %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfcd0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x53ab0
jmp 0x521c2
leaq 0x30(%rsp), %rdi
callq 0x10520
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x90, %rsi
xorl %edx, %edx
callq 0x53c40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0xc0, %rsi
xorl %edx, %edx
callq 0x53c40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0xf0, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x53c40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x120, %rsi            # imm = 0x120
xorps %xmm0, %xmm0
callq 0x53d40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x150, %rsi            # imm = 0x150
xorps %xmm0, %xmm0
callq 0x53d40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x1b0, %rsi            # imm = 0x1B0
xorps %xmm0, %xmm0
callq 0x53d40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x1e0, %rsi            # imm = 0x1E0
xorps %xmm0, %xmm0
callq 0x53d40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x180, %rsi            # imm = 0x180
xorl %edx, %edx
callq 0x53c40
movq 0x8(%rsp), %rdi
movq %rdi, %rsi
addq $0x210, %rsi            # imm = 0x210
xorl %edx, %edx
callq 0x53e60
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x10520
movq 0x28(%rsp), %rdi
callq 0x9cf0
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x41760
leaq 0x48(%rsp), %rdi
callq 0x41760
movq 0x8(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, 0x50(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x48(%rsp)
movl 0x5c(%rsp), %eax
movl %eax, 0x4c(%rsp)
addq $0x30, %rdi
leaq 0x50(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x540c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x524f4
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x48(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x540c0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x524fe
jmp 0x52500
jmp 0x52570
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x50(%rsp), %rsi
callq 0x54150
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movl 0x5c(%rsp), %esi
callq 0x522c0
movq 0x8(%rsp), %rdi
movl 0x58(%rsp), %esi
callq 0x522c0
movq 0x8(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x3afc0
movq %rax, %rdi
leaq 0x58(%rsp), %rsi
callq 0xfce0
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3afc0
movq %rax, %rdi
leaq 0x5c(%rsp), %rsi
callq 0xfce0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movl %edx, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, (%rsp)
leaq 0xac(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x41730
movq (%rsp), %rdi
movq %rax, 0xa0(%rsp)
addq $0x30, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x541b0
leaq 0xa8(%rsp), %rdi
leaq 0xac(%rsp), %rsi
callq 0x41730
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x541e0
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x541b0
movq (%rsp), %rdi
leaq 0xac(%rsp), %rsi
callq 0x3afc0
movq (%rsp), %rdi
movq %rax, 0x90(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0x3afc0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x90(%rsp), %rdi
callq 0x10cf0
movq %rax, 0x70(%rsp)
movq 0x90(%rsp), %rdi
callq 0x10d20
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x542b0
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x54310
movq 0x90(%rsp), %rdi
callq 0x10d20
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x54310
movq 0x8(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x54210
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
callq 0x10cf0
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0x10d20
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
leaq 0xac(%rsp), %rdx
callq 0x542b0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x54310
movq 0x88(%rsp), %rdi
callq 0x10d20
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x54310
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x54210
movq %rax, 0x18(%rsp)
addq $0xb8, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movb %sil, %al
movq %rdi, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x29463(%rip), %rdi     # 0x7bc26
movb $0x0, %al
callq 0x9040
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x420d0
movq %rax, 0x60(%rsp)
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x52805
jmp 0x52847
leaq 0x60(%rsp), %rdi
callq 0x54350
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x54350
movl 0xc(%rsp), %esi
movl 0x4(%rax), %edx
leaq 0x29402(%rip), %rdi     # 0x7bc2f
movb $0x0, %al
callq 0x9040
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x54370
movq %rax, 0x50(%rsp)
jmp 0x527dd
testb $0x1, 0x6f(%rsp)
je 0x52950
leaq 0x293e5(%rip), %rdi     # 0x7bc3e
movb $0x0, %al
callq 0x9040
movq 0x10(%rsp), %rdi
callq 0x2d6b0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2d710
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2d6f0
testb $0x1, %al
jne 0x528a0
jmp 0x5294e
leaq 0x40(%rsp), %rdi
callq 0x2d750
movl (%rax), %esi
leaq 0x293a4(%rip), %rdi     # 0x7bc57
movb $0x0, %al
callq 0x9040
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2d750
movq %rax, %rdi
addq $0x8, %rdi
callq 0xfd50
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52925
leaq 0x40(%rsp), %rdi
callq 0x2d750
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x2c(%rsp), %rsi
callq 0xfbc0
movl (%rax), %esi
leaq 0x2934f(%rip), %rdi     # 0x7bc60
movb $0x0, %al
callq 0x9040
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x528c2
leaq 0x294f6(%rip), %rdi     # 0x7be22
movb $0x0, %al
callq 0x9040
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x543b0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x52874
jmp 0x52950
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x41760
leaq 0x38(%rsp), %rdi
callq 0x41760
movq (%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0x40(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movb $0x0, 0x37(%rsp)
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x540e0
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x540c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x52a34
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x38(%rsp), %rsi
callq 0x540e0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x540c0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x52a3e
jmp 0x52a43
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0xe0(%rsp), %rdi
callq 0x3bb00
movq 0x50(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x53c40
leaq 0x90(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x10580
movq 0x58(%rsp), %rdi
leaq 0xec(%rsp), %rsi
callq 0x105b0
jmp 0x53475
movq 0xe0(%rsp), %rdi
leaq 0xec(%rsp), %rsi
callq 0x2d870
movq %rax, 0x48(%rsp)
jmp 0x53491
movq 0x48(%rsp), %rax
movl $0x0, (%rax)
leaq 0x90(%rsp), %rdi
callq 0x105e0
movb %al, 0x47(%rsp)
jmp 0x534af
movb 0x47(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x534be
jmp 0x5363b
leaq 0x90(%rsp), %rdi
callq 0x10600
movq %rax, 0x38(%rsp)
jmp 0x534d2
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x80(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x10610
jmp 0x534ef
movq 0x50(%rsp), %rdi
movl 0x80(%rsp), %esi
callq 0x52140
movq %rax, 0x30(%rsp)
jmp 0x53507
movq 0x30(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x10b20
jmp 0x53518
movl $0x0, 0x64(%rsp)
movslq 0x64(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xfd50
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x5362c
movslq 0x64(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0xfbc0
movl (%rax), %eax
movl %eax, 0x60(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2d870
movq %rax, 0x20(%rsp)
jmp 0x53573
movq 0x20(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x5361a
movq 0xe0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2d870
movq %rax, 0x18(%rsp)
jmp 0x5359d
movq 0x18(%rsp), %rax
movl (%rax), %eax
incl %eax
movl %eax, 0xc(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2d870
movq %rax, 0x10(%rsp)
jmp 0x535c3
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x105b0
jmp 0x535e2
jmp 0x5361a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x53650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x10520
jmp 0x53650
jmp 0x5361c
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x53520
leaq 0x68(%rsp), %rdi
callq 0x10520
jmp 0x5349c
leaq 0x90(%rsp), %rdi
callq 0x10620
addq $0xf8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x10620
movq 0x88(%rsp), %rdi
callq 0x9cf0
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0x420d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x536c3
jmp 0x536fa
leaq 0x20(%rsp), %rdi
callq 0x54350
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x54350
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x4(%rax), %edx
callq 0x52420
leaq 0x20(%rsp), %rdi
callq 0x4e340
jmp 0x5369b
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
leaq 0x4c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x41730
movq (%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x540e0
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x5678c
jmp 0x56791
jmp 0x56847
leaq 0x48(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x41730
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x541e0
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x540e0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x567f2
jmp 0x567f4
jmp 0x56847
movq (%rsp), %rdi
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x54150
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x42020
movq %rax, %rdi
leaq 0x48(%rsp), %rsi
callq 0xfce0
movq (%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x42020
movq %rax, %rdi
leaq 0x4c(%rsp), %rsi
callq 0xfce0
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x588d0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
callq 0x415e0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x10cf0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0x10d20
movq %rax, 0x18(%rsp)
movl $0x5f5e100, 0x14(%rsp)  # imm = 0x5F5E100
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x41680
movq 0x8(%rsp), %rdi
callq 0x56af0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x278, %rsp            # imm = 0x278
movq %rsi, 0x20(%rsp)
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq 0x270(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x9860
movq 0x20(%rsp), %rdi
callq 0x9250
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x9430
jmp 0x56ba6
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x60(%rsp,%rax), %rdi
callq 0x9c90
movb %al, 0x17(%rsp)
jmp 0x56bbf
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x56c0d
jmp 0x56bc9
movq 0x20(%rsp), %rdi
callq 0x9250
movq %rax, %rsi
leaq 0x25089(%rip), %rdi     # 0x7bc66
xorl %eax, %eax
callq 0x9040
jmp 0x56be6
movl $0x1, %edi
callq 0x98d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x9190
jmp 0x56ce3
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9a60
movq %rax, 0x8(%rsp)
jmp 0x56c23
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9a60
jmp 0x56c34
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x56a60
jmp 0x56c45
movl $0x0, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x56cb9
leaq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9070
movq %rax, (%rsp)
jmp 0x56c6e
movq (%rsp), %rdi
leaq 0x34(%rsp), %rsi
callq 0x9070
jmp 0x56c7e
movl 0x38(%rsp), %eax
cmpq 0x48(%rsp), %rax
jae 0x56caa
movl 0x34(%rsp), %eax
cmpq 0x48(%rsp), %rax
jae 0x56caa
movq 0x18(%rsp), %rdi
movl 0x38(%rsp), %esi
movl 0x34(%rsp), %edx
callq 0x56720
jmp 0x56ca8
jmp 0x56caa
jmp 0x56cac
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x56c4d
leaq 0x60(%rsp), %rdi
callq 0x9140
jmp 0x56cc5
movq 0x18(%rsp), %rdi
callq 0x56af0
jmp 0x56cd1
leaq 0x60(%rsp), %rdi
callq 0x9190
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x58(%rsp), %rdi
callq 0x9cf0
nopl (%rax)
// File: fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::print_mcbs()
void graph_t::print_mcbs()
{
    for(int c = 0; c < mcb.cycle_vec.size(); ++c) {
        printf("Cycle [%d]:\n", c);
        for(int e = 0; e < mcb.cycle_vec[c].size(); ++e) {
            printf("    [%d]===[%d]\n", mcb.cycle_vec[c][e].first, mcb.cycle_vec[c][e].second);
        }        
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x78, %rdi
callq 0x58970
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x56e8d
movl 0x2c(%rsp), %esi
leaq 0x24eb1(%rip), %rdi     # 0x7bc80
movb $0x0, %al
callq 0x9040
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x78, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x58990
movq %rax, %rdi
callq 0x47680
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x56e7b
movq 0x20(%rsp), %rdi
addq $0x78, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x58990
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x78, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x58990
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movl 0xc(%rsp), %esi
movl 0x4(%rax), %edx
leaq 0x24e29(%rip), %rdi     # 0x7bc8d
movb $0x0, %al
callq 0x9040
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x56dde
jmp 0x56e7d
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x56d9b
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x41760
movq 0x8(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x3c(%rsp)
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x540c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x57404
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x38(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x540c0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop