LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x10580
movq 0x28(%rsp), %rdi
leaq 0xbc(%rsp), %rsi
callq 0x105b0
jmp 0x5745e
movq 0xb0(%rsp), %rdi
movl 0xbc(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl $0x0, (%rax)
leaq 0x60(%rsp), %rdi
callq 0x105e0
movb %al, 0x1f(%rsp)
jmp 0x5748a
movb 0x1f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x57499
jmp 0x575ca
leaq 0x60(%rsp), %rdi
callq 0x10600
movq %rax, 0x10(%rsp)
jmp 0x574aa
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x10610
jmp 0x574c1
movq 0x20(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x566f0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x10b20
jmp 0x574de
movl $0x0, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xfd50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x575bb
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xfbc0
movl (%rax), %eax
movl %eax, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0xfc50
cmpl $-0x1, (%rax)
jne 0x575a9
movq 0xb0(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl (%rax), %eax
incl %eax
movl %eax, 0x4(%rsp)
movq 0xb0(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x105b0
jmp 0x5757d
jmp 0x575a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x575dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x10520
jmp 0x575dc
jmp 0x575ab
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x574e6
leaq 0x38(%rsp), %rdi
callq 0x10520
jmp 0x5747a
leaq 0x60(%rsp), %rdi
callq 0x10620
addq $0xc8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x10620
movq 0x58(%rsp), %rdi
callq 0x9cf0
// File: 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:
subq $0x588, %rsp            # imm = 0x588
movq %rdi, 0x580(%rsp)
movl %esi, 0x57c(%rsp)
movl %edx, 0x578(%rsp)
movq %rcx, 0x570(%rsp)
movl %r8d, 0x56c(%rsp)
movq 0x580(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x58ad0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x57c(%rsp), %edx
movl 0x578(%rsp), %ecx
callq 0x3d9d0
jmp 0x578e8
cmpl $-0x1, 0x56c(%rsp)
jne 0x57927
leaq 0xa8(%rsp), %rdi
callq 0x52790
movq %rax, 0x18(%rsp)
jmp 0x57906
movq 0x18(%rsp), %rax
movl %eax, 0x56c(%rsp)
jmp 0x57927
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x57a2f
leaq 0x35(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2d1e0
movq 0x10(%rsp), %r8
leaq 0x38(%rsp), %rdi
movl $0xa, %esi
leaq 0x37(%rsp), %rdx
leaq 0x36(%rsp), %rcx
callq 0x2d1f0
jmp 0x57956
leaq 0x35(%rsp), %rdi
callq 0x2d230
leaq 0xa8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x53d40
jmp 0x57977
leaq 0x548(%rsp), %rdi
callq 0x2d430
jmp 0x57986
movl 0x56c(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3e650
jmp 0x5799e
leaq 0x548(%rsp), %rdi
callq 0x2d450
jmp 0x579ad
leaq 0x548(%rsp), %rdi
callq 0x2d470
movsd %xmm0, 0x8(%rsp)
jmp 0x579c2
movsd 0x8(%rsp), %xmm0
cvtsi2sdl 0x56c(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x570(%rsp), %rax
movsd %xmm0, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x2d420
leaq 0x78(%rsp), %rdi
callq 0x58bb0
addq $0x588, %rsp            # imm = 0x588
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x35(%rsp), %rdi
callq 0x2d230
jmp 0x57a2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2d420
leaq 0x78(%rsp), %rdi
callq 0x58bb0
movq 0x70(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0xb8(%rax)
jne 0x57b4c
movq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x28720
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
leaq 0x58(%rsp), %rsi
callq 0x58bf0
leaq 0x58(%rsp), %rdi
callq 0xfa50
movl $0x0, 0x54(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x54(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xc0, %rdi
callq 0xfa10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x57b40
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0xd8, %rax
movq %rax, (%rsp)
addq $0xc0, %rdi
movslq 0x54(%rsp), %rsi
callq 0xfa30
movq %rax, %rsi
leaq 0x54(%rsp), %rdi
callq 0x58c30
movl %eax, 0x30(%rsp)
movsd %xmm0, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2d2d0
movq (%rsp), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x2d260
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x57aac
movq 0x10(%rsp), %rax
movb $0x1, 0xb8(%rax)
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/iter_info_t.cc
// Function: iter_info_t::init_all(unsigned long)
void iter_info_t::init_all(size_t N)
{
    fill_vec<vector<node_id_t> >(P, N, vector<node_id_t>());
    fill_vec<int>(sigma_vec, N, 0);
    fill_vec<int>(dist_vec, N, -1);
    fill_vec<int>(sigma_inc_vec, N, 0);
    
    fill_vec<double>(delta_vec, N, 0);
    fill_vec<double>(Delta_vec, N, 0);

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

// Assembly:
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, 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 0x21900
jmp 0x59968
leaq 0x30(%rsp), %rdi
callq 0x10520
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x59aa0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x48(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x59aa0
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x59aa0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movq 0x48(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0xfbe0
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
movq 0x48(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0xfbe0
movq 0x8(%rsp), %rdi
addq $0xd8, %rdi
movq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0x21e50
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x10a50
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
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/unit_tests.h
// Function: fill_test_graph(graph_t&)
void fill_test_graph(graph_t& graph)
{
    graph.init_size(20);
    graph.insert_edge(0,1);
    graph.insert_edge(1,2);
    graph.insert_edge(2,3);
    graph.insert_edge(3,0);
    graph.insert_edge(0,4);
    graph.insert_edge(4,5);
    graph.insert_edge(5,6);
    graph.insert_edge(6,7);
    graph.insert_edge(7,8);
    graph.insert_edge(8,4);
    graph.insert_edge(5,9);
    graph.insert_edge(9,8);
    graph.insert_edge(3,10);
    graph.insert_edge(10,11);
    graph.insert_edge(11,12);
    graph.insert_edge(12,13);
    graph.insert_edge(13,14);
    graph.insert_edge(14,15);
    graph.insert_edge(15,10);
    graph.insert_edge(2,16);
    graph.insert_edge(16,17);
    graph.insert_edge(17,18);
    graph.insert_edge(2,19);
}

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

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movb $0x0, 0x1c7(%rsp)
leaq 0x2200a(%rip), %rdi     # 0x7bcf0
xorl %eax, %eax
callq 0x9040
leaq 0x98(%rsp), %rdi
callq 0x5eda0
leaq 0x77(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x9d00
movq 0x20(%rsp), %rdx
leaq 0x21ff5(%rip), %rsi     # 0x7bd0a
leaq 0x78(%rsp), %rdi
callq 0x5ef00
jmp 0x59d21
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x56b50
jmp 0x59d35
leaq 0x78(%rsp), %rdi
callq 0x9410
leaq 0x77(%rsp), %rdi
callq 0x97d0
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa00
movq 0x18(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0xa2d0
jmp 0x59d6c
leaq 0x30(%rsp), %rdi
leaq 0x98(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x28720
jmp 0x59d85
movb $0x1, 0x1c7(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xfa10
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x59e61
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
callq 0xfa30
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x30(%rsp), %rdi
callq 0xfa30
movsd 0x8(%rsp), %xmm0
subsd (%rax), %xmm0
movsd 0x21ee3(%rip), %xmm1    # 0x7bcd8
ucomisd %xmm1, %xmm0
jbe 0x59e4f
movb $0x0, 0x1c7(%rsp)
jmp 0x59e4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x59e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x9410
leaq 0x77(%rsp), %rdi
callq 0x97d0
jmp 0x59eed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x59ee3
jmp 0x59e51
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x59d95
testb $0x1, 0x1c7(%rsp)
je 0x59e97
leaq 0x21ea8(%rip), %rdi     # 0x7bd1a
xorl %eax, %eax
callq 0x9040
jmp 0x59e7b
jmp 0x59ea9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfa50
jmp 0x59ee3
leaq 0x21e84(%rip), %rdi     # 0x7bd22
xorl %eax, %eax
callq 0x9040
jmp 0x59ea7
jmp 0x59ea9
movb 0x1c7(%rsp), %al
movb %al, 0x7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfa50
leaq 0x48(%rsp), %rdi
callq 0xfa50
leaq 0x98(%rsp), %rdi
callq 0x5efc0
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x1c8, %rsp            # imm = 0x1C8
retq
leaq 0x48(%rsp), %rdi
callq 0xfa50
leaq 0x98(%rsp), %rdi
callq 0x5efc0
movq 0x68(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/qube.cc
// Function: shared_vertex(muc_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
bool shared_vertex(muc_t& muc, cycle_t& cycle)
{
    bool res = false;
    for(int i = 0; i < cycle.size(); ++i) {
        if(   muc.muc_subgraph.nodes_map.find(cycle[i].first) != muc.muc_subgraph.nodes_map.end() 
           || muc.muc_subgraph.nodes_map.find(cycle[i].second) != muc.muc_subgraph.nodes_map.end())
            return true;
    }
    return res;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movb $0x0, 0x6f(%rsp)
movl $0x0, 0x68(%rsp)
movslq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
callq 0x47680
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x66414
movq 0x78(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x4dbc0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x53f90
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x78(%rsp), %rdi
addq $0x60, %rdi
callq 0x2d710
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d6f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x663ee
movq 0x78(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x4dbc0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0x53f90
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x78(%rsp), %rdi
addq $0x60, %rdi
callq 0x2d710
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2d6f0
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x663f8
jmp 0x66402
movb $0x1, 0x87(%rsp)
jmp 0x66421
jmp 0x66404
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x662fe
movb 0x6f(%rsp), %al
andb $0x1, %al
movb %al, 0x87(%rsp)
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/qube.cc
// Function: shared_vertex(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
bool shared_vertex(cycle_t& c1, cycle_t& c2)
{
   bool res = false;
    for(int i = 0; i < c1.size(); ++i) {
        for(int j = 0; j < c2.size(); ++j) {
            if(   c1[i].first   == c2[j].first
               || c1[i].first   == c2[j].second
               || c1[i].second  == c2[j].first
               || c1[i].second  == c2[j].second) {
                return true;
            }
        }
    }
    return res;    
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movl $0x0, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x47680
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x6659a
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x47680
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x66588
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4dbc0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
je 0x6656f
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4dbc0
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl 0x4(%rcx), %eax
je 0x6656f
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movl 0x4(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4dbc0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
je 0x6656f
movq 0x38(%rsp), %rdi
movslq 0x28(%rsp), %rsi
callq 0x4dbc0
movl 0x4(%rax), %eax
movl %eax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4dbc0
movq %rax, %rcx
movl (%rsp), %eax
cmpl 0x4(%rcx), %eax
jne 0x66576
movb $0x1, 0x47(%rsp)
jmp 0x665a4
jmp 0x66578
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x66488
jmp 0x6658a
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x6645b
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: fjamour[P]icentral/src/qube.cc
// Function: graph_t::merge_muc_cycle(muc_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void graph_t::merge_muc_cycle(muc_t& muc, cycle_t& cycle)
{
    for(int i = 0; i < cycle.size(); ++i) {
        node_id_t src, dst;
        src = cycle[i].first;
        dst = cycle[i].second;
        muc.muc_subgraph.insert_edge(src, dst);
        node_to_muc_vec[src] = muc.id;
        node_to_muc_vec[dst] = muc.id;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x47680
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x6801d
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4dbc0
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4dbc0
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rdi
addq $0x60, %rdi
movl 0x28(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x52420
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x308(%rax), %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0xfbc0
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rdi
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movl 0x308(%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0xfbc0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x67f55
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/qube.cc
// Function: muc_t::insert_conn_vertex(unsigned int, unsigned int)
void muc_t::insert_conn_vertex(node_id_t id, node_id_t nbr) {
    if(conn_vertex_map.find(id) != conn_vertex_map.end()) {
        conn_vertex_map[id].push_back(nbr);
    } else {
        vector<node_id_t> vec;
        vec.push_back(nbr);
        conn_vertex_map.insert(make_pair(id, vec));
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movl %edx, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xbc(%rsp), %rsi
callq 0x6e740
movq 0x10(%rsp), %rdi
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
callq 0x6e3c0
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x6e3a0
testb $0x1, %al
jne 0x680bc
jmp 0x680e3
movq 0x10(%rsp), %rdi
leaq 0xbc(%rsp), %rsi
callq 0x2d980
movq %rax, %rdi
leaq 0xb8(%rsp), %rsi
callq 0xfce0
jmp 0x681c8
leaq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xfcd0
movq 0x8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xfce0
jmp 0x68109
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0xbc(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x54750
jmp 0x6812e
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x32ec0
jmp 0x6813f
movq (%rsp), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x54720
jmp 0x68154
leaq 0x50(%rsp), %rdi
callq 0x32f10
leaq 0x30(%rsp), %rdi
callq 0x32f30
leaq 0x80(%rsp), %rdi
callq 0x10520
jmp 0x681c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x681b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x681af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x32f10
leaq 0x30(%rsp), %rdi
callq 0x32f30
leaq 0x80(%rsp), %rdi
callq 0x10520
jmp 0x681d0
addq $0xc8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x9cf0
nopw (%rax,%rax)
// File: fjamour[P]icentral/src/qube.cc
// Function: graph_t::get_num_mucs()
size_t graph_t::get_num_mucs()
{
    size_t res = 0;
    for(int i = 0; i < muc_vec.size(); ++i) {
        if(muc_vec[i].valid) {
            ++res;
        }
    }
    return res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rax
movq %rax, (%rsp)
addq $0x60, %rdi
callq 0x6e040
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x68b70
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4dcb0
testb $0x1, 0x30c(%rax)
je 0x68b61
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x68b63
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x68b14
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::insert_edge(unsigned int, unsigned int)
void subgraph_t::insert_edge(node_id_t src, node_id_t dst)
{
    edge_t e1, e2;
    e1.first   = src;
    e1.second  = dst;
    e2.first   = dst;
    e2.second  = src;
    if(edge_set.find(e1) != edge_set.end() || edge_set.find(e2) != edge_set.end())
        return;
    else
        edge_set.insert(e1);
    nodes_vec[src].push_back(dst);
    nodes_vec[dst].push_back(src);
}

// Assembly:
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 $0x18, %rdi
leaq 0x50(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x18, %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 0x771b4
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x48(%rsp), %rsi
callq 0x540e0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x18, %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 0x771be
jmp 0x771c0
jmp 0x77216
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x50(%rsp), %rsi
callq 0x54150
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x100e0
movq %rax, %rdi
leaq 0x58(%rsp), %rsi
callq 0xfce0
movq 0x8(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x100e0
movq %rax, %rdi
leaq 0x5c(%rsp), %rsi
callq 0xfce0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::print_graph(bool)
void subgraph_t::print_graph(bool with_nodes)
{
    printf("Edges: \n");
    for(set<edge_t >::iterator it = edge_set.begin(); it != edge_set.end(); it++) {
        printf("[%d] === [%d]\n", it->first, it->second);
    }
    if(with_nodes) {
        printf("Nodes with edge lists: \n");
        for(int i = 0; i < nodes_vec.size(); ++i) {
            printf("[%d]\t-- ", i);
            for(int j = 0; j < nodes_vec[i].size(); j++) {
                printf("[%d] ", nodes_vec[i][j]);
            }
            printf("\n");
        }
    }
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x47c3(%rip), %rdi      # 0x7bc26
movb $0x0, %al
callq 0x9040
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x420d0
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x54120
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x774a5
jmp 0x774e7
leaq 0x40(%rsp), %rdi
callq 0x54350
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x54350
movl 0x1c(%rsp), %esi
movl 0x4(%rax), %edx
leaq 0x4762(%rip), %rdi      # 0x7bc2f
movb $0x0, %al
callq 0x9040
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x54370
movq %rax, 0x30(%rsp)
jmp 0x7747d
testb $0x1, 0x4f(%rsp)
je 0x775ce
leaq 0x4745(%rip), %rdi      # 0x7bc3e
movb $0x0, %al
callq 0x9040
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x1ac90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x775cc
movl 0x2c(%rsp), %esi
leaq 0x471f(%rip), %rdi      # 0x7bc57
movb $0x0, %al
callq 0x9040
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x2c(%rsp), %rsi
callq 0x100e0
movq %rax, %rdi
callq 0xfd50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x775ae
movq 0x20(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x100e0
movq %rax, %rdi
movslq 0x28(%rsp), %rsi
callq 0xfbc0
movl (%rax), %esi
leaq 0x46c6(%rip), %rdi      # 0x7bc60
movb $0x0, %al
callq 0x9040
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x77547
leaq 0x486d(%rip), %rdi      # 0x7be22
movb $0x0, %al
callq 0x9040
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x77508
jmp 0x775ce
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::find_sssp(unsigned int, std::vector<int, std::allocator<int>>&)
void subgraph_t::find_sssp(node_id_t s, vector<int>& out_vec)
{
    out_vec.clear();
    i_fill_map<int>(out_vec, -1);
    queue<node_id_t> Q;
    Q.push(s);
    out_vec[s] = 0;
    while(!Q.empty()) {
        node_id_t v = Q.front(); Q.pop();
        vector<node_id_t> nbr_vec = get_nbrs(v);
        for(int i = 0; i < nbr_vec.size(); ++i) {
            node_id_t nbr = nbr_vec[i];
            if(out_vec[nbr] == -1) {
                out_vec[nbr] = out_vec[v] + 1;
                Q.push(nbr);
            }
        }
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x543e0
movq 0x20(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x78300
leaq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x10580
movq 0x28(%rsp), %rdi
leaq 0xbc(%rsp), %rsi
callq 0x105b0
jmp 0x77b52
movq 0xb0(%rsp), %rdi
movl 0xbc(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl $0x0, (%rax)
leaq 0x60(%rsp), %rdi
callq 0x105e0
movb %al, 0x1f(%rsp)
jmp 0x77b7e
movb 0x1f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x77b8d
jmp 0x77cbe
leaq 0x60(%rsp), %rdi
callq 0x10600
movq %rax, 0x10(%rsp)
jmp 0x77b9e
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x10610
jmp 0x77bb5
movq 0x20(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x76f50
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x10b20
jmp 0x77bd2
movl $0x0, 0x34(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xfd50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x77caf
movslq 0x34(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xfbc0
movl (%rax), %eax
movl %eax, 0x30(%rsp)
movq 0xb0(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0xfc50
cmpl $-0x1, (%rax)
jne 0x77c9d
movq 0xb0(%rsp), %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl (%rax), %eax
incl %eax
movl %eax, 0x4(%rsp)
movq 0xb0(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0xfc50
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x105b0
jmp 0x77c71
jmp 0x77c9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x77cd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x10520
jmp 0x77cd0
jmp 0x77c9f
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x77bda
leaq 0x38(%rsp), %rdi
callq 0x10520
jmp 0x77b6e
leaq 0x60(%rsp), %rdi
callq 0x10620
addq $0xc8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x10620
movq 0x58(%rsp), %rdi
callq 0x9cf0
nopw %cs:(%rax,%rax)
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::find_pruning_counts_exp(unsigned int, unsigned int, int&, int&, int&)
void subgraph_t::find_pruning_counts_exp(node_id_t src,
                                        node_id_t dst,
                                        int& d0_cnt,
                                        int& d1_cnt,
                                        int& d2_cnt)
{
    vector<int> d_src_vec, d_dst_vec;
    find_sssp(src, d_src_vec);
    find_sssp(dst, d_dst_vec);
    d0_cnt = 0;
    d1_cnt = 0;
    d2_cnt = 0;
    for(int i = 0; i < nodes_vec.size(); ++i) {
        node_id_t s = i;
        int diff = d_src_vec[s] - d_dst_vec[s];
        int abs_diff = abs(diff);
        switch(abs_diff) {
            case 0:  d0_cnt++; break;
            case 1:  d1_cnt++; break;
            default: d2_cnt++;
        }
    }
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movl %edx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movq %r9, 0x70(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfc40
leaq 0x40(%rsp), %rdi
callq 0xfc40
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl 0x8c(%rsp), %esi
callq 0x77ae0
jmp 0x77d5d
movq 0x10(%rsp), %rdi
movl 0x88(%rsp), %esi
leaq 0x40(%rsp), %rdx
callq 0x77ae0
jmp 0x77d75
movq 0x80(%rsp), %rax
movl $0x0, (%rax)
movq 0x78(%rsp), %rax
movl $0x0, (%rax)
movq 0x70(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1ac90
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x77e8a
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
callq 0xfc50
movl (%rax), %eax
movl %eax, (%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xfc50
movq %rax, %rcx
movl (%rsp), %eax
movl (%rcx), %ecx
subl %ecx, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x77e4d
jmp 0x77e1e
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x77e5e
jmp 0x77e6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xfc70
leaq 0x58(%rsp), %rdi
callq 0xfc70
jmp 0x77ea6
movq 0x80(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x77e78
movq 0x78(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x77e78
movq 0x70(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x77e7a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x77da1
leaq 0x40(%rsp), %rdi
callq 0xfc70
leaq 0x58(%rsp), %rdi
callq 0xfc70
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x9cf0
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::fill_graph(graph_hash_t&)
void subgraph_t::fill_graph(graph_hash_t& g)
{       
    nodes_vec.clear();
    edge_set.clear();
    
    inout_label_map.clear(); // maps internal labels to original
    outin_label_map.clear(); // original labels to internal    

    nodes_vec.resize(g.size());
    inout_label_map.resize(g.size());
    int cnt = 0;
    for(graph_hash_t::nodes_map_t::iterator it = g.nodes_map.begin();
            it != g.nodes_map.end();
            ++it) {
        inout_label_map[cnt] = it->first;
        outin_label_map.insert(make_pair(it->first, cnt));
        cnt++;
    }
    for(set<edge_t>::iterator it = g.edge_set.begin();
            it != g.edge_set.end();
            ++it) {
        node_id_t src, dst;
        src = outin_label_map[it->first];
        dst = outin_label_map[it->second];
        insert_edge(src, dst);
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x78490
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
callq 0x784b0
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
callq 0x10a50
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
callq 0x161f0
movq 0x98(%rsp), %rdi
callq 0x52790
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x10040
movq 0x20(%rsp), %rax
addq $0x48, %rax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rdi
callq 0x52790
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x415e0
movl $0x0, 0x94(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2d6b0
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rdi
callq 0x2d710
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2d6f0
testb $0x1, %al
jne 0x77f9f
jmp 0x78047
leaq 0x80(%rsp), %rdi
callq 0x2d750
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x48, %rdi
movslq 0x94(%rsp), %rsi
callq 0xfbc0
movl 0x14(%rsp), %edx
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl %edx, (%rcx)
addq $0x60, %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2d750
movq %rax, %rdi
leaq 0x94(%rsp), %rsi
callq 0x784f0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x78520
movq 0x18(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x784c0
movl 0x94(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x94(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2d760
jmp 0x77f6d
movq 0x98(%rsp), %rdi
addq $0x30, %rdi
callq 0x420d0
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %rdi
addq $0x30, %rdi
callq 0x54120
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x540c0
testb $0x1, %al
jne 0x78088
jmp 0x78104
movq 0x20(%rsp), %rax
addq $0x60, %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x54350
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xfab0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x34(%rsp)
addq $0x60, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x54350
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x4, %rsi
callq 0xfab0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
callq 0x770e0
leaq 0x40(%rsp), %rdi
callq 0x4e340
jmp 0x7805d
addq $0xa8, %rsp
retq
nopl (%rax)
// File: fjamour[P]icentral/src/subgraph_t.cc
// Function: subgraph_t::fill_graph(graph_t&)
void subgraph_t::fill_graph(graph_t& g)
{       
    nodes_vec.clear();
    edge_set.clear();
    
    inout_label_map.clear(); // maps internal labels to original
    outin_label_map.clear(); // original labels to internal    

    nodes_vec.resize(g.size());
    for(node_id_t i = 0; i < g.size(); ++i) {
        nodes_vec[i] = g.nodes_vec[i].nbrs_vec;
    } 
    edge_set = g.edge_set;
    
    inout_label_map.resize(size());
    for(node_id_t i = 0; i < size(); ++i) {
        outin_label_map.insert(make_pair(i, i));
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x78490
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x784b0
movq 0x30(%rsp), %rdi
addq $0x48, %rdi
callq 0x10a50
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
callq 0x161f0
movq 0x68(%rsp), %rdi
callq 0x56b40
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x10040
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rdi
callq 0x56b40
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x781d5
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x42020
movq 0x30(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x100e0
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0xfd70
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x78176
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x30, %rsi
addq $0x18, %rdi
callq 0x6ea40
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0x48, %rax
movq %rax, 0x18(%rsp)
callq 0x77430
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x415e0
movl $0x0, 0x60(%rsp)
movq 0x30(%rsp), %rdi
movl 0x60(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0x77430
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x78287
movq 0x30(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rsi
movq %rsi, %rdi
callq 0x41730
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x194b0
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x784c0
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x78217
addq $0x78, %rsp
retq
nopl (%rax)
// File: fjamour[P]icentral/src/utility.cc
// Function: extract_graph_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string extract_graph_name(string path)
{
    string out;
    int pos = path.rfind("/") + 1;
    int length = path.length() - pos + 1;
    out = path.substr(pos, length);
    return out;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x9a10
movq 0x10(%rsp), %rdi
leaq 0x3593(%rip), %rsi      # 0x7bfa8
movq $-0x1, %rdx
callq 0x9c60
movq %rax, 0x18(%rsp)
jmp 0x78a28
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
incl %eax
movl %eax, 0x50(%rsp)
callq 0x9b10
movq 0x10(%rsp), %rsi
movl 0x50(%rsp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, 0x40(%rsp)
movslq 0x50(%rsp), %rdx
movslq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %rdi
callq 0x9750
jmp 0x78a64
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x98e0
leaq 0x20(%rsp), %rdi
callq 0x9410
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x78aac
jmp 0x78aa3
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x9410
jmp 0x78ab6
movq (%rsp), %rdi
callq 0x9410
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x9cf0
// File: sidscrazy[P]Paxos/paxos_tester.cpp
// Function: run_paxos(int, int)
std::chrono::duration<double> run_paxos (int n, int p){
	std::chrono::duration<double> total;
	for (int i = 0; i < ATTEMPTS; i++) {
		auto start = std::chrono::system_clock::now();
		PaxosController *pc  = new PaxosController(n, p);
		pc->end_simulation ();
		auto end = std::chrono::system_clock::now();
		std::chrono::duration<double> diff = end-start;
		pc->clear_memory ();
		delete pc;
		total += diff;
		std::cout << "cur avg "  << (total / (i + 1)).count () << " seconds." << std::endl;
	}

	return (total / ATTEMPTS );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xf, -0x1c(%rbp)
jge 0x2951
callq 0x2040
movq %rax, -0x28(%rbp)
movl $0xc8, %edi
callq 0x2230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3020
jmp 0x285c
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3670
callq 0x2040
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3720
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3770
movq -0x30(%rbp), %rdi
callq 0x37b0
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x28bd
movq -0x78(%rbp), %rdi
callq 0x3940
movq -0x78(%rbp), %rdi
callq 0x2210
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3990
movq 0xb707(%rip), %rdi      # 0xdfd8
leaq 0x6788(%rip), %rsi      # 0x9060
callq 0x2220
movq %rax, -0x80(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x39d0
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3a20
movq -0x80(%rbp), %rdi
callq 0x23c0
movq %rax, %rdi
leaq 0x6751(%rip), %rsi      # 0x9069
callq 0x2220
movq %rax, %rdi
movq 0xb699(%rip), %rsi      # 0xdfc0
callq 0x2240
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2828
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x2210
jmp 0x2978
movl $0xf, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x39d0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: sidscrazy[P]Paxos/./paxos_controller.cpp
// Function: PaxosController::end_simulation()
void end_simulation (){
		int status;
		char buf[1024];
		for (int i = 0; i < nodes ; i++){
			threads[i].join ();
			waitpid (children[i], &status, 0);
		}
		log->CloseLogFile ();
		//std::cout << "Simulation Complete" << std::endl;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
movl $0x0, -0x414(%rbp)
movq -0x420(%rbp), %rcx
movl -0x414(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jge 0x36f9
movq -0x420(%rbp), %rdi
addq $0x30, %rdi
movslq -0x414(%rbp), %rsi
callq 0x4240
movq %rax, %rdi
callq 0x2370
movq -0x420(%rbp), %rdi
movslq -0x414(%rbp), %rsi
callq 0x40c0
movl (%rax), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x21b0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x3694
movq -0x420(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x7e10
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sidscrazy[P]Paxos/./paxos_controller.cpp
// Function: PaxosController::clear_memory()
void clear_memory (){
		children.erase (children.begin (), children.end ());
		sockets.erase (sockets.begin (), sockets.end ());
		threads.erase (threads.begin (), threads.end ());
		mutexes.clear ();
		delete log;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6b60
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6b90
movq -0x90(%rbp), %rdi
callq 0x6bd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b90
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6ad0
movq -0x90(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xa0(%rbp)
addq $0x18, %rdi
callq 0x6b60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6b90
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x6bd0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6b90
movq -0xa0(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x6ad0
movq -0x90(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x98(%rbp)
addq $0x30, %rdi
callq 0x6c90
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6cc0
movq -0x90(%rbp), %rdi
addq $0x30, %rdi
callq 0x6d00
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6cc0
movq -0x98(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x6c00
movq -0x90(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x48, %rdi
callq 0x6d30
movq -0x90(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x3928
movq -0x88(%rbp), %rdi
callq 0x7d50
movq -0x88(%rbp), %rdi
callq 0x2210
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: cdalitz[P]kdtree-cpp/demo_kdtree.cpp
// Function: print_nodes(std::vector<Kdtree::KdNode, std::allocator<Kdtree::KdNode>> const&)
void print_nodes(const Kdtree::KdNodeVector &nodes) {
  size_t i,j;
  for (i = 0; i < nodes.size(); ++i) {
    if (i > 0)
      cout << " ";
    cout << "(";
    for (j = 0; j < nodes[i].point.size(); j++) {
      if (j > 0)
        cout << ",";
      cout << nodes[i].point[j];
    }
    cout << ")";
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3780
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2408
cmpq $0x0, -0x10(%rbp)
jbe 0x234f
movq 0x12c85(%rip), %rdi     # 0x14fc8
leaq 0xbd24(%rip), %rsi      # 0xe06e
callq 0x2100
movq 0x12c72(%rip), %rdi     # 0x14fc8
leaq 0xbd0b(%rip), %rsi      # 0xe068
callq 0x2100
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37b0
movq %rax, %rdi
callq 0x37d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x23e4
cmpq $0x0, -0x18(%rbp)
jbe 0x23ad
movq 0x12c27(%rip), %rdi     # 0x14fc8
leaq 0xbc78(%rip), %rsi      # 0xe020
callq 0x2100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37b0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x37f0
movsd (%rax), %xmm0
movq 0x12bf7(%rip), %rdi     # 0x14fc8
callq 0x21b0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x236a
movq 0x12bdd(%rip), %rdi     # 0x14fc8
leaq 0xbe03(%rip), %rsi      # 0xe1f5
callq 0x2100
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2314
movq 0x12bb9(%rip), %rdi     # 0x14fc8
movq 0x12ba2(%rip), %rsi     # 0x14fb8
callq 0x2130
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)