LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4, %rax
jae 0x97c75
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rsi
addq 0x70(%rax), %rsi
callq 0x9a090
movsd 0x7373a(%rip), %xmm0    # 0x10b3a0
movsd %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x97c21
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movslq -0xc(%rbp), %rsi
callq 0x993b0
movq -0x20(%rbp), %rcx
movq %rax, %rdi
movslq -0x10(%rbp), %rax
addq 0x70(%rcx), %rax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x99440
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x78, %rdi
movslq -0x10(%rbp), %rsi
addq 0x70(%rax), %rsi
callq 0x993b0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x993d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0xd0(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xa8e00
cltq
movq %rax, -0xc8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x995b0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x995d0
jmp 0xa5703
leaq -0x61(%rbp), %rdi
callq 0x99610
movq -0xd0(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x38(%rax), %rdi
callq 0xa8ec0
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq %rax, %rdx
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x90(%rbp)
movq -0x90(%rbp), %r8
movq -0x88(%rbp), %r9
leaq -0x60(%rbp), %rcx
callq 0xa6610
jmp 0xa575c
leaq -0x60(%rbp), %rdi
callq 0x10160
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xa5841
movq -0x28(%rbp), %rdi
movq -0x98(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x99810
xorb $-0x1, %al
testb $0x1, %al
jne 0xa57ba
jmp 0xa5828
movq -0xd0(%rbp), %rdi
movq -0x98(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp), %r8
callq 0xa5670
jmp 0xa5828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x99610
jmp 0xa584a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x10160
jmp 0xa584a
jmp 0xa582a
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0xa5773
addq $0xe0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0xa0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa8ee0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa8f10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa8fa0
testb $0x1, %al
jne 0xa5f13
jmp 0xa604e
leaq -0x28(%rbp), %rdi
callq 0xa8fe0
movq -0xc0(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0xb8, %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa8ee0
movq -0xd0(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0xa8f10
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x48(%rbp)
leaq 0x181(%rip), %rcx       # 0xa60e0
movq %rcx, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq %rax, -0x80(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa90c0
movq %rax, -0x88(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq 0xfb00e(%rip), %rcx     # 0x1a0fa0
leaq -0x88(%rbp), %r8
callq 0xa9070
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0xa9000
testb $0x1, %al
jne 0xa5fb8
jmp 0xa603e
movq -0xc0(%rbp), %rdi
addq $0xb8, %rdi
movq -0x38(%rbp), %rsi
callq 0xa90f0
movq -0x38(%rbp), %rdi
callq 0xa9160
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0xd8(%rbp)
addq $0x88, %rax
movq %rax, -0xe8(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa9180
movq -0xe8(%rbp), %rdi
movslq (%rax), %rsi
callq 0x9a070
movq %rax, -0xe0(%rbp)
movq -0x38(%rbp), %rdi
callq 0xa91a0
movq -0xe0(%rbp), %rdi
movslq (%rax), %rsi
callq 0x9a090
movsd -0xd8(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0xa6040
leaq -0x28(%rbp), %rdi
callq 0xa91c0
jmp 0xa5efd
movq -0xc8(%rbp), %rdi
leaq 0x8417e(%rip), %rsi     # 0x12a1da
callq 0xa91e0
testb $0x1, %al
jne 0xa6067
jmp 0xa60c8
movq -0xc8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0xa190
movq -0xc0(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
jmp 0xa609a
leaq -0xa8(%rbp), %rdi
callq 0xa8d8
jmp 0xa60c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xa8d8
jmp 0xa60d1
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0xa7c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x280(%rbp)
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0xa890
movq -0x280(%rbp), %rax
movq $0x0, -0x218(%rbp)
movq 0x30(%rax), %rsi
leaq -0x230(%rbp), %rdi
callq 0xa9210
jmp 0xa61b3
movq -0x280(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x258(%rbp), %rdi
callq 0xa9210
jmp 0xa61cc
movq -0x280(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rdi
callq 0xa8ee0
movq %rax, -0x268(%rbp)
movq -0x260(%rbp), %rdi
callq 0xa8f10
movq %rax, -0x270(%rbp)
leaq -0x268(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0xa8fa0
testb $0x1, %al
jne 0xa6222
jmp 0xa6350
leaq -0x268(%rbp), %rdi
callq 0xa8fe0
movq %rax, -0x278(%rbp)
movq -0x278(%rbp), %rdi
callq 0xa9180
movslq (%rax), %rsi
leaq -0x230(%rbp), %rdi
callq 0xa19e0
movq (%rax), %rsi
addq $0x8, %rsi
leaq -0x210(%rbp), %rdi
callq 0xa3d0
movq %rax, -0x288(%rbp)
jmp 0xa626c
movq -0x288(%rbp), %rdi
leaq 0x64fc8(%rip), %rsi     # 0x10b242
callq 0xa440
movq %rax, -0x290(%rbp)
jmp 0xa6288
movq -0x278(%rbp), %rdi
callq 0xa91a0
movslq (%rax), %rsi
leaq -0x258(%rbp), %rdi
callq 0xa19e0
movq -0x290(%rbp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0xa3d0
movq %rax, -0x298(%rbp)
jmp 0xa62bf
movq -0x298(%rbp), %rdi
leaq 0x83e6b(%rip), %rsi     # 0x12a138
callq 0xa440
jmp 0xa62d4
movq -0x278(%rbp), %rdi
callq 0xa9160
movsd (%rax), %xmm0
addsd -0x218(%rbp), %xmm0
movsd %xmm0, -0x218(%rbp)
leaq -0x268(%rbp), %rdi
callq 0xa91c0
jmp 0xa6206
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0xa639f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0xa6393
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x258(%rbp), %rdi
callq 0xffe0
jmp 0xa6393
movq -0x280(%rbp), %rdi
movsd -0x218(%rbp), %xmm0
callq 0xac460
jmp 0xa6366
leaq -0x258(%rbp), %rdi
callq 0xffe0
leaq -0x230(%rbp), %rdi
callq 0xffe0
leaq -0x210(%rbp), %rdi
callq 0xa670
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x230(%rbp), %rdi
callq 0xffe0
leaq -0x210(%rbp), %rdi
callq 0xa670
movq -0x238(%rbp), %rdi
callq 0xa7c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14700
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x13c30
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x28100
movq -0x68(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa8ee0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xa8f10
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa8fa0
testb $0x1, %al
jne 0xa650b
jmp 0xa65dc
leaq -0x50(%rbp), %rdi
callq 0xa8fe0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa9180
movq -0x78(%rbp), %rdi
movslq (%rax), %rsi
callq 0x993b0
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa91a0
movq -0x70(%rbp), %rdi
movslq (%rax), %rsi
callq 0x145d0
cmpl $-0x1, (%rax)
je 0xa65cc
movq -0x60(%rbp), %rdi
callq 0xa9160
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa9180
movq -0x90(%rbp), %rdi
movslq (%rax), %rsi
callq 0x993b0
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa91a0
movq -0x88(%rbp), %rdi
movslq (%rax), %rsi
callq 0x145d0
movq -0x80(%rbp), %rdi
movslq (%rax), %rsi
callq 0x145f0
movsd 0x676a0(%rip), %xmm0    # 0x10dc68
movsd %xmm0, (%rax)
jmp 0xa65ce
leaq -0x50(%rbp), %rdi
callq 0xa91c0
jmp 0xa64f5
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xf4d84(%rip), %rax     # 0x1a14e4
testb $0x1, (%rax)
je 0xac77a
movq -0x30(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0xaca40
movsd %xmm0, -0x8(%rbp)
jmp 0xac7e4
movq -0x30(%rbp), %rax
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq 0x30(%rax), %rdi
callq 0xa8ec0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
leaq -0x1c(%rbp), %rdx
callq 0xac7f0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x24(%rbp)
movq 0x38(%rax), %rdi
callq 0xa8ec0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0xac7f0
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
subl -0x24(%rbp), %eax
subl -0x28(%rbp), %eax
cvtsi2sd %eax, %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xac84d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xac7f0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xac81e
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xac86a
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xac874
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xac874
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xac8f2
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xac8f2
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x99b50
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x99b50
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xdbd60
movsd %xmm0, -0x50(%rbp)
jmp 0xac8fc
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0xac8fc
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xac95d
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %r8
callq 0xac880
movsd %xmm0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14920
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xac911
movsd -0x30(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xac9dd
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xac9dd
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa8ec0
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
movq -0x20(%rbp), %r8
callq 0xac880
movsd %xmm0, -0x40(%rbp)
jmp 0xac9e7
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xac9e7
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xaca33
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rcx
callq 0xac970
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xac9fc
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x0, 0x110(%rax)
movq 0x30(%rax), %rdi
callq 0xa8e00
cltq
movq %rax, -0xa8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x995b0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x995d0
jmp 0xad48f
leaq -0x31(%rbp), %rdi
callq 0x99610
movq -0xb0(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xa8e00
movl %eax, -0xb4(%rbp)
jmp 0xad4b0
movq -0xb0(%rbp), %rax
movl -0xb4(%rbp), %ecx
movl %ecx, -0x48(%rbp)
movq 0x38(%rax), %rdi
callq 0xa8e00
movl %eax, -0xb8(%rbp)
jmp 0xad4d1
movq -0xb0(%rbp), %rax
movl -0xb8(%rbp), %ecx
movl %ecx, -0x4c(%rbp)
movq 0x30(%rax), %rdi
callq 0xa8ec0
movq %rax, -0xc0(%rbp)
jmp 0xad4f3
movq -0xc0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x68(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x30(%rbp), %rdx
callq 0xad700
jmp 0xad532
movq -0xb0(%rbp), %rax
movl -0x48(%rbp), %ecx
movl -0x4c(%rbp), %edx
addl %edx, %ecx
movl %ecx, 0x108(%rax)
movl -0x48(%rbp), %ecx
movl -0x4c(%rbp), %edx
imull %edx, %ecx
movl 0x110(%rax), %edx
subl %edx, %ecx
movl %ecx, 0x10c(%rax)
movq %rax, %rdi
addq $0xf8, %rdi
movslq 0x10c(%rax), %rsi
callq 0xaf010
jmp 0xad576
movq -0xb0(%rbp), %rax
movslq 0x10c(%rax), %rsi
leaq -0x80(%rbp), %rdi
callq 0x13c30
jmp 0xad58f
movq -0xb0(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x80(%rbp), %rsi
callq 0x28100
jmp 0xad5a8
movq -0xb0(%rbp), %rax
movslq 0x108(%rax), %rsi
leaq -0x98(%rbp), %rdi
callq 0x13c30
jmp 0xad5c4
movq -0xb0(%rbp), %rdi
addq $0xb0, %rdi
leaq -0x98(%rbp), %rsi
callq 0x28100
jmp 0xad5e0
leaq -0x30(%rbp), %rdi
callq 0x10160
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x99610
jmp 0xad61e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10160
movq -0x40(%rbp), %rdi
callq 0xa7c0
nopw (%rax,%rax)
// File: canzarlab[P]Trajan/src/LP.h
// Function: int LP::Add<2>()
int LP::Add()
{
    static_assert(N == 1 || N == 2, "invalid constraint");
    if (N == 1)
        return Add<CrossingConstraint>();
    return (dag ? Add<AntichainConstraint>() : Add<IndependentSetConstraint>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x68(%rax)
je 0xaf088
movq -0x10(%rbp), %rdi
callq 0xb6040
movl %eax, -0x14(%rbp)
jmp 0xaf094
movq -0x10(%rbp), %rdi
callq 0xb61e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x160e0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x3a(%rbp), %rcx
callq 0x1cea0
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x5a(%rbp), %rdi
callq 0x160e0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x5a(%rbp), %rcx
callq 0x16120
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb0a00
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd %xmm0, (%rcx)
movq 0x18(%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb0490
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x32(%rbp), %rdi
callq 0x160e0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x32(%rbp), %rcx
callq 0x1cea0
movq -0x80(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x52(%rbp), %rdi
callq 0x160e0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x52(%rbp), %rcx
callq 0x16120
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xb15a0
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xb15f0
movb $0x1, %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x160e0
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x3a(%rbp), %rcx
callq 0x1cea0
movq -0xc0(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0xe0(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq -0x5a(%rbp), %rdi
callq 0x160e0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x5a(%rbp), %rcx
callq 0x1cea0
movq -0xc0(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x7a(%rbp), %rdi
callq 0x160e0
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x7a(%rbp), %rcx
callq 0x16120
movq -0xc0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb23e0
movb %al, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xb2410
leaq -0x78(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xb2460
movb $0x1, %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %r9
movq %r9, -0x208(%rbp)
movl 0x108(%r9), %eax
movl %eax, -0xc(%rbp)
movq %r9, %rsi
addq $0x88, %rsi
movq 0x30(%r9), %rdx
movq 0x38(%r9), %rcx
movq %r9, %r8
addq $0xe0, %r8
addq $0xc0, %r9
movq %rsp, %rax
movl $0x0, (%rax)
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0xc23e0
movq -0x208(%rbp), %rax
movq -0x200(%rbp), %rdi
movl 0x108(%rax), %esi
callq 0xc28c0
movl %eax, -0x1f4(%rbp)
jmp 0xb5a94
movq -0x208(%rbp), %r9
movl -0x1f4(%rbp), %ecx
movl 0x108(%r9), %eax
addl %ecx, %eax
movl %eax, 0x108(%r9)
movq %r9, %rsi
addq $0x88, %rsi
movq 0x30(%r9), %rcx
movq 0x38(%r9), %rdx
movq %r9, %r8
addq $0xe0, %r8
addq $0xc0, %r9
movq %rsp, %rax
movl $0x1, (%rax)
leaq -0x1f0(%rbp), %rdi
callq 0xc23e0
jmp 0xb5aeb
movq -0x208(%rbp), %rax
movl 0x108(%rax), %esi
leaq -0x1f0(%rbp), %rdi
callq 0xc28c0
movl %eax, -0x20c(%rbp)
jmp 0xb5b0c
movq -0x208(%rbp), %rax
movl -0x20c(%rbp), %ecx
addl 0x108(%rax), %ecx
movl %ecx, 0x108(%rax)
movl 0x108(%rax), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x210(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xb5bb0
leaq -0xf8(%rbp), %rdi
callq 0xb5bb0
movl -0x210(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xb5b8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0xb5bb0
leaq -0xf8(%rbp), %rdi
callq 0xb5bb0
movq -0x100(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movzbl -0x31(%rbp), %r10d
andl $0x1, %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0xc0550
movq -0x68(%rbp), %rdi
leaq 0xe403a(%rip), %rax     # 0x19f5c0
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
addq $0x78, %rax
movq %rax, 0x38(%rdi)
movl $0x0, 0x40(%rdi)
addq $0x58, %rdi
callq 0xbcd80
movq -0x68(%rbp), %rax
subq $-0x80, %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa8e00
cltq
movq %rax, -0x58(%rbp)
leaq -0x32(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x995b0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x995d0
jmp 0xbb5e0
leaq -0x32(%rbp), %rdi
callq 0x99610
movq -0x68(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x20(%rbp), %rdi
callq 0xa8e00
movl %eax, -0x6c(%rbp)
jmp 0xbb605
movq -0x68(%rbp), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, 0x50(%rax)
movl 0x50(%rax), %ecx
shll %ecx
addl $0x2, %ecx
movl %ecx, 0x54(%rax)
movl 0x54(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x48(%rax)
movl 0x54(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x4c(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x32(%rbp), %rdi
callq 0x99610
jmp 0xbb661
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x10160
movq -0x40(%rbp), %rdi
callq 0xa7c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbcda0
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x4, %rax
jae 0xbb724
movq -0x58(%rbp), %rax
leaq 0xa7(%rip), %rcx        # 0xbb780
movq %rcx, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0xbcdc0
jmp 0xbb700
jmp 0xbb702
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbb6c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbce70
jmp 0xbb768
movl $0x0, -0x50(%rbp)
movslq -0x50(%rbp), %rax
cmpq $0x4, %rax
jae 0xbb759
movslq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xbce50
movq %rax, %rdi
callq 0xa770
jmp 0xbb74c
jmp 0xbb74e
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0xbb72b
leaq -0x20(%rbp), %rdi
callq 0xbce70
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x68(%rbp), %rsi
addq $0x58, %rsi
leaq -0x30(%rbp), %rdi
callq 0xbced0
movq -0x68(%rbp), %rax
movslq 0xa8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
callq 0x99730
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jne 0xbb7f2
movl $0x3, -0x34(%rbp)
jmp 0xbb89a
movq -0x68(%rbp), %rcx
movl 0xa8(%rcx), %eax
movl %eax, %edx
incl %edx
movl %edx, 0xa8(%rcx)
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x99760
movq %rax, %rdi
callq 0x99a50
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x99760
movq %rax, %rdi
callq 0x99a80
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xbb910
movb %al, -0x71(%rbp)
jmp 0xbb86a
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xbb873
jmp 0xbb893
movl $0x2, -0x34(%rbp)
jmp 0xbb89a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbcf00
jmp 0xbb903
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbcf00
movl -0x34(%rbp), %eax
movl %eax, -0x78(%rbp)
testl %eax, %eax
je 0xbb8bf
jmp 0xbb8af
movl -0x78(%rbp), %eax
subl $0x2, %eax
je 0xbb7aa
jmp 0xbb8bd
jmp 0xbb8fa
movq -0x18(%rbp), %rdi
addq $0xf0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x99760
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
addq $0x90, %rdx
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdx
callq 0xbb970
jmp 0xbb7aa
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xa7c0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x4c(%rcx), %eax
jne 0xbbd9e
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbbf44
movq -0x60(%rbp), %rax
movq 0x38(%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0x993b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9e780
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9e610
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xbcf30
testb $0x1, %al
jne 0xbbde3
jmp 0xbbf29
leaq -0x40(%rbp), %rdi
callq 0x9ec20
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x9a090
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbbf19
movq -0x30(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x145d0
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x145d0
movq %rax, %rcx
movl -0x64(%rbp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0xbbf19
movl -0x4c(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x9a090
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x148e0
movq -0x60(%rbp), %rdi
movl -0x68(%rbp), %esi
movsd (%rax), %xmm0
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xbbd60
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbbea7
jp 0xbbea7
jmp 0xbbf17
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x9a090
movsd -0x78(%rbp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x4c(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x9a090
movsd -0x70(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbbf44
jmp 0xbbf19
jmp 0xbbf1b
leaq -0x40(%rbp), %rdi
callq 0xbcf70
jmp 0xbbdcd
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x145d0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xbcf90
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
addq $0x48, %rsi
callq 0xbcfc0
jmp 0xbbfab
movq -0xb8(%rbp), %rax
movq -0x18(%rbp), %rdi
movslq 0x48(%rax), %rsi
callq 0x145d0
movl $0x0, (%rax)
leaq -0x70(%rbp), %rdi
callq 0xbcff0
movb %al, -0xb9(%rbp)
jmp 0xbbfd6
movb -0xb9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xbbfe7
jmp 0xbc156
leaq -0x70(%rbp), %rdi
callq 0xbd010
movq %rax, -0xc8(%rbp)
jmp 0xbbff9
movq -0xc8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbd030
jmp 0xbc010
movq -0xb8(%rbp), %rcx
movl -0x80(%rbp), %eax
cmpl 0x4c(%rcx), %eax
jne 0xbc04c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0xbc164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbd050
jmp 0xbc17b
movq -0xb8(%rbp), %rax
movq 0x38(%rax), %rdi
movslq -0x80(%rbp), %rsi
callq 0x993b0
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0x9e780
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
callq 0x9e610
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xbcf30
testb $0x1, %al
jne 0xbc0a9
jmp 0xbc151
leaq -0x98(%rbp), %rdi
callq 0x9ec20
movl (%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xa4(%rbp), %rsi
callq 0x145d0
cmpl $-0x1, (%rax)
jne 0xbc13e
movq -0x20(%rbp), %rdi
movslq -0x80(%rbp), %rsi
callq 0x9a070
movq %rax, %rdi
movslq -0xa4(%rbp), %rsi
callq 0x9a090
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xbc13e
movq -0x18(%rbp), %rdi
movslq -0x80(%rbp), %rsi
callq 0x145d0
movl (%rax), %eax
incl %eax
movl %eax, -0xcc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xa4(%rbp), %rsi
callq 0x145d0
movl -0xcc(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x70(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
callq 0xbcfc0
jmp 0xbc13c
jmp 0xbc13e
jmp 0xbc140
leaq -0x98(%rbp), %rdi
callq 0xbcf70
jmp 0xbc08d
jmp 0xbbfc5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xbd050
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbbf60
testb $0x1, %al
jne 0xbc1cb
jmp 0xbc248
jmp 0xbc1cd
movq -0x48(%rbp), %rdi
movl 0x48(%rdi), %esi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movsd 0x4f1bc(%rip), %xmm0    # 0x10b3a0
callq 0xbbd60
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbc200
jp 0xbc200
jmp 0xbc211
movsd -0x28(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xbc1cd
movq -0x10(%rbp), %rdi
callq 0x9e780
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e610
movq %rax, -0x38(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xbd070
jmp 0xbc1b4
movsd -0x20(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc0090
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfea0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc0680
testb $0x1, %al
jne 0xc0610
jmp 0xc066b
leaq -0x28(%rbp), %rdi
callq 0xc0530
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0xbd650
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
je 0xc065e
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movsd 0x4d620(%rip), %xmm0    # 0x10dc68
movsd %xmm0, -0x48(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0xb4c70
jmp 0xc0660
leaq -0x28(%rbp), %rdi
callq 0xc06c0
jmp 0xc05fd
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: canzarlab[P]Trajan/src/IndependentSetConstraint.cpp
// Function: IndependentSetConstraint::DFSLeft(newick_node*, newick_node*, double)
void IndependentSetConstraint::DFSLeft(newick_node* nodel, newick_node* noder, double w)
{
    if (!nodel->child)
        D[nodel->taxoni][noder->taxoni] = w + GetWeight(nodel, noder);
    for (newick_child* child = nodel->child; child; child = child->next)
        DFSLeft(child->node, noder, w + GetWeight(nodel, noder));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc0e25
movq -0x30(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc0f90
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x38, %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x9a070
movq %rax, %rdi
movq -0x18(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x9a090
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc0e90
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc0f90
movq -0x30(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0xc0da0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc0e30
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::DFSLeft(newick_node*, std::vector<bool, std::allocator<bool>>&)
void CrossingConstraint::DFSLeft(newick_node* node, vb& C)
{
    C[node->taxoni] = true;
    for (newick_child* child = node->child; child; child = child->next)
    {
        PA[child->node->taxoni]++;
        if (!C[child->node->taxoni])
            DFSLeft(child->node, C);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xc27c8
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x145d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x99810
xorb $-0x1, %al
testb $0x1, %al
jne 0xc27a4
jmp 0xc27b8
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc2700
jmp 0xc27ba
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc274e
addq $0x50, %rsp
popq %rbp
retq
nop
// File: canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::RunParallel()
void CrossingConstraint::RunParallel()
{
    const size_t NR_THREADS = min(::NR_THREADS, size_t(64));
    ax = (NR_THREADS < 64 ? (uint64_t(1) << NR_THREADS) - 1 : ~0);
    vector<thread> vt;
    for (int i = 0; i < NR_THREADS; ++i)
        vt.emplace_back(&CrossingConstraint::CrossingJob, this, i);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $0x4, -0x10(%rbp)
addq $0x38, %rdi
movl $0xf, %esi
callq 0xc32c0
leaq -0x28(%rbp), %rdi
callq 0xbcda0
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq $0x4, %rax
jae 0xc286a
movq -0x60(%rbp), %rax
leaq 0x3f1(%rip), %rcx       # 0xc2c10
movq %rcx, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0xc3360
jmp 0xc2846
jmp 0xc2848
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc280a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xbce70
jmp 0xc28ae
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
cmpq $0x4, %rax
jae 0xc289f
movslq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xbce50
movq %rax, %rdi
callq 0xa770
jmp 0xc2892
jmp 0xc2894
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xc2871
leaq -0x28(%rbp), %rdi
callq 0xbce70
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa7c0
nopw (%rax,%rax)