LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/bc.cc
// Function: brandes_bc_hash(graph_hash_t&, int)
brandes_bc_hash(graph_hash_t& graph_in, int max_iter)
{
    tr1_map_t(double) bc_vec;
    graph_in.i_fill_map<double>(bc_vec, 0);
    //means do all iterations
    if(max_iter == -1) {
        for(graph_hash_t::nodes_map_t::iterator it = graph_in.nodes_map.begin();
                it != graph_in.nodes_map.end(); 
                ++it) {
            node_id_t s = it->first;
            brandes_iter(graph_in, s, bc_vec);
        }
    } else {
        int cnt = 0;
        for(graph_hash_t::nodes_map_t::iterator it = graph_in.nodes_map.begin();
                it != graph_in.nodes_map.end(); 
                ++it) {
            node_id_t s = it->first;
            ++cnt;
            brandes_iter(graph_in, s, bc_vec);
            if(cnt == max_iter)
                break;
        }
    }
    
    if(max_iter == -1) {
        for(tr1_map_t(double)::iterator it = bc_vec.begin();
                it != bc_vec.end();
                ++it) {
            it->second = it->second/2;
        }
    }
    return bc_vec;    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%rsp), %rax
leaq 0x5(%rsp), %r10
leaq 0x4(%rsp), %rdx
leaq 0x7(%rsp), %rcx
leaq 0x6(%rsp), %r8
leaq 0x3(%rsp), %r9
movl $0xa, %esi
pushq %rax
pushq %r10
callq 0xddc0
addq $0x10, %rsp
xorpd %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d472
movq 0x8(%r14), %r15
movq (%r15), %r12
cmpl $-0x1, %ebp
je 0xd28e
testq %r12, %r12
jne 0xd2c8
movq 0x8(%r15), %r12
addq $0x8, %r15
jmp 0xd277
movq 0x8(%r15), %r12
addq $0x8, %r15
testq %r12, %r12
je 0xd286
jmp 0xd2b8
movl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd39a
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0xd2b8
movq 0x8(%r15), %r12
addq $0x8, %r15
jmp 0xd2a9
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r12
jne 0xd295
jmp 0xd312
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r12
je 0xd312
xorl %r13d, %r13d
movl (%r12), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd39a
incl %r13d
cmpl %ebp, %r13d
je 0xd312
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0xd304
movq 0x8(%r15), %r12
addq $0x8, %r15
jmp 0xd2f5
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
cmpq (%rax,%rcx,8), %r12
jne 0xd2d9
cmpl $-0x1, %ebp
jne 0xd371
movq 0x8(%rbx), %rdx
movq (%rdx), %rcx
movq %rdx, %rax
testq %rcx, %rcx
jne 0xd336
movq %rdx, %rax
movq 0x8(%rax), %rcx
addq $0x8, %rax
testq %rcx, %rcx
je 0xd329
movq 0x10(%rbx), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq %rdx, %rcx
je 0xd371
movsd 0x23ced(%rip), %xmm0    # 0x31038
movsd 0x8(%rcx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rcx)
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xd36c
movq 0x8(%rax), %rcx
addq $0x8, %rax
jmp 0xd35d
cmpq %rdx, %rcx
jne 0xd34b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd387
jmp 0xd387
movq %rax, %r14
movq %rbx, %rdi
callq 0xd8b4
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/bcc_delta.cc
// Function: bcc_delta_t::print()
void bcc_delta_t::print()
{
    bcc_subgraph.print_graph(false);
    printf("Art. point and graph sizes:\n");
    for(art_pt_map_t::iterator it = art_pt_map.begin();
        it != art_pt_map.end();
        ++it) {
        printf("[%d]: ", it->first);
        for(int i = 0; i < it->second.size(); ++i) {
            printf("%d ", it->second[i]);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1c632
leaq 0x22637(%rip), %rdi     # 0x311cb
callq 0x2350
movq 0x8(%rbx), %r12
movq (%r12), %r13
testq %r13, %r13
jne 0xebb1
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0xeba1
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
je 0xec37
leaq 0x225fa(%rip), %r14     # 0x311c0
leaq 0x225fa(%rip), %r15     # 0x311c7
movl (%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x8(%r13), %rax
cmpq %rax, 0x10(%r13)
je 0xec0b
xorl %ebp, %ebp
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %rbp
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0xebe7
movl $0xa, %edi
callq 0x22f0
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0xec29
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0xec19
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
jne 0xebcd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/bcc_delta.cc
// Function: bcc_delta_t::i_iteration(unsigned int, unsigned int, unsigned int, int, int, std::tr1::unordered_map<unsigned int, double, std::tr1::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::pair<unsigned int const, double>>>&)
void bcc_delta_t::i_iteration(node_id_t s,
                        node_id_t src,
                        node_id_t dst,
                        int d_src,
                        int d_dst,
                        tr1_map_t(double)& bc_vec)
{
    //make sure that @src is the closer to source node
    if(d_src > d_dst) {
        node_id_t       tmp_v;
        int             tmp_i;
        tmp_v = src; src = dst; dst = tmp_v;
        tmp_i = d_src; d_src = d_dst; d_dst = tmp_i;
    }
    
    if(d_dst - d_src == 1) {
        //dbg_iteration(s, src, dst, d_src, d_dst, bc_vec);
        i_iteration_1(s, src, dst, d_src, d_dst, bc_vec);
        //i_iteration_2(s, src, dst, d_src, d_dst, bc_vec);
    } else {
        //dbg_iteration(s, src, dst, d_src, d_dst, bc_vec);
        i_iteration_2(s, src, dst, d_src, d_dst, bc_vec);
    }
}

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
xorl %eax, %eax
movq %rax, 0x70(%rsp)
movq %rax, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x1e160
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0xd7da
movq %r14, %rdi
callq 0x1e160
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0xd7da
movq %r14, %rdi
callq 0x1e160
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xd7da
movq %r14, %rdi
callq 0x1e160
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1537c
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rdx
cmpq %rdx, %rdi
je 0x14478
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2110
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rdx
cmpq %rdx, %rdi
je 0x144a0
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
cmpq %rdx, %rdi
je 0x144c8
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
cmpq %rdx, %rdi
je 0x144ef
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
leaq 0x84(%rsp), %rax
leaq 0x60(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rsp, %r9
movq %r14, %rdi
xorl %esi, %esi
pushq %rbx
pushq %rax
callq 0x145b8
addq $0x10, %rsp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1452f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x14546
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1455d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x14574
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14598
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x27c9
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/bicon.cc
// Function: graph_t::find_bridge_edges(std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void graph_t::find_bridge_edges(vector<edge_t>& out_vec)
{
    out_vec.clear();
    
    vector<graph_hash_t> bcc_vec;
    find_bicon_comp(bcc_vec);
    
    for(int i = 0; i < bcc_vec.size(); ++i) {
        if(bcc_vec[i].size() == 2) {
            edge_t e;
            e = *bcc_vec[i].edge_set.begin();
            out_vec.push_back(e);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x1529b
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x147a2
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x1534a
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
movabsq $-0x303030303030303, %r12 # imm = 0xFCFCFCFCFCFCFCFD
xorl %r13d, %r13d
addq %r15, %rdi
callq 0x1c62c
cmpq $0x2, %rax
jne 0x15326
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x48(%rax,%r15), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1531b
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x15326
movq %rbx, %rdi
movq %r14, %rdx
callq 0x16e08
incq %r13
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x2a8, %r15            # imm = 0x2A8
cmpq %r13, %rax
ja 0x152d8
leaq 0x10(%rsp), %rdi
callq 0x15802
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x15366
jmp 0x15366
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15802
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/experiments.cc
// Function: fuad_ideal_speedup(double, int, int, int, int, int)
double fuad_ideal_speedup(double iter_frac,
        int BCC_n,
        int BCC_m,
        int G_n,
        int G_m,
        int inc_bfs_ratio)
{
   double res;
   int BCC_s = BCC_n + BCC_m;
   int G_s = G_n + G_m;
   res =  1.0/(((double)BCC_n/G_n) * iter_frac * ((double)BCC_s/G_s));
   res = res * 100.0/inc_bfs_ratio; 
   return res;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, 0xc(%rsp)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x16fae
movq %rax, 0x8(%rbx)
cmpl $0x0, 0xc(%rsp)
jle 0x1705e
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq $0x0, 0x10(%rsp)
callq 0x2070
movslq %eax, %r12
movq %r14, %rdi
callq 0x1e160
movq %rax, %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r12
callq 0x2070
movslq %eax, %r13
movq %r14, %rdi
callq 0x1e160
movq %rax, %rcx
movq %r13, %rax
xorl %edx, %edx
divq %rcx
movl %r12d, 0x10(%rsp)
movl %edx, 0x14(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e7bc
testb %al, %al
jne 0x16fc9
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r15, %rdx
callq 0x1b49c
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
jne 0x16fc9
cmpq 0x10(%rbx), %rsi
je 0x17047
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x17052
movq %rbx, %rdi
movq %r15, %rdx
callq 0x16e08
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x16fc0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/experiments.cc
// Function: gen_rand_edges_deletions(int, graph_t&, std::vector<std::pair<unsigned int, unsigned int>, std::allocator<std::pair<unsigned int, unsigned int>>>&)
void gen_rand_edges_deletions(int num_edges,
        graph_t& graph,
        vector<edge_t>& out_vec)
{
    vector<edge_t> bridges_vec;
    graph.find_bridge_edges(bridges_vec);
    //NOTE:insert each edge twice -- e(v1, v2) e(v2, v1)
    int num_bridges = bridges_vec.size();
    for(int i = 0; i < num_bridges; ++i) {
        bridges_vec.push_back(make_pair(bridges_vec[i].second, bridges_vec[i].first));
    }
    out_vec.clear();
    int num_edges_graph = graph.edge_set.size();
    set<edge_t>::const_iterator it(graph.edge_set.begin());
    for(int i = 0; i < num_edges; ++i) {
        edge_t rand_edge;
        do {
            //select an edge at random
            it = graph.edge_set.begin();
            advance(it, rand()%num_edges_graph);
            rand_edge = *it;
        } while(find(bridges_vec.begin(), bridges_vec.end(), rand_edge) != bridges_vec.end());
        out_vec.push_back(rand_edge);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movl %edi, 0xc(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x1527e
movq 0x18(%rsp), %r13
subq 0x10(%rsp), %r13
shrq $0x3, %r13
testl %r13d, %r13d
jle 0x170f0
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0x10(%rsp), %rax
movl (%rax,%rbx,8), %ecx
movl 0x4(%rax,%rbx,8), %eax
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b59e
incq %rbx
cmpq %rbx, %r13
jne 0x170c6
movq 0x30(%rsp), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x17102
movq %rax, 0x8(%rcx)
cmpl $0x0, 0xc(%rsp)
jle 0x171a7
movl 0x58(%r14), %r13d
xorl %ebp, %ebp
movq %rsp, %r15
movq $0x0, (%rsp)
movq 0x48(%r14), %r12
callq 0x2070
cltd
idivl %r13d
movslq %edx, %rbx
testl %ebx, %ebx
jle 0x17152
movq %r12, %rdi
callq 0x2290
movq %rax, %r12
decq %rbx
jne 0x17132
jmp 0x17154
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
incq %rbx
jne 0x17144
movq 0x20(%r12), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
callq 0x1b49c
cmpq 0x18(%rsp), %rax
jne 0x1711e
movq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x17193
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x1719b
movq %r15, %rdx
callq 0x16e08
incl %ebp
cmpl 0xc(%rsp), %ebp
jne 0x17116
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x171be
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x171d3
jmp 0x171d3
jmp 0x171d3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x171ed
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::init_maps()
void graph_hash_t::init_maps()
{
    i_fill_map<vector<node_id_t> >(P, vector<node_id_t>());
    i_fill_map<int>(path_cnt_vec, 0);
    i_fill_map<int>(new_path_cnt_vec, 0);
    i_fill_map<int>(dist_vec, -1);
    i_fill_map<double>(pair_dep_vec, 0);
    i_fill_map<double>(new_pair_dep_vec, 0);
    i_fill_map<double>(sigma_t_map, 0);
    i_fill_map<double>(new_sigma_t_map, 0);
    i_fill_map<int>(path_cnt_inc_vec, 0);
    i_fill_map<bool>(visited_vec, false);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x1d27c
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c2ce
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x90(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d3c8
leaq 0xc0(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d3c8
leaq 0xf0(%rbx), %rsi
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1d3c8
leaq 0x120(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d472
leaq 0x150(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d472
leaq 0x1b0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d472
leaq 0x1e0(%rbx), %rsi
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x1d472
leaq 0x180(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d3c8
leaq 0x210(%rbx), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1d530
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c38d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::insert_edge(unsigned int, unsigned int)
void graph_hash_t::insert_edge(node_id_t src, node_id_t dst)
{
    edge_t e1, e2;
    e1.first   = src;
    e1.second  = dst;
    e2.first   = dst;
    e2.second  = src;
    if(edge_set.find(e1) != edge_set.end() || edge_set.find(e2) != edge_set.end())
        return;
    else
        edge_set.insert(e1);
    
    insert_node(src);
    insert_node(dst);
    nodes_map[src].nbrs_vec.push_back(dst);
    nodes_map[dst].nbrs_vec.push_back(src);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
leaq 0x18(%rsp), %rax
movq $0x0, (%rax)
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movl %edx, 0x10(%rsp)
movl %esi, 0x14(%rsp)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d75a
leaq 0x38(%rbx), %r15
cmpq %r15, %rax
jne 0x1c52e
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x1d75a
cmpq %r15, %rax
jne 0x1c52e
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x1d7c2
leaq 0xc(%rsp), %r14
movl (%r14), %esi
movq %rbx, %rdi
callq 0x1c396
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x1c396
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12762
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1c4ed
movl 0x8(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1c4fa
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x6f98
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12762
movq 0x8(%rax), %rsi
cmpq 0x10(%rax), %rsi
je 0x1c521
movl 0xc(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rax)
jmp 0x1c52e
leaq 0xc(%rsp), %rdx
movq %rax, %rdi
callq 0x6f98
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::remove_edge(unsigned int, unsigned int)
void graph_hash_t::remove_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    edge_set.erase(edge);
    edge = make_pair(dst, src);
    edge_set.erase(edge);
    
    vector<node_id_t>& v1 = nodes_map[src].nbrs_vec;
    vector<node_id_t>& v2 = nodes_map[dst].nbrs_vec;
    v1.erase(std::remove(v1.begin(), v1.end(), dst), v1.end());
    v2.erase(std::remove(v2.begin(), v2.end(), src), v2.end());    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsp, %r15
movl %esi, (%r15)
leaq 0x4(%rsp), %rbx
movl %edx, (%rbx)
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
leaq 0x30(%rdi), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1d916
movq %r13, %rdi
movq %rax, %rsi
callq 0x1d9f0
movl (%rbx), %eax
movl (%r15), %ecx
movl %eax, (%r12)
movl %ecx, 0x4(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1d916
movq %r13, %rdi
movq %rax, %rsi
callq 0x1d9f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x12762
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12762
movq %rax, %r14
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x1da95
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x1c5ef
movq 0x8(%r15), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x1c5ef
movq %rax, 0x8(%r15)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsp, %rdx
callq 0x1da95
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x1c61d
movq 0x8(%r14), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x1c61d
movq %rax, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::print_graph(bool)
void graph_hash_t::print_graph(bool with_nodes)
{
    printf("Edges: \n");
    for(set<edge_t >::iterator it = edge_set.begin(); it != edge_set.end(); it++) {
        printf("[%d] === [%d]\n", it->first, it->second);
    }
    if(with_nodes) {
        printf("Nodes with edge lists: \n");
        for(tr1::unordered_map<node_id_t, node_t>::iterator it = nodes_map.begin(); it != nodes_map.end(); it++) {
            printf("[%d]\t-- ", it->first);
            for(int i = 0; i < it->second.nbrs_vec.size(); i++) {
                printf("[%d] ", it->second.nbrs_vec[i]);
            }
            printf("\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x15566(%rip), %rdi     # 0x31baf
callq 0x2350
movq 0x48(%rbx), %r14
leaq 0x38(%rbx), %r12
cmpq %r12, %r14
je 0x1c684
leaq 0x1552f(%rip), %r15     # 0x31b91
movl 0x20(%r14), %esi
movl 0x24(%r14), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x2290
movq %rax, %r14
cmpq %r12, %rax
jne 0x1c662
testb %bpl, %bpl
je 0x1c737
leaq 0x15523(%rip), %rdi     # 0x31bb7
callq 0x2350
movq 0x8(%rbx), %r12
movq (%r12), %r13
testq %r13, %r13
jne 0x1c6b1
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0x1c6a1
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
je 0x1c737
leaq 0x154da(%rip), %r14     # 0x31ba0
leaq 0x154dc(%rip), %r15     # 0x31ba9
movl (%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2030
movq 0x8(%r13), %rax
cmpq %rax, 0x10(%r13)
je 0x1c70b
xorl %ebp, %ebp
movl (%rax,%rbp,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2030
incq %rbp
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
ja 0x1c6e7
movl $0xa, %edi
callq 0x22f0
movq 0x20(%r13), %r13
testq %r13, %r13
jne 0x1c729
movq 0x8(%r12), %r13
addq $0x8, %r12
jmp 0x1c719
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq (%rax,%rcx,8), %r13
jne 0x1c6cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::has_edge(unsigned int, unsigned int)
bool graph_hash_t::has_edge(node_id_t src, node_id_t dst)
{
    edge_t e1,e2;
    e1.first    = src;
    e1.second   = dst;
    e2.first    = dst;
    e2.second   = src;
    bool res = false;
    if(   edge_set.find(e1) != edge_set.end()
       || edge_set.find(e2) != edge_set.end()) {
        res = true;
    }
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq $0x0, (%rax)
movl %esi, (%rax)
movl %edx, 0x4(%rax)
movl %edx, 0x8(%rsp)
movl %esi, 0xc(%rsp)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d75a
addq $0x38, %rbx
cmpq %rbx, %rax
jne 0x1c793
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1d75a
cmpq %rbx, %rax
je 0x1c79d
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x1c795
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_hash_t.cc
// Function: graph_hash_t::fill_graph(graph_t&)
void graph_hash_t::fill_graph(graph_t& g)
{
    for(set<edge_t>::iterator it = g.edge_set.begin();
            it != g.edge_set.end();
            ++it) {
        insert_edge(it->first, it->second);
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x48(%rsi), %r15
addq $0x38, %rbx
cmpq %rbx, %r15
je 0x1d09a
movq %rdi, %r14
movl 0x20(%r15), %esi
movl 0x24(%r15), %edx
movq %r14, %rdi
callq 0x1c440
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1d07a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::insert_edge(unsigned int, unsigned int)
void graph_t::insert_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    if(edge_set.find(edge) != edge_set.end())
        return;
    edge = make_pair(dst, src);
    if(edge_set.find(edge) != edge_set.end())
        return;
    edge_set.insert(edge);
    nodes_vec[src].nbrs_vec.push_back(dst);
    nodes_vec[dst].nbrs_vec.push_back(src);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
callq 0x1d75a
leaq 0x38(%rbx), %r15
cmpq %r15, %rax
jne 0x1ded0
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movq %r14, %rdi
callq 0x1d75a
cmpq %r15, %rax
jne 0x1ded0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1d7c2
movl 0x4(%rsp), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1de96
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1de9e
movq %rsp, %rdx
callq 0x6f98
movl (%rsp), %eax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1dec6
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1ded0
leaq 0x4(%rsp), %rdx
callq 0x6f98
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::remove_edge(unsigned int, unsigned int)
void graph_t::remove_edge(node_id_t src, node_id_t dst)
{
    pair<node_id_t, node_id_t> edge = make_pair(src, dst);
    edge_set.erase(edge);
    edge = make_pair(dst, src);
    edge_set.erase(edge);
    
    vector<node_id_t>& v1 = nodes_vec[src].nbrs_vec;
    vector<node_id_t>& v2 = nodes_vec[dst].nbrs_vec;
    v1.erase(std::remove(v1.begin(), v1.end(), dst), v1.end());
    v2.erase(std::remove(v2.begin(), v2.end(), src), v2.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, 0x8(%rsp)
leaq 0xc(%rsp), %rbx
movl %edx, (%rbx)
shlq $0x20, %rdx
movl %esi, %eax
orq %rdx, %rax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x30(%rdi), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d916
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d9f0
movl (%rbx), %eax
movl 0x8(%rsp), %ecx
movl %eax, (%r15)
movl %ecx, 0x4(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d916
movq %r12, %rdi
movq %rax, %rsi
callq 0x1d9f0
movl 0x8(%rsp), %eax
movq (%r14), %r15
leaq (%rax,%rax,2), %r12
movl (%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %r14
movq (%r15,%r12,8), %rdi
movq 0x8(%r15,%r12,8), %rsi
movq %rbx, %rdx
callq 0x1da95
movq 0x8(%r15,%r12,8), %rdx
cmpq %rdx, %rax
je 0x1df8b
leaq (%r15,%r12,8), %rcx
movq 0x8(%rcx), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
addq %rdi, %rax
cmpq %rax, %rsi
je 0x1df8b
movq %rax, 0x8(%rcx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1da95
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x1dfbb
movq 0x8(%r14), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x1dfbb
movq %rax, 0x8(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::init_size(unsigned long)
void graph_t::init_size(size_t num_nodes)
{
    nodes_vec.resize(num_nodes);
    node_to_muc_vec.resize(num_nodes);
    fill(node_to_muc_vec.begin(), node_to_muc_vec.end(), INF);
    i_init_internals();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1f8f4
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1537c
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x1e0f6
subq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, %xmm0
shrq $0x2, %rcx
addq $0x4, %rcx
andq $-0x4, %rcx
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
psrlq $0x2, %xmm0
xorl %edx, %edx
movdqa 0x13150(%rip), %xmm1    # 0x31170
movdqa 0x13158(%rip), %xmm2    # 0x31180
movdqa 0x13160(%rip), %xmm3    # 0x31190
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x1e082
movl $0x5f5e100, (%rax,%rdx,4) # imm = 0x5F5E100
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x1e099
movl $0x5f5e100, 0x4(%rax,%rdx,4) # imm = 0x5F5E100
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x1e0d6
movl $0x5f5e100, 0x8(%rax,%rdx,4) # imm = 0x5F5E100
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1e0e9
movl $0x5f5e100, 0xc(%rax,%rdx,4) # imm = 0x5F5E100
addq $0x4, %rdx
cmpq %rdx, %rcx
jne 0x1e038
movq 0x8(%rbx), %rax
subq (%rbx), %rax
leaq 0x90(%rbx), %rdi
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
xorl %edx, %edx
callq 0x96d2
movb $0x0, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::read_graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void graph_t::read_graph(string path)
{
    ifstream fin;
    fin.open(path.c_str(), ios::in);
    if(!fin.good()) {
        printf("Can't open the file [%s]\n", path.c_str());
        exit(1);
    }
    size_t N, M;
    fin >> N >> M;
    init_size(N);
    for(int i = 0; i < M; ++i) {
        node_id_t src, dst;
        fin >> src >> dst;
        //TODO could this cause issues?
        if(src < N && dst < N) {
            insert_edge(src, dst);
        }
    }
    fin.close();
    i_init_internals();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2280
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x2150
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x38(%rsp,%rax)
jne 0x1e293
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2100
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2100
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1dfc8
cmpq $0x0, 0x8(%rsp)
je 0x1e240
xorl %r13d, %r13d
leaq 0x18(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x23a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x23a0
movl 0x4(%rsp), %esi
movq 0x10(%rsp), %rax
cmpq %rsi, %rax
jbe 0x1e236
movl (%rsp), %edx
cmpq %rdx, %rax
jbe 0x1e236
movq %rbx, %rdi
callq 0x1de06
incq %r13
cmpq %r13, 0x8(%rsp)
ja 0x1e202
leaq 0x18(%rsp), %rdi
callq 0x2050
movq 0x8(%rbx), %rax
subq (%rbx), %rax
leaq 0x90(%rbx), %rdi
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
xorl %edx, %edx
callq 0x96d2
movb $0x0, 0xb8(%rbx)
leaq 0x18(%rsp), %rdi
callq 0x2060
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rsi
leaq 0x13932(%rip), %rdi     # 0x31bcf
xorl %eax, %eax
callq 0x2030
movl $0x1, %edi
callq 0x22c0
jmp 0x1e2b2
jmp 0x1e2b2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::has_edge(std::pair<unsigned int, unsigned int> const&)
bool graph_t::has_edge(const edge_t& e)
{
    edge_t e1 = e;
    edge_t e2; e2.first = e1.second; e2.second = e1.first;
    return (edge_set.find(e1) != edge_set.end() ||
            edge_set.find(e2) != edge_set.end());
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, (%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x6b50
movq 0x30(%r15), %rax
movq 0x40(%r15), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x1e878
movl (%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x50(%rsp)
jmp 0x1e885
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x7644
movl (%rsp), %eax
movq (%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x30(%rsp), %rax
cmpq %rax, 0x50(%rsp)
je 0x1e9a7
leaq 0x20(%rsp), %r12
leaq 0x4(%rsp), %r13
movl (%rax), %ebp
movq 0x40(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x1e8c2
addq $0x4, %rax
jmp 0x1e8f4
movq 0x38(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x2250
movq 0x48(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x30(%rsp)
leaq (,%rbp,2), %rsi
addq %rbp, %rsi
shlq $0x3, %rsi
addq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x61a0
movq 0x8(%rsp), %rdi
cmpq %rdi, 0x10(%rsp)
je 0x1e985
xorl %r15d, %r15d
movl (%rdi,%r15,4), %eax
movl %eax, 0x4(%rsp)
movq (%rbx), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x1e96c
movl (%rcx,%rbp,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movq 0x50(%rsp), %rax
movq 0x60(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x1e961
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x50(%rsp)
jmp 0x1e96c
movq %r12, %rdi
movq %r13, %rsi
callq 0x7644
incq %r15
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x2, %rax
cmpq %r15, %rax
ja 0x1e924
testq %rdi, %rdi
je 0x1e997
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0x30(%rsp), %rax
cmpq %rax, 0x50(%rsp)
jne 0x1e8ac
leaq 0x20(%rsp), %rdi
callq 0x6998
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e9c2
movq %rax, %rbx
jmp 0x1e9e1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1e9e1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x20(%rsp), %rdi
callq 0x6998
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::approx_bcc_iter_tm(unsigned int, unsigned int, double&, int)
void graph_t::approx_bcc_iter_tm(node_id_t src,
                                 node_id_t dst,
                                 double& avg_iter_time,
                                 int num_iter)
{
    timer tm;
    
    bcc_scratch_t bcc;
    find_edge_bcc(bcc, src, dst);
    if(num_iter == -1) {
        num_iter = bcc.bcc_subgraph.size();
    }
    
    tr1_map_t(double) bc_map;
    bcc.bcc_subgraph.i_fill_map<double>(bc_map, 0);
    tm.start();
    bcc.compute_bc(bc_map, num_iter);
    tm.stop();
    
    avg_iter_time = tm.interval()/num_iter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x538, %rsp            # imm = 0x538
movl %r8d, %r14d
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0xa(%rsp), %rax
leaq 0xc(%rsp), %r10
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %r13
leaq 0x18(%rsp), %rcx
leaq 0xd(%rsp), %r8
leaq 0xb(%rsp), %r9
movl $0xa, %esi
movq %r13, %rdx
pushq %rax
pushq %r10
callq 0x67d6
addq $0x10, %rsp
leaq 0x98(%rsp), %r15
movq %r15, %rdi
callq 0x153ae
leaq 0x340(%rsp), %rdi
callq 0x6220
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
movl %ebp, %ecx
callq 0x1317a
cmpl $-0x1, %r14d
jne 0x1ecd2
movq %r15, %rdi
callq 0x1c62c
movq %rax, %r14
leaq 0xe(%rsp), %rax
leaq 0x18(%rsp), %rdi
leaq 0xb(%rsp), %rdx
leaq 0xd(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0xa(%rsp), %r9
movl $0xa, %esi
pushq %rax
pushq %r13
callq 0xddc0
addq $0x10, %rsp
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x1d472
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x2360
leaq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl %r14d, %edx
callq 0x13a86
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2360
xorps %xmm0, %xmm0
cvtsi2sdq -0x10(%rbx), %xmm0
cvtsi2sdq -0x8(%rbx), %xmm1
movsd 0x1244b(%rip), %xmm2    # 0x311a0
divsd %xmm2, %xmm1
cvtsi2sdq (%rbx), %xmm3
cvtsi2sdq 0x8(%rbx), %xmm4
addsd %xmm0, %xmm1
divsd %xmm2, %xmm4
addsd %xmm3, %xmm4
subsd %xmm1, %xmm4
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
divsd %xmm0, %xmm4
movq 0x10(%rsp), %rax
movsd %xmm4, (%rax)
leaq 0x18(%rsp), %rdi
callq 0xd8b4
leaq 0x340(%rsp), %rdi
callq 0x6460
movq %r15, %rdi
callq 0x15750
leaq 0x68(%rsp), %rdi
callq 0x68e6
addq $0x538, %rsp            # imm = 0x538
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ede2
movq %rax, %rbx
movq %r15, %rdi
callq 0x15750
jmp 0x1edd6
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x68e6
jmp 0x1edfe
movq %rax, %rbx
jmp 0x1edf4
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd8b4
leaq 0x68(%rsp), %rdi
callq 0x1f952
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/graph_t.cc
// Function: graph_t::init_bc()
void graph_t::init_bc()
{
    if(!bc_computed) {
        bc_vec = brandes_bc(*this);
        for(int i = 0; i < bc_vec.size(); ++i) {
            bc_map.insert(make_pair(i, bc_vec[i]));
        }
        bc_computed = true;
    }    
}

// Assembly:
cmpb $0x0, 0xb8(%rdi)
jne 0x1eed0
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xaa17
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0x1fb70
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ee5c
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq 0xc0(%rbx), %rax
cmpq %rax, 0xc8(%rbx)
je 0x1eebc
leaq 0xd8(%rbx), %r14
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movsd (%rax,%r13,8), %xmm0
movl %r13d, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xded0
incq %r13
movq 0xc0(%rbx), %rax
movq 0xc8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x1ee80
movb $0x1, 0xb8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/iter_info_t.cc
// Function: iter_info_t::init_all(unsigned long)
void iter_info_t::init_all(size_t N)
{
    fill_vec<vector<node_id_t> >(P, N, vector<node_id_t>());
    fill_vec<int>(sigma_vec, N, 0);
    fill_vec<int>(dist_vec, N, -1);
    fill_vec<int>(sigma_inc_vec, N, 0);
    
    fill_vec<double>(delta_vec, N, 0);
    fill_vec<double>(Delta_vec, N, 0);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
callq 0x8c41
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fbe1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd7da
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
cmpq %rdx, %rdi
je 0x1fc10
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2110
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xd7da
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rdx
cmpq %rdx, %rdi
je 0x1fc42
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x2110
leaq 0xc0(%rbx), %rdi
movq %r14, %rsi
callq 0xd7da
movq 0xc0(%rbx), %rdi
movq 0xc8(%rbx), %rdx
cmpq %rdx, %rdi
je 0x1fc7a
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x2110
leaq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x5c58
movq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
cmpq %rdx, %rdi
je 0x1fca9
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x2110
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x5c58
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rdx
cmpq %rdx, %rdi
je 0x1fcd8
subq %rdi, %rdx
addq $-0x8, %rdx
andq $-0x8, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x2110
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x8e36
movq 0x100(%rbx), %rax
cmpq %rax, 0x108(%rbx)
je 0x1fd00
movq %rax, 0x108(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fd21
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x14, %esi
callq 0x1dfc8
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x1de06
movq %rbx, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x5, %esi
movl $0x6, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x6, %esi
movl $0x7, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x7, %esi
movl $0x8, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x8, %esi
movl $0x4, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x5, %esi
movl $0x9, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x9, %esi
movl $0x8, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x3, %esi
movl $0xa, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xa, %esi
movl $0xb, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xb, %esi
movl $0xc, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xc, %esi
movl $0xd, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xd, %esi
movl $0xe, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xe, %esi
movl $0xf, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0xf, %esi
movl $0xa, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x10, %esi
movl $0x11, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x11, %esi
movl $0x12, %edx
callq 0x1de06
movq %rbx, %rdi
movl $0x2, %esi
movl $0x13, %edx
popq %rbx
jmp 0x1de06
// File: /workspace/github_cpp_makefile_star2_O1/fjamour[P]icentral/src/unit_tests.h
// Function: test__fast_brandes_BC()
bool test__fast_brandes_BC()
{
    bool passed = false;
    printf("Testing [brandes_BC] ...\t");
    graph_t g;
    g.read_graph(string("Erdos02.lcc.net"));
    //fill_test_graph(g);
    vector<double> BC_vec;
    fast_brandes_BC(g, BC_vec);
    vector<double> ref_BC_vec = brandes_bc(g);
    passed = true;
    for(node_id_t v = 0; v < BC_vec.size(); ++v) {
        if((BC_vec[v] - ref_BC_vec[v]) > EPS) {
            passed = false;
        }
        //printf("[%f]\t\t[%f]\n", BC_vec[v], ref_BC_vec[v]);
    }
    if(passed) {
        printf("PASSED\n");
    } else {
        printf("FAILED\n");
    }
    
    return passed;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
leaq 0x11cc7(%rip), %rdi     # 0x31c60
xorl %eax, %eax
callq 0x2030
leaq 0x50(%rsp), %rdi
callq 0x240d4
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x11cc0(%rip), %rsi     # 0x31c7a
leaq 0x11cc8(%rip), %rdx     # 0x31c89
leaq 0x18(%rsp), %rdi
callq 0x24852
leaq 0x50(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1e17a
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fff1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2250
xorpd %xmm0, %xmm0
movq %rsp, %rsi
movapd %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x50(%rsp), %rdi
callq 0x328c
leaq 0x38(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xaa17
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
je 0x20068
sarq $0x3, %rcx
movb $0x1, %bl
movq 0x38(%rsp), %rdx
xorl %esi, %esi
movsd 0x11bfb(%rip), %xmm0    # 0x31c40
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm1
subsd (%rdx,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
movzbl %bl, %ebx
cmoval %esi, %ebx
incq %rdi
movl %edi, %r8d
cmpq %r8, %rcx
ja 0x20047
jmp 0x2006a
movb $0x1, %bl
leaq 0x11e69(%rip), %rax     # 0x31eda
leaq 0x11e5b(%rip), %rdi     # 0x31ed3
testb $0x1, %bl
cmovneq %rax, %rdi
callq 0x2350
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x2009b
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x200b1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2250
leaq 0x50(%rsp), %rdi
callq 0x2426c
andb $0x1, %bl
movl %ebx, %eax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
retq
jmp 0x200cd
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x20102
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
jmp 0x200f8
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x20102
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2250
jmp 0x20102
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2426c
movq %rbx, %rdi
callq 0x23b0