LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Relation(int, int)
void LDAG::Relation(int l, int i)
{
    for (int j = 0; j < NR_THREADS; ++j)
        R[j][l][i + _n] = INF;
    G[l].push_back(i + _n);
    G[i + _n].push_back(l);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rsp)
movslq %esi, %rsi
movslq %edx, %r14
movq 0x70(%rdi), %rax
xorl %ecx, %ecx
imulq $0x18, %rsi, %rdi
leaq (,%rax,8), %rdx
movabsq $0x7ff0000000000000, %rsi # imm = 0x7FF0000000000000
cmpq $0x60, %rcx
je 0x2d6f7
movq 0x90(%rbx,%rcx), %r8
movq (%r8,%rdi), %r8
addq %rdx, %r8
movq %rsi, (%r8,%r14,8)
addq $0x18, %rcx
jmp 0x2d6d8
addq 0x78(%rbx), %rdi
addl %r14d, %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
callq 0x2ec6a
imulq $0x18, 0x70(%rbx), %rax
addq 0x78(%rbx), %rax
imulq $0x18, %r14, %rdi
addq %rax, %rdi
movq %rsp, %rsi
callq 0x2dcc0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)
Greedy::Greedy(Graph& t1, Graph& t2, string d, double k, bool dag) : Solver(t1, t2, d, k, dag), A(t1.GetNumNodes(), vd(t2.GetNumNodes()))
{
    vb P(t1.GetNumNodes());
    DFSLeft(t1.GetRoot(), P, [&](newick_node* nodel, newick_node* noder, double w)
    {
        if (w != 0.0 && (dag || nodel->parent) && (dag || nodel->child) && (dag || noder->parent) && (dag || noder->child))
            E.emplace_back(nodel->taxoni, noder->taxoni, w);
    });
    sort(E.begin(), E.end(), [](const iid& a, const iid& b){return get<2>(a) > get<2>(b);});
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb %bpl, 0x6(%rsp)
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x9470
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
movsd 0x8(%rsp), %xmm0
movl %ebp, %r8d
callq 0x31914
leaq 0x38(%rsp), %rdi
callq 0x9708
leaq 0x65528(%rip), %rax     # 0x95448
movq %rax, (%rbx)
movq 0x70(%r15), %r12
movslq 0x70(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x2dc6e
leaq 0x88(%rbx), %r14
movslq %r12d, %rsi
leaq 0x10(%rsp), %rdx
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x31238
leaq 0x10(%rsp), %rdi
callq 0x2e522
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movslq 0x70(%r15), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x2dd44
movq 0x68(%r15), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %rbx, %r8
callq 0x3009a
movq 0xa0(%rbx), %r12
movq 0xa8(%rbx), %r15
cmpq %r15, %r12
je 0x30018
movq %r15, %r13
subq %r12, %r13
movq %r13, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x30926
cmpq $0x101, %r13            # imm = 0x101
jl 0x3000d
leaq 0x100(%r12), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x30bd7
jmp 0x30006
movq %r13, %rdi
callq 0x30c41
addq $0x10, %r13
cmpq %r15, %r13
jne 0x2fffa
jmp 0x30018
movq %r12, %rdi
movq %r15, %rsi
callq 0x30bd7
leaq 0x10(%rsp), %rdi
callq 0xbdb2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x30066
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x2e522
jmp 0x30089
movq %rax, %r15
jmp 0x30089
movq %rax, %r15
leaq 0x38(%rsp), %rdi
callq 0x9708
jmp 0x30091
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0xbdb2
leaq 0xa0(%rbx), %r12
leaq 0xb8(%rbx), %rdi
callq 0x3140c
movq %r12, %rdi
callq 0x3140c
movq %r14, %rdi
callq 0x2dd00
movq %rbx, %rdi
callq 0x3134c
movq %r15, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.h
// Function: void Solver::DFSLeft<Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0>(newick_node*, std::vector<bool, std::allocator<bool>>&, Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0)
void Solver::DFSLeft(newick_node* node, vb& P, F f)
{
    P[node->taxoni] = true;
    {
        vb Q(t2.GetNumNodes());
        DFSRight(node, t2.GetRoot(), Q, f);
    }
    for (newick_child* child = node->child; child; child = child->next)
        if (!P[child->node->taxoni])
            DFSLeft(child->node, P, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movslq 0x28(%rsi), %rsi
movq %rdx, %rdi
callq 0x2ddae
orq %rdx, (%rax)
movq 0x38(%r13), %rax
movslq 0x70(%rax), %rsi
leaq 0x10(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
callq 0x2dd44
movq 0x38(%r13), %rax
movq 0x68(%rax), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x30760
leaq 0x10(%rsp), %rdi
callq 0xbdb2
movq (%r12), %r12
testq %r12, %r12
je 0x3013f
movq (%r12), %rax
movslq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x30139
movq (%r12), %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x3009a
addq $0x8, %r12
jmp 0x30106
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbdb2
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::Solve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Greedy::Solve(string filename, string outScoreFile)
{
    for (const iid& e : E)
        if (all_of(M.begin(), M.end(), bind(&Greedy::CC, this, _1, cref(e))))
            M.push_back(e), A[get<0>(e)][get<1>(e)] = get<2>(e);
    if (filename != "") WriteSolution(filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, %rbx
movq 0xa0(%rdi), %rbp
movq 0xa8(%rdi), %r14
leaq 0xb8(%rdi), %r15
leaq 0x8(%rsp), %r12
movq %rbp, %r13
cmpq %r14, %r13
je 0x304dc
movq 0xb8(%rbx), %rdi
movq 0xc0(%rbx), %rsi
leaq 0xba(%rip), %rax        # 0x3053e
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r12, %rdx
callq 0x3128e
testb %al, %al
je 0x304d2
movq %r15, %rdi
movq %r13, %rsi
callq 0x312b8
movsd (%r13), %xmm0
movslq 0xc(%r13), %rax
movq 0x88(%rbx), %rcx
imulq $0x18, %rax, %rax
movslq 0x8(%r13), %rdx
movq (%rcx,%rax), %rax
movsd %xmm0, (%rax,%rdx,8)
addq $0x10, %r13
addq $0x10, %rbp
jmp 0x3046a
leaq 0x3c4b7(%rip), %rsi     # 0x6c99a
movq (%rsp), %r14
movq %r14, %rdi
callq 0x312d5
testb %al, %al
je 0x30519
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9470
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x9708
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9708
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::WriteSolution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Greedy::WriteSolution(string fileName)
{
    ofstream sol_file(fileName);
    double weight = 0.0;
    vn n1 = t1.GetNodes(), n2 = t2.GetNodes();
    for (const iid& e : M)
        sol_file << n1[get<0>(e)]->taxon << " " << n2[get<1>(e)]->taxon << " 1\n", weight += get<2>(e);
    PrintScore(weight);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x96e0
movq 0x30(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x312e0
movq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x312e0
movq 0xb8(%rbx), %r13
movq 0xc0(%rbx), %rbp
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x38(%rsp), %r14
leaq 0x20cb2(%rip), %r15     # 0x51262
leaq 0x3c330(%rip), %r12     # 0x6c8e7
cmpq %rbp, %r13
je 0x3061a
movslq 0xc(%r13), %rax
movq 0x20(%rsp), %rcx
movq (%rcx,%rax,8), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x92d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x9330
movslq 0x8(%r13), %rcx
movq 0x8(%rsp), %rdx
movq (%rdx,%rcx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0x92d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x9330
movsd (%rsp), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%rsp)
addq $0x10, %r13
jmp 0x305b7
movq %rbx, %rdi
movsd (%rsp), %xmm0
callq 0x31c84
leaq 0x8(%rsp), %rdi
callq 0xbeac
leaq 0x20(%rsp), %rdi
callq 0xbeac
leaq 0x38(%rsp), %rdi
callq 0x94f0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30663
movq %rax, %rbx
jmp 0x30670
movq %rax, %rbx
jmp 0x3067a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbeac
leaq 0x20(%rsp), %rdi
callq 0xbeac
leaq 0x38(%rsp), %rdi
callq 0x94f0
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::GetSolution(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double&)
void Greedy::GetSolution(vvi& K, Vector& v, double& d)
{
    double weight = 0.0;
    v = Vector::Zero(v.size());
    for (const iid& e : M)
        if (K[get<0>(e)][get<1>(e)] != -1)
            weight += get<2>(e), v(K[get<0>(e)][get<1>(e)]) = 1;
    d = -weight;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdx), %rsi
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xced2
movq %r14, %rdi
movq %r13, %rsi
callq 0x26bc6
movq 0xb8(%r12), %r13
movq 0xc0(%r12), %r12
xorpd %xmm0, %xmm0
movabsq $0x3ff0000000000000, %rbp # imm = 0x3FF0000000000000
cmpq %r12, %r13
je 0x30745
movslq 0xc(%r13), %rax
movq (%r15), %rcx
imulq $0x18, %rax, %rax
movslq 0x8(%r13), %rdx
movq (%rcx,%rax), %rax
movslq (%rax,%rdx,4), %rsi
cmpq $-0x1, %rsi
je 0x3073f
addsd (%r13), %xmm0
movapd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xd27a
movapd (%rsp), %xmm0
movq %rbp, (%rax)
addq $0x10, %r13
jmp 0x30702
xorpd 0x20c73(%rip), %xmm0    # 0x513c0
movlpd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.h
// Function: void Solver::DFSRight<Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0>(newick_node*, newick_node*, std::vector<bool, std::allocator<bool>>&, Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0)
void Solver::DFSRight(newick_node* nodel, newick_node* noder, vb& Q, F f)
{
    Q[noder->taxoni] = true;
    if (d == "j")
        f(nodel, noder, JaccardSim(t1.clade[nodel], t2.clade[noder], k));
    else if (d == "s")
        f(nodel, noder, SymdifSim(t1.clade[nodel], t2.clade[noder]));
    else
    	f(nodel, noder, EditDistance(*t1.clade[nodel].begin(), *t2.clade[noder].begin(), cost_matrix));

    for (newick_child* child = noder->child; child; child = child->next)
        if (!Q[child->node->taxoni])
            DFSRight(nodel, child->node, Q, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %r12
movq %r8, 0x18(%rsp)
movq %r9, 0x20(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movslq 0x28(%rdx), %rsi
movq %rcx, %rdi
callq 0x2ddae
orq %rdx, (%rax)
leaq 0x40(%r12), %rbp
leaq 0x20916(%rip), %rsi     # 0x510c6
movq %rbp, %rdi
callq 0xb7fa
testb %al, %al
je 0x307f7
movq 0x30(%r12), %rdi
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2de6e
movq %rax, %rbp
movq 0x38(%r12), %rdi
addq $0x20, %rdi
movq %rsp, %rsi
callq 0x2de6e
movsd 0x60(%r12), %xmm0
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3fd18
jmp 0x3086d
leaq 0x20a92(%rip), %rsi     # 0x51290
movq %rbp, %rdi
callq 0xb7fa
movl %eax, %ebp
movq 0x30(%r12), %rdi
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2de6e
testb %bpl, %bpl
je 0x30841
movq 0x38(%r12), %rdi
addq $0x20, %rdi
movq %rsp, %rsi
movq %rax, %rbp
callq 0x2de6e
movq %rbp, %rdi
movq %rax, %rsi
callq 0x3fe2b
jmp 0x3086d
movq (%rax), %rbp
addq $0x10, %rbp
movq 0x38(%r12), %rdi
addq $0x20, %rdi
movq %rsp, %rsi
callq 0x2de6e
movq (%rax), %rsi
addq $0x10, %rsi
leaq 0x70(%r12), %rdx
movq %rbp, %rdi
callq 0x3fefa
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x308d0
movq (%rsp), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x308c1
movq (%r13), %rax
movslq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x308bb
movq 0x8(%rsp), %rsi
movq (%r13), %rdx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x30760
addq $0x8, %r13
jmp 0x30883
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::PrintScore(double)
void Solver::PrintScore(double weight)
{
    if (d == "e")
    {
        double optVal2 = -weight;
        int n = (int) cost_matrix.size();
        int m = (int) cost_matrix[0].size();
        for (int i=0; i < n-1; ++i)
            optVal2 += cost_matrix[i][m-1];
        for (int j=0; j < m-1; ++j)
            optVal2 += cost_matrix[n-1][j];
        optVal2 = optVal2*scaleCoef;
        cout << ">>>>>>>>>>>>>>>>>>>>>> Optimal value:" << optVal2 << "." << endl;
        moptVal = optVal2;
//         return optVal2;
    }
    else if (dag){
        cout << weight << " ";
//         return weight;
    }
    else{
        cout << ((d == "j") ? JaccardDist(weight) : SymdifDist(weight)) << " ";
//         return ((d == "j") ? JaccardDist(weight) : SymdifDist(weight));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
leaq 0x3c376(%rip), %rsi     # 0x6e013
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0x31d15
movapd (%rsp), %xmm0
xorpd 0x1f70a(%rip), %xmm0    # 0x513c0
movq 0x70(%rbx), %rcx
movq 0x78(%rbx), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq 0x8(%rcx), %rdi
subq (%rcx), %rdi
movq %rdi, %rdx
shrq $0x3, %rdx
decl %eax
shlq $0x1d, %rdi
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
addq %rdi, %rsi
sarq $0x1d, %rsi
xorl %edi, %edi
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
imulq $0x18, %r8, %r8
cmpq %rdi, %r8
je 0x31d2f
movq (%rcx,%rdi), %r9
addsd (%r9,%rsi), %xmm0
addq $0x18, %rdi
jmp 0x31d00
cmpb $0x1, 0x68(%rbx)
jne 0x31dad
movq 0x6528a(%rip), %rdi     # 0x96fb0
movaps (%rsp), %xmm0
jmp 0x31dde
cltq
imulq $0x18, %rax, %rax
addq %rax, %rcx
cmpl $0x2, %edx
pushq $0x1
popq %rax
cmovgel %edx, %eax
decl %eax
shlq $0x3, %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x31d5c
movq (%rcx), %rsi
addsd (%rsi,%rdx), %xmm0
addq $0x8, %rdx
jmp 0x31d49
mulsd 0x28(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x65243(%rip), %rdi     # 0x96fb0
leaq 0x3abea(%rip), %rsi     # 0x6c95e
callq 0x9330
movq %rax, %rdi
movaps (%rsp), %xmm0
callq 0x9540
leaq 0x21e4e(%rip), %rsi     # 0x53bda
movq %rax, %rdi
callq 0x9330
movq %rax, %rdi
callq 0x9170
movaps (%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1f312(%rip), %rsi     # 0x510c6
movq %r14, %rdi
callq 0xb7fa
movq %rbx, %rdi
testb %al, %al
je 0x31dce
movaps (%rsp), %xmm0
callq 0x31dfa
jmp 0x31dd7
movaps (%rsp), %xmm0
callq 0x31e5a
movq 0x651d2(%rip), %rdi     # 0x96fb0
callq 0x9540
leaq 0x1f478(%rip), %rsi     # 0x51262
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x9330
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::SymdifDist(double) const
double Solver::SymdifDist(double weight) const
{
    if (tt) return TumorDist(weight);
    int max1 = 0, max2 = 0;
    int r1 = GetMax(t1.GetRoot(), max1);
    int r2 = GetMax(t2.GetRoot(), max2);
    return max1 + max2 - r1 - r2 - weight;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x65586(%rip), %rax     # 0x973f4
cmpb $0x1, (%rax)
jne 0x31e85
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3205a
leaq 0x14(%rsp), %r14
andl $0x0, (%r14)
leaq 0x10(%rsp), %r15
andl $0x0, (%r15)
movq 0x30(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x31ee4
movl %eax, %ebp
movq 0x38(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x31ee4
movl (%r14), %ecx
addl %ebp, %eax
subl %eax, %ecx
addl (%r15), %ecx
cvtsi2sd %ecx, %xmm0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::GetMax(newick_node*, int&) const
int Solver::GetMax(newick_node* node, int& hmax) const
{
    int sum = 0;
    for (newick_child* child = node->child; child; child = child->next)
        sum += GetMax(child->node, hmax);
    hmax += sum;
    return node->child ? sum : 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %ebp, %ebp
movq %rsi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x31f1a
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x31ee4
addl %eax, %ebp
addq $0x8, %r12
jmp 0x31efa
addl %ebp, (%r14)
cmpq $0x0, (%rbx)
pushq $0x1
popq %rax
cmovnel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::GetMax(Graph&, Graph&, newick_node*, newick_node*) const
double Solver::GetMax(Graph& t1, Graph& t2, newick_node* root, newick_node* rnode) const
{
    double m = root->parent && root->child ? SymdifSim(t1.clade[rnode], t2.clade[root]) : 0;
    for (newick_child* child = root->child; child; child = child->next)
        m = max(m, GetMax(t1, t2, child->node, rnode));
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
xorpd %xmm0, %xmm0
cmpq $0x0, 0x30(%rcx)
je 0x31fb9
cmpq $0x0, (%r12)
je 0x31fb9
leaq 0x20(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2de6e
movq %rax, %r12
leaq 0x20(%rbx), %rdi
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x2de6e
movq %r12, %rdi
movq %rax, %rsi
callq 0x3fe2b
movq (%r13), %r12
jmp 0x31fb9
movq (%r12), %rcx
movq 0x10(%rsp), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31f30
maxsd 0x8(%rsp), %xmm0
addq $0x8, %r12
movsd %xmm0, 0x8(%rsp)
movq (%r12), %r12
testq %r12, %r12
jne 0x31f98
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::CalcY(Graph&, Graph&, newick_node*) const
double Solver::CalcY(Graph& t1, Graph& t2, newick_node* root) const
{
    double w = root->parent && root->child ? GetMax(t1, t2, t2.GetRoot(), root) : 0;
    for (newick_child* child = root->child; child; child = child->next)
        w += CalcY(t1, t2, child->node);
    return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorpd %xmm0, %xmm0
cmpq $0x0, 0x30(%rcx)
je 0x32016
cmpq $0x0, (%rbx)
je 0x32016
movq 0x68(%r14), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq 0x31f30
movsd %xmm0, (%rsp)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x32048
movq (%rbx), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x31fdc
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
addq $0x8, %rbx
jmp 0x3201b
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::IsNotInConflict(int, int, int, int) const
bool Solver::IsNotInConflict(int i, int j, int x, int y) const
{
    if (i == j || x == y) return false;
    if (cf == 0) return true;
    bool c2 = (t1.D[j][i] || t1.D[i][j]) == (t2.D[x][y] || t2.D[y][x]);
    bool c1 = (t1.D[i][j] == t2.D[x][y]); // assuming c2 is satisfied
    if (cf == 1) return !c2 || c1;
    return c2 && c1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
cmpl %edx, %esi
sete %al
cmpl %r8d, %ecx
sete %cl
orb %al, %cl
je 0x320e7
xorl %eax, %eax
jmp 0x321e9
leaq 0x65302(%rip), %rax     # 0x973f0
cmpl $0x0, (%rax)
je 0x321da
movl %r8d, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq %edx, %r14
imulq $0x28, %r14, %rdi
addq 0x50(%rax), %rdi
movslq %esi, %r15
movq %r15, %rsi
callq 0x2ddae
pushq $0x1
popq %rcx
testq %rdx, (%rax)
jne 0x3213b
movq 0x30(%rbx), %rax
imulq $0x28, %r15, %rdi
addq 0x50(%rax), %rdi
movq %r14, %rsi
callq 0x2ddae
xorl %ecx, %ecx
testq %rdx, (%rax)
setne %cl
movq %r14, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x38(%rbx), %rax
movslq %r12d, %r14
imulq $0x28, %r14, %r12
movq 0x50(%rax), %rdi
addq %r12, %rdi
movslq %ebp, %r13
movq %r13, %rsi
callq 0x2ddae
testq %rdx, (%rax)
pushq $0x1
popq %rbp
jne 0x32186
movq 0x38(%rbx), %rax
imulq $0x28, %r13, %rdi
addq 0x50(%rax), %rdi
movq %r14, %rsi
callq 0x2ddae
xorl %ebp, %ebp
testq %rdx, (%rax)
setne %bpl
movq 0x30(%rbx), %rax
imulq $0x28, %r15, %rdi
addq 0x50(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2ddae
movq %rax, %r14
movq %rdx, %r15
movq 0x38(%rbx), %rax
addq 0x50(%rax), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2ddae
testq %r15, (%r14)
setne %cl
testq %rdx, (%rax)
sete %al
xorb %cl, %al
leaq 0x65226(%rip), %rcx     # 0x973f0
cmpl $0x1, (%rcx)
jne 0x321de
cmpl %ebp, 0xc(%rsp)
setne %cl
orb %cl, %al
jmp 0x321e9
movb $0x1, %al
jmp 0x321e9
cmpl %ebp, 0xc(%rsp)
sete %cl
andb %al, %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/LP.cpp
// Function: LP::MatchingConstraints()
void LP::MatchingConstraints()
{
    cnt = 0;
    vb P(t1.GetNumNodes());
    int n = t1.GetNumNodes(), m = t2.GetNumNodes();
    DFSLeft(t1.GetRoot(), P, [&](newick_node* nodel, newick_node* noder, double w)
    {
        if (w != 0 && (dag || (nodel->parent && nodel->child && noder->parent && noder->child)))
        {
            int i = nodel->taxoni, j = noder->taxoni;
            int col = i * m + j - cnt;
            K[i][j] = col;
            Triplets.emplace_back(i, col, 1.);
            Triplets.emplace_back(n + j, col, 1.);
            c(col) = w;
        }
        else
            ++cnt;
    });
    nr_rows = n + m;
    nr_cols = n * m - cnt;
    c.conservativeResize(nr_cols);
    // set warm_x and warm_y initialy to zeroes
    warm_x = Vector::Zero(nr_cols);
    warm_y = Vector::Zero(nr_rows);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
andl $0x0, 0x110(%rdi)
movq 0x30(%rdi), %rax
movslq 0x70(%rax), %rsi
leaq 0x50(%rsp), %r14
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x2dd44
movq 0x30(%rbx), %rax
movl 0x70(%rax), %ecx
leaq 0x1c(%rsp), %rdx
movl %ecx, (%rdx)
movq 0x38(%rbx), %rcx
movl 0x70(%rcx), %ecx
leaq 0x18(%rsp), %rdi
movl %ecx, (%rdi)
movq 0x68(%rax), %rsi
movq %rbx, 0x38(%rsp)
movq %rdi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3259e
movl 0x1c(%rsp), %eax
movl 0x18(%rsp), %ecx
leal (%rcx,%rax), %edx
movl %edx, 0x108(%rbx)
imull %eax, %ecx
movslq 0x110(%rbx), %rax
movslq %ecx, %rsi
subq %rax, %rsi
movl %esi, 0x10c(%rbx)
leaq 0xf8(%rbx), %rdi
callq 0x34920
movslq 0x10c(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0xced2
leaq 0xa0(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x26bc6
movslq 0x108(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0xced2
addq $0xb0, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x26bc6
leaq 0x50(%rsp), %rdi
callq 0xbdb2
addq $0x78, %rsp
popq %rbx
popq %r14
retq
jmp 0x32504
jmp 0x32504
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xbdb2
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: PackingJRF::getBoundsConstraints(double*, double*)
bool getBoundsConstraints(Scalar* cl, Scalar* cu) override
    {
    // we have equality constraints here
        Vector::MapType(cu, _m) = _b;
        Vector::MapType(cl, _m) = Vector::Constant(_m, -INF);
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq 0x38(%rdi), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xe296
movq %r12, %rdi
movq %r15, %rsi
callq 0x338ce
movq 0x38(%r14), %rsi
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe890
movq 0x38(%r14), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe296
movq %r14, %rdi
movq %r15, %rsi
callq 0x3374d
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::functionValueAndGradient(double const*, double&, double*)
virtual bool functionValueAndGradient(const Scalar* variablesPtr,
                                          Scalar& functionValue,
                                          Scalar* gradientPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::MapType g = Vector::MapType(gradientPtr, _n);
        functionValue = _c.dot(x);
        g = _c;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rdx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xebcc
movq 0x30(%r15), %rdx
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe296
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0x33a26
movsd %xmm0, (%r14)
movq 0x18(%r15), %rsi
movq %r13, %rdi
callq 0x338ce
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::functionValueConstraints(double const*, double*)
virtual bool functionValueConstraints(const Scalar* variablesPtr,
                                          Scalar* constraintValuesPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::MapType constraintValues = Vector::MapType(constraintValuesPtr, _m);
        constraintValues = _A * x;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xebcc
movq 0x38(%r14), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0xe296
movq 0x8(%r14), %rsi
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x33c26
movq %r12, %rdi
movq %rbx, %rsi
callq 0x33c59
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::gradientConstraintsTimesVector(double const*, double const*, double*)
virtual bool gradientConstraintsTimesVector(const Scalar* variablesPtr,
                                                const Scalar* dualVariablesPtr,
                                                Scalar* gradientPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::ConstMapType y = Vector::ConstMapType(dualVariablesPtr, _m);
        Vector::MapType gradient = Vector::MapType(gradientPtr, _n);
        gradient = _A.transpose() * y;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rdx
leaq 0x48(%rsp), %rdi
callq 0xebcc
movq 0x38(%r15), %rdx
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xebcc
movq 0x30(%r15), %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe296
movq 0x8(%r15), %rax
leaq 0x8(%rsp), %rsi
movb $0x0, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x33eb0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33eea
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/LP.h
// Function: int LP::Add<CrossingConstraint>()
int LP::Add()
{
    int row_old = nr_rows;
    T c12(Triplets, t1, t2, K, x, false);
    nr_rows += c12.AddTriplets(nr_rows);
    T c21(Triplets, t2, t1, K, x, true);
    nr_rows += c21.AddTriplets(nr_rows);
    return nr_rows - row_old;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
movl 0x108(%rdi), %ebp
leaq 0x88(%rdi), %r14
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
leaq 0xe0(%rdi), %r15
leaq 0xc0(%rdi), %r12
andl $0x0, (%rsp)
leaq 0xf0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %r8
movq %r12, %r9
callq 0x37d08
movl 0x108(%rbx), %esi
movq %r13, %rdi
callq 0x37f86
movl %ebp, %r13d
addl %eax, 0x108(%rbx)
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rdx
movl $0x1, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %r8
movq %r12, %r9
callq 0x37d08
movl 0x108(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x37f86
movl %eax, %ebp
addl 0x108(%rbx), %ebp
movl %ebp, 0x108(%rbx)
subl %r13d, %ebp
leaq 0x8(%rsp), %rdi
callq 0x34a54
leaq 0xf0(%rsp), %rdi
callq 0x34a54
movl %ebp, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34a54
jmp 0x34a3f
jmp 0x34a3c
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x34a54
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::AntichainConstraint(std::vector<Eigen::Triplet<double, int>, std::allocator<Eigen::Triplet<double, int>>>&, Graph&, Graph&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, bool)
AntichainConstraint::AntichainConstraint(vector<ET>& Triplets, Graph& t1, Graph& t2, vvi& K, Vector& x, bool swp) : Constraint(Triplets, t1, t2, K, x, swp), G(((LDAG*)&t2)->G), ncr(0), B(t1.GetNumNodes()), pi(0)
{
    Z = t2.GetNumNodes();
    SZ = Z * 2 + 2;
    S = SZ - 2;
    T = SZ - 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movzbl 0x30(%rsp), %eax
movl %eax, (%rsp)
callq 0x37530
leaq 0x5f4d2(%rip), %rax     # 0x955e0
movq %rax, (%rbx)
leaq 0x78(%r14), %rax
movq %rax, 0x38(%rbx)
andl $0x0, 0x40(%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x78(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
leaq 0x80(%rbx), %rdi
movslq 0x70(%r15), %rsi
leaq 0xf(%rsp), %rdx
callq 0x2dd44
andl $0x0, 0xa8(%rbx)
movl 0x70(%r14), %eax
movl %eax, 0x50(%rbx)
leal 0x2(,%rax,2), %ecx
leal 0x1(,%rax,2), %edx
addl %eax, %eax
movl %ecx, 0x54(%rbx)
movl %eax, 0x48(%rbx)
movl %edx, 0x4c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::RunParallel()
void AntichainConstraint::RunParallel()
{
    vector<thread> vt;
    for (int i = 0; i < NR_THREADS; ++i)
        vt.emplace_back(&AntichainConstraint::AntichainJob, this, i);

    for (int i = 0; i < NR_THREADS; ++i)
        vt[i].join();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %eax, %eax
leaq 0x8d(%rip), %rbp        # 0x3623e
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jae 0x361f2
movq %rbp, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x36afa
movl 0x4(%rsp), %eax
incl %eax
jmp 0x361c0
xorl %ebx, %ebx
cmpq $0x20, %rbx
je 0x3620d
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x95f0
addq $0x8, %rbx
jmp 0x361f4
leaq 0x20(%rsp), %rdi
callq 0x36b42
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36228
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x36b42
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::AntichainJob(int)
void AntichainConstraint::AntichainJob(int id)
{
    LDAG &g1 = (LDAG&)t1, &g2 = (LDAG&)t2;
    while (true)
    {
        int i;
        {
            lock_guard<mutex> g(qmutex);
            if (pi == g1.P.size())
                break;
            i = pi++;
            if (all_of(g1.P[i].begin(), g1.P[i].end(), [&](newick_node* node){return B[node->taxoni];}))
                continue;
        }
        Antichain(g1.P[i], g2.R[id]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rdi), %rax
leaq 0x58(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movslq %esi, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x90, %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %r12
movq %rdi, 0x28(%rsp)
movq 0x10(%rsp), %rdi
callq 0x36f8c
movl 0xa8(%r15), %ebx
movslq %ebx, %rsi
movq 0x18(%rsp), %rax
movq 0xf0(%rax), %rcx
movq 0xf8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rdi
idivq %rdi
cmpq %rsi, %rax
jne 0x362c9
xorl %r15d, %r15d
pushq $0x3
popq %r14
movl %ebp, %ebx
jmp 0x363c0
leal 0x1(%rsi), %eax
movl %eax, 0xa8(%r15)
imulq $0x18, %rsi, %rax
movq (%rcx,%rax), %r13
movq 0x8(%rcx,%rax), %r14
movq %r15, 0x30(%rsp)
movq %r14, 0x8(%rsp)
subq %r13, %r14
movq %r14, %r15
sarq $0x5, %r15
testq %r15, %r15
jle 0x36356
movq %r12, %rdi
movq %r13, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363aa
leaq 0x8(%r13), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363ad
leaq 0x10(%r13), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363ad
leaq 0x18(%r13), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363ad
addq $0x20, %r13
decq %r15
addq $-0x20, %r14
jmp 0x362f4
sarq $0x3, %r14
cmpq $0x1, %r14
je 0x36397
cmpq $0x2, %r14
je 0x36384
movq 0x8(%rsp), %rbp
cmpq $0x3, %r14
jne 0x363ad
movq %r12, %rdi
movq %r13, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363aa
addq $0x8, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x36ac2
testb %al, %al
jne 0x363aa
addq $0x8, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x36ac2
testb %al, %al
cmoveq 0x8(%rsp), %r13
movq %r13, %rbp
xorl %r14d, %r14d
cmpq 0x8(%rsp), %rbp
setne %r15b
sete %r14b
addl %r14d, %r14d
movq 0x10(%rsp), %rdi
callq 0x9280
testb %r15b, %r15b
movq 0x28(%rsp), %r15
je 0x363f7
movslq %ebx, %rax
imulq $0x18, %rax, %rsi
movq 0x18(%rsp), %rax
addq 0xf0(%rax), %rsi
movq %r15, %rdi
movq 0x20(%rsp), %rdx
callq 0x3642a
xorl %r14d, %r14d
movl %ebx, %ebp
cmpl $0x3, %r14d
jne 0x36284
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36414
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x9280
movq %r14, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::Push(int, double, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<int, std::allocator<int>>&)
double AntichainConstraint::Push(int x, double flow, vvd& R, vi& D)
{
    if (x == T)
        return flow;
    for (int y : G[x])
        if (R[x][y] > 0 && D[y] == D[x] + 1)
            if (double f = Push(y, min(flow, R[x][y]), R, D))
                return R[x][y] -= f, R[y][x] += f, f;
    return D[x] = -1, 0;
}

// Assembly:
movapd %xmm0, %xmm1
cmpl %esi, 0x4c(%rdi)
je 0x367a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbp
movq %rdx, %rbx
movq %rdi, %r13
movq 0x38(%rdi), %rax
movslq %esi, %r14
movq (%rax), %rax
imulq $0x18, %r14, %r8
movq (%rax,%r8), %r15
movq 0x8(%rax,%r8), %r9
xorpd %xmm2, %xmm2
movsd %xmm1, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movq %r9, (%rsp)
cmpq %r9, %r15
je 0x3678b
movslq (%r15), %r12
movq (%rbx), %rax
movq (%rax,%r8), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x36785
movq (%rbp), %rax
movl (%rax,%r14,4), %esi
incl %esi
cmpl %esi, (%rax,%r12,4)
jne 0x36785
minsd %xmm1, %xmm0
movq %r13, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r8, %r14
callq 0x366d6
xorpd %xmm2, %xmm2
movq (%rsp), %r9
movq %r14, %r8
movq 0x8(%rsp), %r14
movsd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm0
jne 0x367ab
jp 0x367ab
addq $0x4, %r15
jmp 0x36724
movq (%rbp), %rax
orl $-0x1, (%rax,%r14,4)
xorpd %xmm1, %xmm1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
movq (%rbx), %rax
movq (%rax,%r8), %rcx
movsd (%rcx,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r12,8)
imulq $0x18, %r12, %rcx
movq (%rax,%rcx), %rax
movsd (%rax,%r14,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r14,8)
movapd %xmm0, %xmm1
jmp 0x36798
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::LevelGraph(std::vector<int, std::allocator<int>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
bool AntichainConstraint::LevelGraph(vi& D, vvd& R)
{
    queue<int> W;
    W.push(S);
    D[S] = 0;
    while (!W.empty())
    {
        int k = W.front(); W.pop();
        if (k == T) return true;
        for (int x : G[k])
            if (D[x] == -1 && R[k][x] > 0)
                D[x] = D[k] + 1, W.push(x);
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x36b64
leaq 0x48(%r15), %rsi
movq %r12, %rdi
callq 0x37150
movq %r15, 0x10(%rsp)
movslq 0x48(%r15), %rax
movq (%r14), %rcx
andl $0x0, (%rcx,%rax,4)
movq 0x28(%rsp), %r15
movq 0x48(%rsp), %r12
cmpq %r15, %r12
movq 0x10(%rsp), %r13
je 0x368a4
movslq (%r15), %rbp
leaq 0x18(%rsp), %rdi
callq 0x37384
cmpl 0x4c(%r13), %ebp
je 0x368a4
movq 0x38(%r13), %rax
movq (%rax), %rax
imulq $0x18, %rbp, %r15
movq (%rax,%r15), %r13
movq 0x8(%rax,%r15), %r12
cmpq %r12, %r13
je 0x36820
movslq (%r13), %rax
movl %eax, 0xc(%rsp)
movq (%r14), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x3689e
movq (%rbx), %rdx
movq (%rdx,%r15), %rdx
movsd (%rdx,%rax,8), %xmm0
ucomisd 0x1ab83(%rip), %xmm0    # 0x51408
jbe 0x3689e
movl (%rcx,%rbp,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x37150
addq $0x4, %r13
jmp 0x3685b
cmpq %r15, %r12
setne %bl
leaq 0x18(%rsp), %rdi
callq 0x36be2
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x368c7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x36be2
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::MaxFlow(std::vector<int, std::allocator<int>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double AntichainConstraint::MaxFlow(vi& D, vvd& R)
{
    double flow = 0;
    while (LevelGraph(D, R))
    {
        while (double f = Push(S, INF, R, D))
            flow += f;
        fill(D.begin(), D.end(), -1);
    }
    return flow;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x367e0
testb %al, %al
je 0x36963
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x48(%r15), %esi
movq %r15, %rdi
movsd 0x1aac3(%rip), %xmm0    # 0x513e8
movq %rbx, %rdx
movq %r14, %rcx
callq 0x366d6
movsd 0x8(%rsp), %xmm1
ucomisd 0x1aaca(%rip), %xmm0    # 0x51408
addsd %xmm1, %xmm0
jne 0x36910
jp 0x36910
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x3695b
orl $-0x1, (%rax)
addq $0x4, %rax
jmp 0x3694d
movsd %xmm1, 0x8(%rsp)
jmp 0x368f8
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::Reset(std::vector<newick_node*, std::allocator<newick_node*>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double AntichainConstraint::Reset(vn& P, vvd& R)
{
    double sum = 0;
    for (int i = 0; i < Z; ++i)
    {
        R[S][i] = R[i][S] = R[T][i + Z] = 0;
        for (int j : G[i + Z])
            R[i + Z][j] = 0;

        for (newick_node* nodel : P)
        {
            R[S][i] += GetWeight(nodel->taxoni, i);
            R[i + Z][T] += GetWeight(nodel->taxoni, i);
        }
        sum += R[S][i];
    }
    return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movl 0x50(%rdi), %eax
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x36aad
movslq 0x4c(%r15), %rdx
movq (%rbx), %rcx
imulq $0x18, %rdx, %rdx
leal (%rax,%r12), %esi
movslq %esi, %rsi
movq (%rcx,%rdx), %rdx
andq $0x0, (%rdx,%rsi,8)
imulq $0x18, %r12, %rdx
movslq 0x48(%r15), %rdi
movq (%rcx,%rdx), %rdx
andq $0x0, (%rdx,%rdi,8)
imulq $0x18, %rdi, %rdx
movq (%rcx,%rdx), %rdx
andq $0x0, (%rdx,%r12,8)
movq 0x38(%r15), %rdx
movq (%rdx), %rdi
imulq $0x18, %rsi, %rdx
movq (%rdi,%rdx), %rsi
movq 0x8(%rdi,%rdx), %rdi
addq %rcx, %rdx
cmpq %rdi, %rsi
je 0x36a0f
movslq (%rsi), %r8
movq (%rdx), %r9
andq $0x0, (%r9,%r8,8)
addq $0x4, %rsi
jmp 0x369f9
movq 0x10(%rsp), %rdx
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x36a87
movq (%r13), %r14
movl 0x28(%r14), %esi
movq %r15, %rdi
movl %r12d, %edx
callq 0x36b80
movslq 0x48(%r15), %rax
movq (%rbx), %rcx
imulq $0x18, %rax, %rax
movq (%rcx,%rax), %rax
addsd (%rax,%r12,8), %xmm0
movsd %xmm0, (%rax,%r12,8)
movl 0x28(%r14), %esi
movq %r15, %rdi
movl %r12d, %edx
callq 0x36b80
movl 0x50(%r15), %eax
leal (%rax,%r12), %ecx
movslq %ecx, %rdx
movq (%rbx), %rcx
imulq $0x18, %rdx, %rdx
movslq 0x4c(%r15), %rsi
movq (%rcx,%rdx), %rdx
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
addq $0x8, %r13
jmp 0x36a1b
movslq 0x48(%r15), %rdx
imulq $0x18, %rdx, %rdx
movq (%rcx,%rdx), %rcx
movsd 0x8(%rsp), %xmm0
addsd (%rcx,%r12,8), %xmm0
movsd %xmm0, 0x8(%rsp)
incq %r12
jmp 0x3699d
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Constraint.cpp
// Function: Constraint::AddConstraint(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Constraint::AddConstraint(int row, vii& P)
{
    for (auto k : P)
    {
        int col = GetCol(k.first, k.second);
        if (col != -1)
            Triplets.emplace_back(row, col, 1.);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
cmpq %rbp, %r13
je 0x375c6
movl (%r13), %esi
movl 0x4(%r13), %edx
movq %rbx, %rdi
callq 0x36c3a
movl %eax, 0x8(%rsp)
cmpl $-0x1, %eax
je 0x375c0
movq 0x8(%rbx), %rdi
movq %r14, 0x10(%rsp)
leaq 0xc(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x34634
addq $0x8, %r13
jmp 0x37589
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/IndependentSetConstraint.cpp
// Function: IndependentSetConstraint::AddTriplets(int)
int IndependentSetConstraint::AddTriplets(int nr_rows)
{
    DFSRight(t2.GetRoot());
    int ncr = 0;
    for (newick_node* node : t1.L)
    {
        dLN L = DFSRight(node, t2.GetRoot());
        if (L.first - EPS <= 1)
            continue;

        vii P;
        for (newick_node* noder : L.second)
            for (newick_node* nodel = node; nodel; nodel = nodel->parent ? nodel->parent->node : nullptr)
                P.emplace_back(nodel->taxoni, noder->taxoni);

        AddConstraint(nr_rows + ncr++, P);
    }
    return ncr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rsi
callq 0x377b4
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
xorl %r14d, %r14d
leaq 0x50(%rsp), %r15
leaq 0x30(%rsp), %rbp
movq %rbx, 0x10(%rsp)
cmpq 0x20(%rsp), %rcx
je 0x37782
movq %r14, 0x8(%rsp)
movq %rcx, 0x28(%rsp)
movq (%rcx), %r12
movq 0x18(%rbx), %rax
movq 0x68(%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x377f2
movsd 0x48(%rsp), %xmm0
addsd 0x36818(%rip), %xmm0    # 0x6def8
movsd 0x1c138(%rip), %xmm1    # 0x53820
ucomisd %xmm0, %xmm1
jae 0x3773c
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x37743
movq 0x10(%rbx), %r13
addq $0x28, %r13
movq %r12, %r14
testq %r14, %r14
je 0x37701
leaq 0x28(%r14), %rsi
movq %rbp, %rdi
movq %r13, %rdx
callq 0x36ba6
movq 0x30(%r14), %rax
movl $0x0, %r14d
testq %rax, %rax
je 0x37714
movq (%rax), %r14
jmp 0x37714
movq 0x8(%rsp), %r14
jmp 0x3776c
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %r14
leal (%r14,%rax), %esi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x37556
incl %r14d
movq %rbp, %rdi
callq 0x3137c
movq %r15, %rdi
callq 0x37a86
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
jmp 0x376a2
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37796
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3137c
movq %r15, %rdi
callq 0x37a86
movq %r14, %rdi
callq 0x9640
nop