LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::TransitiveClosure(newick_node*, newick_node*, std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>>&)
void Graph::TransitiveClosure(newick_node* node, newick_node* rnode, vvb& C)
{
    int l = rnode->taxoni;
    int i = node->taxoni;
    if (l != i)
    {
        D[l][i] = true;
        Relation(l, i);
    }

    C[i][l] = true;
    for (newick_parent* parent = node->parent; parent; parent = parent->next)
    {
        newick_node* pn = parent->node;
        int pnt = pn->taxoni;
        if (!C[pnt][l])
            TransitiveClosure(pn, rnode, C);
        if (!C[pnt][pnt])
            TransitiveClosure(pn, pn, C);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq %rdx, 0x8(%rsp)
movslq 0x28(%rdx), %r12
movslq 0x28(%rsi), %rbp
cmpl %ebp, %r12d
je 0x2eb0c
movq (%rsp), %rdi
movq 0x50(%rdi), %rax
leaq (%r12,%r12,4), %rcx
leal 0x3f(%rbp), %edx
testl %ebp, %ebp
cmovnsl %ebp, %edx
sarl $0x6, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq (%rax,%rcx,8), %rdx
leaq 0x3f(%r8), %rax
andq %rbp, %rax
xorl %esi, %esi
cmpq %r8, %rax
setbe %sil
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
orq %rax, -0x8(%rdx,%rsi,8)
movq (%rdi), %rax
movl %r12d, %esi
movl %ebp, %edx
callq *0x28(%rax)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq (%rbx), %rax
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
leal 0x3f(%r12), %edx
testl %r12d, %r12d
cmovnsl %r12d, %edx
sarl $0x6, %edx
movslq %edx, %rdx
movq %rdx, 0x20(%rsp)
leaq (,%rdx,8), %rdx
addq (%rax,%rcx,8), %rdx
leaq 0x3f(%r8), %rax
movq %r12, %rcx
movq %rax, 0x18(%rsp)
andq %rax, %rcx
xorl %eax, %eax
cmpq %r8, %rcx
setbe %al
movl $0x1, %r13d
movl %r12d, %ecx
shlq %cl, %r13
orq %r13, -0x8(%rdx,%rax,8)
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x2ec24
leaq -0x8(,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %r12
movslq 0x28(%r12), %r14
movq (%rbx), %rax
leaq (%r14,%r14,4), %rbp
movq (%rax,%rbp,8), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rdx
testq %r13, (%rdx,%rcx)
jne 0x2ebcb
movq (%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x2ea82
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
leal 0x3f(%r14), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
leaq (%rax,%rcx,8), %rax
movq %r14, %rcx
andq 0x18(%rsp), %rcx
xorl %edx, %edx
cmpq %r8, %rcx
setbe %dl
movq -0x8(%rax,%rdx,8), %rax
btq %r14, %rax
jb 0x2ec17
movq (%rsp), %rdi
movq %r12, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2ea82
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x2eb7f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movslq %esi, %rsi
movslq %edx, %r15
movq 0x70(%rdi), %rax
xorl %ecx, %ecx
leaq (%rsi,%rsi,2), %rsi
leaq (,%rax,8), %rdi
movabsq $0x7ff0000000000000, %r8 # imm = 0x7FF0000000000000
movq 0x90(%r14,%rcx), %r9
movq (%r9,%rsi,8), %r9
addq %rdi, %r9
movq %r8, (%r9,%r15,8)
addq $0x18, %rcx
cmpq $0x60, %rcx
jne 0x2ee22
movq 0x78(%r14), %rcx
leaq (%rcx,%rsi,8), %rdi
addl %eax, %edx
movl %edx, 0x8(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2ee63
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x2ee75
leaq 0x8(%rsp), %rdx
callq 0x305f8
movq 0x70(%r14), %rax
movq 0x78(%r14), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2ee9b
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x2eea5
leaq 0xc(%rsp), %rdx
callq 0x304d8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movslq 0x28(%rsi), %rcx
leal 0x3f(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq (%rdx), %rax
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
leaq 0x3f(%r8), %rdx
andq %rcx, %rdx
xorl %esi, %esi
cmpq %r8, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
movq %rdi, %r12
orq %rdx, -0x8(%rax,%rsi,8)
movq 0x38(%rdi), %rax
movslq 0x70(%rax), %rsi
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x10(%rsp), %rbp
leaq 0xe(%rsp), %rcx
movq %rbp, %rdi
callq 0x306d4
movq 0x38(%r12), %rax
movq 0x68(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rcx
movq %r14, %rbp
movq %r14, %r8
movq %rbx, %r14
movq %rbx, %r9
callq 0x3220c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x318d5
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq (%r13), %r13
testq %r13, %r13
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
je 0x31948
leaq 0x3f(%r8), %rbx
movq (%r13), %rsi
movslq 0x28(%rsi), %rax
leal 0x3f(%rax), %ecx
testq %rax, %rax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq (%r15), %rcx
movq %rax, %rdx
andq %rbx, %rdx
xorl %edi, %edi
cmpq %r8, %rdx
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
jb 0x3193f
movq %r12, %rdi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0x3181c
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x318ec
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x3196e
leaq 0x10(%rsp), %rdi
callq 0x98bc
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq 0xa0(%rdi), %r15
movq 0xa8(%rdi), %r14
cmpq %r14, %r15
je 0x31e3a
leaq 0xb8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %r13
movq %r15, %r12
movq 0xb8(%rbx), %rdi
movq 0xc0(%rbx), %rbp
leaq 0x114(%rip), %rax       # 0x31ec6
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq %r12, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
movq %rbp, %rsi
movq %r13, %rdx
callq 0x334ff
cmpq %rbp, %rax
jne 0x31e29
movq 0xc0(%rbx), %rsi
cmpq 0xc8(%rbx), %rsi
je 0x31dfb
movups (%r15), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0xc0(%rbx)
jmp 0x31e08
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x33694
movsd (%r15), %xmm0
movslq 0xc(%r15), %rax
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movslq 0x8(%r15), %rdx
movq (%rcx,%rax,8), %rax
movsd %xmm0, (%rax,%rdx,8)
addq $0x10, %r15
addq $0x10, %r12
cmpq %r14, %r15
jne 0x31d9d
leaq 0x3c025(%rip), %rsi     # 0x6de66
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x31e95
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xda46
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x31e95
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9350
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x31ebe
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9350
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movl $0x10, %edx
callq 0x9710
movq 0x30(%rbx), %rax
movq 0x68(%rax), %rsi
movl 0x70(%rax), %edx
leaq 0x30(%rsp), %rdi
callq 0x3ca09
movq 0x38(%rbx), %rax
movq 0x68(%rax), %rsi
movl 0x70(%rax), %edx
leaq 0x18(%rsp), %rdi
callq 0x3ca09
movq 0xb8(%rbx), %rbp
movq %rbx, 0x10(%rsp)
movq 0xc0(%rbx), %rbx
xorpd %xmm0, %xmm0
cmpq %rbx, %rbp
je 0x31fd7
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rsp), %r14
leaq 0x2a30b(%rip), %r15     # 0x5c262
leaq 0x3be21(%rip), %r12     # 0x6dd7f
movslq 0xc(%rbp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x93b0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x93b0
movslq 0x8(%rbp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r13, %rdi
callq 0x93b0
movl $0x3, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x93b0
movsd 0x8(%rsp), %xmm0
addsd (%rbp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x10, %rbp
cmpq %rbx, %rbp
jne 0x31f5e
jmp 0x31fdd
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x33c98
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x32004
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3201b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x53f7e(%rip), %rax     # 0x85fa0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x92d0
leaq 0x140(%rsp), %rdi
callq 0x9110
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3206b
movq %rax, %rbx
jmp 0x32085
movq %rax, %rbx
jmp 0x3209c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x32085
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3209c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
leaq 0x48(%rsp), %rdi
callq 0x9510
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52516(%rip), %rax     # 0x8640c
cmpb $0x1, (%rax)
jne 0x33f0d
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34116
xorl %eax, %eax
leaq 0x14(%rsp), %r14
movl %eax, (%r14)
leaq 0x10(%rsp), %r15
movl %eax, (%r15)
movq 0x30(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x33f70
movl %eax, %ebp
movq 0x38(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x33f70
movl (%r14), %ecx
addl %ebp, %eax
subl %eax, %ecx
addl (%r15), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x33fb4
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq (%r12), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x33f70
addl %eax, %ebp
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x33f8b
cmpq $0x0, (%r14)
movl $0x1, %eax
cmovnel %ebp, %eax
jmp 0x33fbb
xorl %ebp, %ebp
movl $0x1, %eax
addl %ebp, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, 0x18(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x30(%rcx)
je 0x3402a
cmpq $0x0, (%rcx)
je 0x3406f
leaq 0x20(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2f808
movq %rax, %r12
leaq 0x20(%rbx), %rdi
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x2f808
movq %r12, %rdi
movq %rax, %rsi
callq 0x45cbb
movapd %xmm0, %xmm1
movq (%r13), %rcx
jmp 0x3402e
xorpd %xmm1, %xmm1
movq (%rcx), %r12
testq %r12, %r12
je 0x34069
movsd %xmm1, 0x10(%rsp)
movq (%r12), %rcx
movq 0x8(%rsp), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x33fc6
maxsd 0x10(%rsp), %xmm0
movq 0x8(%r12), %r12
movapd %xmm0, %xmm1
testq %r12, %r12
jne 0x34036
jmp 0x34073
movapd %xmm1, %xmm0
jmp 0x34073
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x30(%rcx)
movq (%rcx), %r13
je 0x340c5
testq %r13, %r13
je 0x34104
movq %rcx, %r12
movq 0x68(%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq 0x33fc6
movq (%r12), %r13
jmp 0x340fd
xorpd %xmm0, %xmm0
jmp 0x340fd
movsd %xmm0, 0x8(%rsp)
movq (%r13), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34082
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x340cb
jmp 0x34108
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl %ecx, %eax
cmpl %edx, %esi
sete %cl
cmpl %r8d, %eax
sete %r9b
orb %cl, %r9b
je 0x34192
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x52265(%rip), %rcx     # 0x86408
movl (%rcx), %r9d
testl %r9d, %r9d
je 0x34339
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq 0x30(%rdi), %rcx
movslq %edx, %r10
movq 0x50(%rcx), %r11
leaq (%r10,%r10,4), %rcx
leal 0x3f(%rsi), %ebp
testl %esi, %esi
cmovnsl %esi, %ebp
sarl $0x6, %ebp
movslq %ebp, %r14
shlq $0x3, %r14
addq (%r11,%rcx,8), %r14
movslq %esi, %rcx
leaq 0x3f(%r13), %r15
andq %rcx, %r15
xorl %r12d, %r12d
cmpq %r13, %r15
setbe %r12b
movq -0x8(%r14,%r12,8), %r14
movl $0x1, %ebp
btq %rsi, %r14
leaq (%rcx,%rcx,4), %rbx
movl $0x1, %r14d
jb 0x34243
leal 0x3f(%rdx), %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq (%r11,%rbx,8), %rcx
leaq 0x3f(%r13), %rsi
andq %r10, %rsi
xorl %r14d, %r14d
cmpq %r13, %rsi
setbe %r14b
movq -0x8(%rcx,%r14,8), %rcx
xorl %r14d, %r14d
btq %r10, %rcx
setb %r14b
movq %rbx, -0x10(%rsp)
movq %r11, -0x8(%rsp)
movq 0x38(%rdi), %rcx
movslq %eax, %r15
movq 0x50(%rcx), %r12
leaq (%r15,%r15,4), %rcx
movslq %r8d, %rsi
leal 0x3f(%r8), %edi
testl %r8d, %r8d
cmovnsl %r8d, %edi
sarl $0x6, %edi
movslq %edi, %rbx
shlq $0x3, %rbx
addq (%r12,%rcx,8), %rbx
leaq 0x3f(%r13), %rdi
movq %rsi, %rcx
andq %rdi, %rcx
xorl %r11d, %r11d
cmpq %r13, %rcx
setbe %r11b
movl $0x1, %r13d
movl %r8d, %ecx
shlq %cl, %r13
andq -0x8(%rbx,%r11,8), %r13
jne 0x342e1
leal 0x3f(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
leaq (%rsi,%rsi,4), %rax
sarl $0x6, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq (%r12,%rax,8), %rcx
movq %r15, %rax
andq %rdi, %rax
xorl %esi, %esi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
cmpq %r8, %rax
setbe %sil
movq -0x8(%rcx,%rsi,8), %rax
xorl %ebp, %ebp
btq %r15, %rax
setb %bpl
testq %r13, %r13
sete %cl
leal 0x3f(%rdx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
movq -0x8(%rsp), %rdx
movq -0x10(%rsp), %rsi
addq (%rdx,%rsi,8), %rax
andq %r10, %rdi
xorl %edx, %edx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rsi, %rdi
setbe %dl
movq -0x8(%rax,%rdx,8), %rax
btq %r10, %rax
setb %al
xorb %cl, %al
cmpl $0x1, %r9d
jne 0x3433d
cmpl %ebp, %r14d
setne %cl
orb %cl, %al
jmp 0x34347
movb $0x1, %al
jmp 0x34347
cmpl %ebp, %r14d
sete %cl
andb %al, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x68, %rsp
movq 0x30(%rdi), %r12
testq %r12, %r12
js 0x36834
movq %rdi, %r15
movq 0x18(%rdi), %rax
cmpq %r12, 0x8(%rax)
jne 0x36853
movq %rcx, %rbx
movq %rdx, %r14
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %r12, 0x18(%rsp)
testq %r12, %r12
je 0x3679c
movq (%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq %rsi, 0x18(%rdi)
movq %r12, 0x28(%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x30(%rdi)
leaq 0x7(%rsp), %rsi
callq 0x36b42
movq 0x18(%r15), %rax
jmp 0x3679f
xorps %xmm0, %xmm0
movsd %xmm0, (%r14)
cmpq 0x8(%rax), %r12
jne 0x36872
movq %r12, %rcx
testb $0x7, %bl
jne 0x367c5
movl %ebx, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %r12, %rcx
cmovaeq %r12, %rcx
movq (%rax), %rax
movq %r12, %rsi
subq %rcx, %rsi
movq %rsi, %rdx
shrq $0x3f, %rdx
addq %rsi, %rdx
andq $-0x2, %rdx
testq %rcx, %rcx
je 0x367f5
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x367e3
addq %rcx, %rdx
cmpq $0x2, %rsi
jl 0x3680f
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rbx,%rcx,8)
addq $0x2, %rcx
cmpq %rdx, %rcx
jl 0x367fe
cmpq %r12, %rdx
jge 0x36826
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x36814
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2636c(%rip), %rdi     # 0x5cba7
leaq 0x260e2(%rip), %rsi     # 0x5c924
leaq 0x26f15(%rip), %rcx     # 0x5d75e
movl $0xa3, %edx
callq 0x9200
leaq 0x2749c(%rip), %rdi     # 0x5dcf6
leaq 0x274ac(%rip), %rsi     # 0x5dd0d
leaq 0x3771f(%rip), %rcx     # 0x6df87
movl $0x52, %edx
callq 0x9200
leaq 0x27afc(%rip), %rdi     # 0x5e375
leaq 0x27b5e(%rip), %rsi     # 0x5e3de
leaq 0x37675(%rip), %rcx     # 0x6defc
movl $0x101, %edx            # imm = 0x101
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x30, %rsp
movq 0x30(%rdi), %rax
testq %rax, %rax
js 0x36981
movq 0x38(%rdi), %r15
testq %r15, %r15
js 0x36998
movq 0x8(%rdi), %rcx
movq %rcx, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpq %rax, 0x8(%rcx)
jne 0x369b7
movq %rdx, %rbx
leaq 0x20(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x36c2e
cmpq 0x8(%r14), %r15
jne 0x369d6
movq %r15, %rax
testb $0x7, %bl
jne 0x3690d
movl %ebx, %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpq %r15, %rax
cmovaeq %r15, %rax
movq 0x20(%rsp), %rdi
movq %r15, %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x3f, %rcx
addq %rdx, %rcx
andq $-0x2, %rcx
testq %rax, %rax
je 0x3693f
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3692d
addq %rax, %rcx
cmpq $0x2, %rdx
jl 0x36959
movups (%rdi,%rax,8), %xmm0
movaps %xmm0, (%rbx,%rax,8)
addq $0x2, %rax
cmpq %rcx, %rax
jl 0x36948
cmpq %r15, %rcx
jge 0x36970
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x3695e
callq 0x93d0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2621f(%rip), %rdi     # 0x5cba7
leaq 0x25f95(%rip), %rsi     # 0x5c924
leaq 0x26dc8(%rip), %rcx     # 0x5d75e
jmp 0x369ad
leaq 0x26208(%rip), %rdi     # 0x5cba7
leaq 0x25f7e(%rip), %rsi     # 0x5c924
leaq 0x26207(%rip), %rcx     # 0x5cbb4
movl $0xa3, %edx
callq 0x9200
leaq 0x27d8e(%rip), %rdi     # 0x5e74c
leaq 0x27e13(%rip), %rsi     # 0x5e7d8
leaq 0x37707(%rip), %rcx     # 0x6e0d3
movl $0x61, %edx
callq 0x9200
leaq 0x27998(%rip), %rdi     # 0x5e375
leaq 0x279fa(%rip), %rsi     # 0x5e3de
leaq 0x37511(%rip), %rcx     # 0x6defc
movl $0x101, %edx            # imm = 0x101
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x40, %rsp
movq 0x30(%rdi), %r15
testq %r15, %r15
js 0x36ae5
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x36ae5
movq %rcx, %rbx
movq 0x8(%rdi), %rcx
movb $0x0, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
cmpq %rax, 0x10(%rcx)
jne 0x36b04
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36dd6
cmpq 0x8(%r14), %r15
jne 0x36b23
movq %r15, %rax
testb $0x7, %bl
jne 0x36a71
movl %ebx, %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpq %r15, %rax
cmovaeq %r15, %rax
movq 0x30(%rsp), %rdi
movq %r15, %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x3f, %rcx
addq %rdx, %rcx
andq $-0x2, %rcx
testq %rax, %rax
je 0x36aa3
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x36a91
addq %rax, %rcx
cmpq $0x2, %rdx
jl 0x36abd
movups (%rdi,%rax,8), %xmm0
movaps %xmm0, (%rbx,%rax,8)
addq $0x2, %rax
cmpq %rcx, %rax
jl 0x36aac
cmpq %r15, %rcx
jge 0x36ad4
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x36ac2
callq 0x93d0
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x260bb(%rip), %rdi     # 0x5cba7
leaq 0x25e31(%rip), %rsi     # 0x5c924
leaq 0x26c64(%rip), %rcx     # 0x5d75e
movl $0xa3, %edx
callq 0x9200
leaq 0x27c41(%rip), %rdi     # 0x5e74c
leaq 0x27cc6(%rip), %rsi     # 0x5e7d8
leaq 0x376a1(%rip), %rcx     # 0x6e1ba
movl $0x61, %edx
callq 0x9200
leaq 0x2784b(%rip), %rdi     # 0x5e375
leaq 0x278ad(%rip), %rsi     # 0x5e3de
leaq 0x373c4(%rip), %rcx     # 0x6defc
movl $0x101, %edx            # imm = 0x101
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, (%rsp)
leaq 0xf0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %r8
movq %r12, %r9
callq 0x3b3dc
movl 0x108(%rbx), %esi
movq %r13, %rdi
callq 0x3b70e
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 0x3b3dc
movl 0x108(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x3b70e
movl %eax, %ebp
addl 0x108(%rbx), %ebp
movl %ebp, 0x108(%rbx)
leaq 0x4cbad(%rip), %r14     # 0x846c0
addq $0x10, %r14
leaq 0xd8(%rsp), %rbx
movq %r14, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x2f65a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x37b47
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
leaq 0x70(%rsp), %rdi
callq 0x37c14
leaq 0x1c0(%rsp), %rbx
movq %r14, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x2f65a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x37b81
movq 0x1b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
subl %r13d, %ebp
leaq 0x158(%rsp), %rdi
callq 0x37c14
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 0x37bce
jmp 0x37bb9
jmp 0x37bb6
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x37bce
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
callq 0x3ab58
leaq 0x4b0f9(%rip), %rax     # 0x845e8
movq %rax, (%rbx)
leaq 0x78(%r14), %rax
movq %rax, 0x38(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movslq 0x70(%r15), %rsi
leaq 0x17(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x16(%rsp), %rcx
callq 0x306d4
movl %ebp, 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 $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%r14)
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
leaq 0x86(%rip), %rbp        # 0x39630
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x3a2f8
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jb 0x395b4
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x9630
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x395e9
leaq 0x20(%rsp), %rdi
callq 0x3a340
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3961b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3a340
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movapd %xmm0, %xmm1
cmpl %esi, 0x4c(%rdi)
je 0x39e76
movq 0x38(%rdi), %rax
movslq %esi, %rsi
movq (%rax), %rax
leaq (%rsi,%rsi,2), %r9
movq (%rax,%r9,8), %r15
movq 0x8(%rax,%r9,8), %r14
cmpq %r14, %r15
je 0x39e68
movq 0x18(%rsp), %rax
movq (%rax), %rax
xorpd %xmm2, %xmm2
movsd %xmm1, 0x20(%rsp)
movq %rsi, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x18(%rsp), %rbx
movslq (%r15), %r12
movq (%rax,%r9,8), %rdx
movsd (%rdx,%r12,8), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x39e5f
movq (%rcx), %r8
movl (%r8,%rsi,4), %edx
incl %edx
cmpl %edx, (%r8,%r12,4)
jne 0x39e5f
minsd %xmm1, %xmm0
movq %rdi, %rbp
movl %r12d, %esi
movq %rbx, %rdx
movq %rcx, %r13
callq 0x39da2
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movq (%rbx), %rax
jne 0x39e89
jp 0x39e89
movsd 0x20(%rsp), %xmm1
movq 0x10(%rsp), %rsi
movq %r13, %rcx
movq %rbp, %rdi
movq 0x8(%rsp), %r9
addq $0x4, %r15
cmpq %r14, %r15
jne 0x39e03
movq (%rcx), %rax
movl $0xffffffff, (%rax,%rsi,4) # imm = 0xFFFFFFFF
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movsd (%rcx,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r12,8)
leaq (%r12,%r12,2), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %r14
movsd (%rax,%r14,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r14,8)
movapd %xmm0, %xmm1
jmp 0x39e76
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movapd %xmm0, 0x40(%r13)
movapd %xmm0, 0x30(%r13)
movapd %xmm0, 0x20(%r13)
movapd %xmm0, 0x10(%r13)
movapd %xmm0, (%r13)
movq %r13, %rdi
xorl %esi, %esi
callq 0x3a67c
leaq 0x48(%r15), %r12
movq 0x30(%r13), %rcx
movq 0x40(%r13), %rax
addq $-0x4, %rax
cmpq %rax, %rcx
je 0x39f34
movl (%r12), %eax
movl %eax, (%rcx)
addq $0x4, %rcx
movq %rcx, 0x40(%rsp)
jmp 0x39f4a
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x3a7f2
movl (%r12), %eax
movq 0x40(%rsp), %rcx
cltq
movq (%r14), %rdx
movl $0x0, (%rdx,%rax,4)
movq 0x20(%rsp), %rax
cmpq %rax, %rcx
je 0x3a063
movq %r15, 0x60(%rsp)
movslq (%rax), %r12
movq 0x30(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x39f80
addq $0x4, %rax
jmp 0x39fb2
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x9350
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
cmpl 0x4c(%r15), %r12d
sete %cl
je 0x3a06d
movl %ecx, 0x8(%rsp)
movq 0x38(%r15), %rcx
movq (%rcx), %rcx
leaq (%r12,%r12,2), %r13
movq (%rcx,%r13,8), %r15
movq 0x8(%rcx,%r13,8), %rbp
cmpq %rbp, %r15
je 0x3a051
movslq (%r15), %rax
movl %eax, 0xc(%rsp)
movq (%r14), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x3a043
movq (%rbx), %rdx
movq (%rdx,%r13,8), %rdx
movsd (%rdx,%rax,8), %xmm0
ucomisd 0x2241b(%rip), %xmm0    # 0x5c420
jbe 0x3a043
movl (%rcx,%r12,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x3a034
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rsp)
jmp 0x3a043
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3a7f2
addq $0x4, %r15
cmpq %rbp, %r15
jne 0x39fe1
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
movq 0x60(%rsp), %r15
jne 0x39f69
jmp 0x3a073
movl $0x0, 0x8(%rsp)
jmp 0x3a073
movb $0x1, %al
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3a3b8
movl 0x8(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a092
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3a3b8
movq %rbx, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x39ec6
xorpd %xmm0, %xmm0
testb %al, %al
je 0x3a144
movsd %xmm0, 0x8(%rsp)
movl 0x48(%r15), %esi
movq %r15, %rdi
movsd 0x22324(%rip), %xmm0    # 0x5c400
movq %rbx, %rdx
movq %r14, %rcx
callq 0x39da2
ucomisd 0x22331(%rip), %xmm0    # 0x5c420
jne 0x3a12c
jp 0x3a12c
movq (%r14), %rdi
movq 0x8(%r14), %rdx
cmpq %rdx, %rdi
je 0x3a118
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x91c0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x39ec6
testb %al, %al
jne 0x3a0cd
jmp 0x3a13e
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
jmp 0x3a0cd
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movslq 0x50(%rdi), %rax
testq %rax, %rax
jle 0x3a2c5
movslq 0x4c(%rdi), %rcx
movq (%rdx), %rdx
leaq (%rcx,%rcx,2), %r8
movq (%rdx,%r8,8), %r8
movq %r8, 0x20(%rsp)
movslq 0x48(%rdi), %r8
movq %r8, 0x18(%rsp)
leaq (%r8,%r8,2), %r8
movq (%rdx,%r8,8), %r10
movq 0x38(%rdi), %r8
movq (%r8), %r11
movq (%rsi), %r8
movq %r8, (%rsp)
movq 0x8(%rsi), %rsi
movb 0x30(%rdi), %bpl
movq %rdi, 0x10(%rsp)
movq 0x20(%rdi), %rdi
movq %rdi, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
leaq (%r12,%rax), %r8
movq 0x20(%rsp), %rdi
xorl %ebx, %ebx
movq %rbx, (%rdi,%r8,8)
leaq (%r12,%r12,2), %r9
movq (%rdx,%r9,8), %r9
movq 0x18(%rsp), %rdi
movq %rbx, (%r9,%rdi,8)
movq %rbx, (%r10,%r12,8)
leaq (%r8,%r8,2), %r8
movq (%r11,%r8,8), %r9
movq 0x8(%r11,%r8,8), %rbx
cmpq %rbx, %r9
je 0x3a207
movq (%rdx,%r8,8), %r14
movslq (%r9), %r13
movq $0x0, (%r14,%r13,8)
addq $0x4, %r9
cmpq %rbx, %r9
jne 0x3a1f3
cmpq %rsi, (%rsp)
je 0x3a2b1
movq 0x8(%rsp), %rdi
movq (%rdi), %r13
movq 0x10(%rsp), %rdi
movq 0x28(%rdi), %r14
leaq (%rdx,%r8,8), %r8
movq (%rsp), %rbx
movq (%rbx), %r9
movl 0x28(%r9), %r9d
testb $0x1, %bpl
movl %r9d, %r15d
cmovnel %r12d, %r15d
cmovel %r12d, %r9d
movslq %r15d, %r15
leaq (%r15,%r15,2), %r15
movslq %r9d, %r9
movq (%r13,%r15,8), %r15
movslq (%r15,%r9,4), %r9
cmpq $-0x1, %r9
je 0x3a281
testl %r9d, %r9d
js 0x3a2d8
cmpq %r9, 0x8(%r14)
jle 0x3a2d8
movq (%r14), %r15
movsd (%r15,%r9,8), %xmm1
addsd (%r10,%r12,8), %xmm1
movsd %xmm1, (%r10,%r12,8)
movsd (%r15,%r9,8), %xmm1
jmp 0x3a295
xorpd %xmm1, %xmm1
movsd (%r10,%r12,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%r10,%r12,8)
movq (%r8), %r9
addsd (%r9,%rcx,8), %xmm1
movsd %xmm1, (%r9,%rcx,8)
addq $0x8, %rbx
cmpq %rsi, %rbx
jne 0x3a22a
addsd (%r10,%r12,8), %xmm0
incq %r12
cmpq %rax, %r12
jne 0x3a1b9
jmp 0x3a2c9
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22f66(%rip), %rdi     # 0x5d245
leaq 0x22f7c(%rip), %rsi     # 0x5d262
leaq 0x22f98(%rip), %rcx     # 0x5d285
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %esi, 0xc(%rsp)
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x3ac0d
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movl (%r13), %eax
movl 0x4(%r13), %ecx
movq 0x20(%rbx), %rdx
cmpb $0x0, 0x30(%rbx)
movl %eax, %esi
cmovnel %ecx, %esi
cmovnel %eax, %ecx
movq (%rdx), %rax
movslq %esi, %rdx
leaq (%rdx,%rdx,2), %rdx
movslq %ecx, %rcx
movq (%rax,%rdx,8), %rax
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
cmpl $-0x1, %eax
je 0x3ac04
movq 0x8(%rbx), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsp)
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x376dc
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3abae
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x30(%rsp)
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rsi
callq 0x3ae78
movq 0x10(%r14), %rax
movq 0x8(%rax), %rbp
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x3ae17
movq $0x0, 0x8(%rsp)
leaq 0x50(%rsp), %r12
leaq 0x10(%rsp), %r13
movq %r14, 0x28(%rsp)
movq (%rbp), %r15
movq 0x18(%r14), %rax
movq 0x68(%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3aeb6
movsd 0x48(%rsp), %xmm0
addsd 0x33de7(%rip), %xmm0    # 0x6eb20
movsd 0x216b7(%rip), %xmm1    # 0x5c3f8
ucomisd %xmm0, %xmm1
jae 0x3ade7
movq %rbp, 0x38(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x50(%rsp), %r14
cmpq %r12, %r14
je 0x3ada2
testq %r15, %r15
je 0x3ad9d
movq 0x10(%r14), %rbx
addq $0x28, %rbx
movq %r15, %rbp
leaq 0x28(%rbp), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x3a37c
movq 0x30(%rbp), %rax
testq %rax, %rax
je 0x3ad9d
movq (%rax), %rbp
testq %rbp, %rbp
jne 0x3ad7d
movq (%r14), %r14
jmp 0x3ad68
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
leal (%rcx,%rax), %esi
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
callq 0x3ab7e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x38(%rsp), %rbp
je 0x3addb
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ae06
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x9350
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x3adf1
addq $0x8, %rbp
cmpq 0x40(%rsp), %rbp
jne 0x3ad0f
jmp 0x3ae20
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ae36
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ae50
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ae6f
movq (%rdi), %r14
movl $0x18, %esi
callq 0x9350
movq %r14, %rdi
cmpq %r12, %r14
jne 0x3ae5a
movq %rbx, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x3b195
movq (%r12), %rsi
movl 0x28(%r15), %eax
movl 0x28(%r14), %ecx
movq 0x20(%rbx), %rdx
cmpb $0x0, 0x30(%rbx)
movq (%rdx), %rdx
movl %eax, %edi
cmovnel %ecx, %edi
cmovnel %eax, %ecx
movslq %edi, %rax
leaq (%rax,%rax,2), %rax
movslq %ecx, %rcx
movq (%rdx,%rax,8), %rax
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x3b175
testl %eax, %eax
js 0x3b208
movq 0x28(%rbx), %rcx
cmpq %rax, 0x8(%rcx)
jle 0x3b208
movq (%rcx), %rcx
movsd (%rcx,%rax,8), %xmm0
jmp 0x3b179
xorpd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3b100
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x3b11e
jmp 0x3b1fc
movslq 0x28(%r15), %rax
movslq 0x28(%r14), %rcx
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0x30(%rbx)
movl %eax, %esi
cmovnel %ecx, %esi
movl %ecx, %edi
cmovnel %eax, %edi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movslq %edi, %rdi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx,%rdi,4), %rdx
cmpq $-0x1, %rdx
je 0x3b1e2
testl %edx, %edx
js 0x3b208
movq 0x28(%rbx), %rsi
cmpq %rdx, 0x8(%rsi)
jle 0x3b208
movq (%rsi), %rsi
movsd (%rsi,%rdx,8), %xmm0
jmp 0x3b1e6
xorpd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq 0x38(%rbx), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movsd %xmm0, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22036(%rip), %rdi     # 0x5d245
leaq 0x2204c(%rip), %rsi     # 0x5d262
leaq 0x22068(%rip), %rcx     # 0x5d285
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::CrossingConstraint(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)
CrossingConstraint::CrossingConstraint(vector<ET>& Triplets, Graph& t1, Graph& t2, vvi& K, Vector& x, bool swp) : Constraint(Triplets, t1, t2, K, x, swp)
{
    DP.resize(t1.GetNumNodes());
    PA.resize(t1.GetNumNodes());
    for (auto& v : DP)
        v.resize(t2.GetNumNodes());

    vb C(t1.GetNumNodes());
    DFSLeft(t1.GetRoot(), C);
    Q.push(t1.GetRoot());
    RunParallel();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbp
movq %rdx, %r13
movq %rdi, %rbx
movzbl 0x90(%rsp), %eax
movl %eax, (%rsp)
callq 0x3ab58
leaq 0x492c6(%rip), %rax     # 0x846d0
movq %rax, (%rbx)
leaq 0x68(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movq $0x0, 0xb0(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3bdd2
leaq 0xb8(%rbx), %r15
leaq 0xd0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
movslq 0x70(%r13), %rsi
movq %rdi, 0x18(%rsp)
movq %r15, 0x20(%rsp)
callq 0x3bcea
movslq 0x70(%r13), %rsi
movq %r15, %rdi
callq 0x3bd26
movq 0xd0(%rbx), %r15
movq 0xd8(%rbx), %r12
cmpq %r12, %r15
je 0x3b4b8
movslq 0x70(%rbp), %rsi
movq %r15, %rdi
callq 0x3bd58
addq $0x18, %r15
jmp 0x3b4a1
movslq 0x70(%r13), %rsi
leaq 0x28(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x17(%rsp), %rcx
callq 0x306d4
movq 0x68(%r13), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x3b582
movq 0x68(%r13), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x3c2e2
movq %rbx, %rdi
callq 0x3b646
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3b517
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b528
movq %rax, %r13
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3b54b
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
jmp 0x3b54b
jmp 0x3b548
jmp 0x3b548
movq %rax, %r13
movq 0x18(%rsp), %rdi
callq 0x2f65a
movq 0x20(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3b571
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x9350
movq %r14, %rdi
callq 0x37c14
movq %r13, %rdi
callq 0x9680
nop