LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/IndependentSetConstraint.cpp
// Function: IndependentSetConstraint::DFSRight[abi:cxx11](newick_node*, newick_node*)
dLN IndependentSetConstraint::DFSRight(newick_node* nodel, newick_node* noder)
{
    double w = D[nodel->taxoni][noder->taxoni], sum = 0;
    LN V;

    for (newick_child* child = noder->child; child; child = child->next)
    {
        double ww;
        LN T;
        tie(ww, T) = DFSRight(nodel, child->node);
        sum += ww;
        V.splice(V.begin(), T);
    }

    if (sum > w)
        return make_pair(sum, V);
    return make_pair(w, LN(1, noder));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rcx, 0x50(%rsp)
movslq 0x28(%rdx), %rax
movq 0x38(%rsi), %rcx
imulq $0x18, %rax, %rax
movslq 0x28(%r14), %rdx
movq (%rcx,%rax), %rax
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rdi, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rbx
leaq 0x68(%rsp), %rbp
leaq 0x58(%rsp), %r13
movq (%r14), %r14
testq %r14, %r14
je 0x378db
movq %rbx, 0x20(%rsp)
movq %rbx, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
movq (%r14), %rcx
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x377f2
movq %rbx, 0x58(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x37a30
leaq 0x70(%rsp), %rdi
callq 0x37a86
movsd (%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x38(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0x37ca0
movq %rbx, %rdi
callq 0x37a86
addq $0x8, %r14
jmp 0x3785e
movsd (%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x37905
movq 0x8(%rsp), %r14
movsd %xmm0, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
leaq 0x38(%rsp), %rsi
callq 0x37ab0
jmp 0x37948
leaq 0x68(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x50(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x37a52
movq 0x8(%rsp), %r14
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
leaq 0x68(%rsp), %rbx
movq %rbx, %rsi
callq 0x37bea
movq %rbx, %rdi
callq 0x37a86
leaq 0x38(%rsp), %rdi
callq 0x37a86
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37969
movq %rax, %rbx
jmp 0x3797b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x37a86
leaq 0x38(%rsp), %rdi
callq 0x37a86
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rsi)
jne 0x379dd
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37a24
addsd 0x8(%rsp), %xmm0
movslq 0x28(%r14), %rax
movq 0x38(%r15), %rcx
imulq $0x18, %rax, %rax
movslq 0x28(%rbx), %rdx
movq (%rcx,%rax), %rax
movsd %xmm0, (%rax,%rdx,8)
movq %r14, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x37a15
movq (%r13), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37a24
addsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3798e
addq $0x8, %r13
jmp 0x379e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rcx, %rbp
movq %rdx, %r13
movq %rdi, %r12
movzbl 0x80(%rsp), %eax
movl %eax, (%rsp)
callq 0x37530
leaq 0x5d992(%rip), %rax     # 0x956c8
movq %rax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
movups %xmm0, 0x50(%r12)
andq $0x0, 0x60(%r12)
leaq 0x68(%r12), %rbx
movq %rbx, %rdi
callq 0x3835c
leaq 0xb8(%r12), %r14
leaq 0xd0(%r12), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%r12)
movups %xmm0, 0xc8(%r12)
movups %xmm0, 0xb8(%r12)
movslq 0x70(%r13), %rsi
movq %rdi, 0x8(%rsp)
movq %r14, 0x10(%rsp)
callq 0x38378
movslq 0x70(%r13), %rsi
movq %r14, %rdi
callq 0x383ae
movq 0xd0(%r12), %r14
movq 0xd8(%r12), %r15
cmpq %r15, %r14
je 0x37dd0
movslq 0x70(%rbp), %rsi
movq %r14, %rdi
callq 0x383e0
addq $0x18, %r14
jmp 0x37db9
movslq 0x70(%r13), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x2dd44
movq 0x68(%r13), %rsi
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
callq 0x37e66
movq 0x68(%r13), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x389c8
movq %r12, %rdi
callq 0x37ec8
leaq 0x20(%rsp), %rdi
callq 0xbdb2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37e2d
jmp 0x37e3e
movq %rax, %r12
leaq 0x20(%rsp), %rdi
callq 0xbdb2
jmp 0x37e41
jmp 0x37e3e
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0x2dd00
movq 0x10(%rsp), %rdi
callq 0xd85a
movq %rbx, %rdi
callq 0x34a8c
movq %r12, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x28(%rsi), %rsi
movq %rdx, %rdi
callq 0x2ddae
orq %rdx, (%rax)
movq (%r14), %r14
testq %r14, %r14
je 0x37ec1
movq (%r14), %rax
movslq 0x28(%rax), %rcx
movq 0xb8(%r15), %rdx
incl (%rdx,%rcx,4)
movslq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x37ebb
movq (%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x37e66
addq $0x8, %r14
jmp 0x37e83
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0xf
popq %rax
xchgq %rax, 0x38(%rdi)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
xorl %eax, %eax
leaq 0x25c(%rip), %rbp       # 0x38156
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jae 0x37f3b
movq %rbp, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x38412
movl 0x4(%rsp), %eax
incl %eax
jmp 0x37f09
xorl %ebx, %ebx
cmpq $0x20, %rbx
je 0x37f56
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x95f0
addq $0x8, %rbx
jmp 0x37f3d
leaq 0x20(%rsp), %rdi
callq 0x36b42
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37f71
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x36b42
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::AddTriplets(int)
int CrossingConstraint::AddTriplets(int nr_rows)
{
    int ncr = 0;
    for (auto node : t1.L)
    {
        vii P;
        Reconstruct(P, node, t2.GetRoot());

        double sum = 0;
        for (auto k : P)
            sum += GetWeight(k.first, k.second);

        if (sum - EPS > 1)
            AddConstraint(nr_rows + ncr++, P);
    }
    return ncr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
xorl %r15d, %r15d
movq %rsp, %r12
cmpq 0x28(%rsp), %r13
je 0x38057
movq (%r13), %rdx
andq $0x0, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq 0x18(%r14), %rax
movq 0x68(%rax), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x38080
movq (%rsp), %rbx
movq 0x8(%rsp), %rbp
xorpd %xmm0, %xmm0
cmpq %rbp, %rbx
je 0x3801d
movsd %xmm0, 0x30(%rsp)
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq %r14, %rdi
callq 0x36b80
movsd 0x30(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rbx
jmp 0x37ff1
addsd 0x35ed3(%rip), %xmm0    # 0x6def8
ucomisd 0x1b7f3(%rip), %xmm0    # 0x53820
jbe 0x38046
movq 0x20(%rsp), %rax
leal (%r15,%rax), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x37556
incl %r15d
movq %r12, %rdi
callq 0x3137c
addq $0x8, %r13
jmp 0x37fb3
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3806d
jmp 0x3806d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3137c
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::Reconstruct(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, newick_node*, newick_node*)
void CrossingConstraint::Reconstruct(vii& P, newick_node* nodel, newick_node* noder)
{
    double pw, cw;
    newick_node *child, *parent;
    tie(child, cw) = GetMaxChild(nodel, noder);
    tie(parent, pw) = GetMaxParent(noder, nodel);
    P.emplace_back(nodel->taxoni, noder->taxoni);
    if (nodel->parent && (!child || pw > cw))
        Reconstruct(P, parent, noder);
    else if (child && (!parent || cw >= pw))
        Reconstruct(P, nodel, child);
    else
        assert(!parent && !child);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
movq %rbx, %r12
leaq 0x28(%rbx), %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x38466
movq %rax, %rbp
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3845a
movq %rax, %rbx
movsd %xmm0, (%rsp)
leaq 0x28(%r15), %rdx
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x36ba6
cmpq $0x0, 0x30(%r12)
je 0x38101
testq %rbp, %rbp
je 0x3809c
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x38111
jmp 0x3809c
testq %rbp, %rbp
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
je 0x38141
movq %rbp, %r15
testq %rbx, %rbx
je 0x380a3
ucomisd %xmm1, %xmm0
movq %rbp, %r15
jae 0x380a3
leaq 0x35df2(%rip), %rdi     # 0x6df1b
leaq 0x35dfd(%rip), %rsi     # 0x6df2d
leaq 0x35e11(%rip), %rcx     # 0x6df48
movl $0x91, %edx
callq 0x9210
testq %rbx, %rbx
jne 0x38122
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::CrossingJob(int)
void CrossingConstraint::CrossingJob(int i)
{
    while (ax)
    {
        newick_node* node = nullptr;
        {
            lock_guard<mutex> g(qmutex);
            if (Q.empty())
            {
                ax &= ~(1 << i);
                continue;
            }
            else
                ax |= 1 << i;
            node = Q.front();
            Q.pop();
        }
        DFSRight(t2.GetRoot(), node);
        lock_guard<mutex> g(qmutex);
        for (newick_child* child = node->child; child; child = child->next)
            if (--PA[child->node->taxoni] == 0)
                Q.push(child->node);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ecx
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
pushq $0x1
popq %rax
shll %cl, %eax
leaq 0x68(%rdi), %r15
cltq
movq %rax, 0x10(%rsp)
pushq $-0x2
popq %rax
roll %cl, %eax
cltq
movq %rax, 0x8(%rsp)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x38239
movq %rbx, %rdi
callq 0x36f8c
movq 0x78(%r14), %rbp
movq 0x98(%r14), %r13
cmpq %rbp, %r13
je 0x381c9
movq 0x10(%rsp), %rax
lock
orq %rax, 0x38(%r14)
movq 0x78(%r14), %rax
movq (%rax), %r12
movq %r15, %rdi
callq 0x38e1a
jmp 0x381d6
movq 0x8(%rsp), %rax
lock
andq %rax, 0x38(%r14)
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x9280
cmpq %rbp, %r13
je 0x38189
movq 0x18(%r14), %rax
movq 0x68(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3825c
movq %rbx, %rdi
callq 0x36f8c
movq (%r12), %r12
testq %r12, %r12
je 0x3822c
movq (%r12), %rax
movslq 0x28(%rax), %rax
movq 0xb8(%r14), %rcx
decl (%rcx,%rax,4)
jne 0x38226
movq %r15, %rdi
movq %r12, %rsi
callq 0x38e70
addq $0x8, %r12
jmp 0x381fe
movq %rbx, %rdi
callq 0x9280
jmp 0x38189
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9280
movq %r14, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::DFSRight(newick_node*, newick_node*)
double CrossingConstraint::DFSRight(newick_node* node, newick_node* nodel)
{
    double mx = 0;
    for (newick_child* child = node->child; child; child = child->next)
        mx = max(mx, DFSRight(child->node, nodel));
    mx = max(mx, GetMaxParent(node, nodel).second);
    return GetDP(nodel, node) = mx + GetWeight(nodel, node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %rsi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x382a1
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x3825c
maxsd (%rsp), %xmm0
addq $0x8, %r12
movsd %xmm0, (%rsp)
jmp 0x38279
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3845a
maxsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37a24
addsd (%rsp), %xmm0
movq 0xd0(%r15), %rax
movslq 0x28(%r14), %rcx
imulq $0x18, %rcx, %rcx
movslq 0x28(%rbx), %rdx
movq (%rax,%rcx), %rax
movsd %xmm0, (%rax,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::GetMaxPC(newick_node*, newick_child*, bool)
pair<newick_node*, double> CrossingConstraint::GetMaxPC(newick_node* nodel, newick_child* noder, bool s)
{
    double mx = 0;
    newick_node* mc = nullptr;
    for (newick_child* pc = noder; pc; pc = pc->next)
    {
        double cw = GetDP(nodel, pc->node, s);
        if (cw >= mx)
        {
            mx = cw;
            mc = pc->node;
        }
    }
    return make_pair(mc, mx);
}

// Assembly:
movq 0xd0(%rdi), %rdi
xorpd %xmm0, %xmm0
xorl %eax, %eax
testq %rdx, %rdx
je 0x3835a
testb %cl, %cl
movq (%rdx), %r8
movq %rsi, %r9
cmovneq %r8, %r9
movq 0x8(%rdx), %rdx
movq %r8, %r10
cmovneq %rsi, %r10
movslq 0x28(%r9), %r9
imulq $0x18, %r9, %r9
movslq 0x28(%r10), %r10
movq (%rdi,%r9), %r9
movsd (%r9,%r10,8), %xmm1
ucomisd %xmm0, %xmm1
movapd %xmm0, %xmm2
cmpnlesd %xmm1, %xmm2
movapd %xmm2, %xmm3
andnpd %xmm1, %xmm3
andpd %xmm0, %xmm2
orpd %xmm3, %xmm2
cmovaeq %r8, %rax
movapd %xmm2, %xmm0
jmp 0x38301
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnB.cpp
// Function: BnB::SolveRec(unsigned long, bool)
bool BnB::SolveRec(size_t p, bool b)
{ 
    sys_lo(p) = b;
    sys_hi(p) = b;
    sys_x[p] = 1;
    
    bool f = SolveLP();    
    
    sys_lo(p) = 0;
    sys_hi(p) = 1;
    sys_x[p] = 0;

    return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r13
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rsp)
leaq 0x228(%rdi), %r14
movq %r14, %rdi
callq 0xd27a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x238(%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd27a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x1f0(%r13), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2ddae
orq %rdx, (%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x20(%rax)
movl %eax, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd27a
andq $0x0, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd27a
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2ddae
notq %rdx
andq %rdx, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnG.cpp
// Function: BnBNode::BnBNode(std::vector<Eigen::Triplet<double, int>, std::allocator<Eigen::Triplet<double, int>>>&, unsigned long, unsigned long)
BnBNode::BnBNode(vector<ET>& Triplets, size_t rows, size_t cols) : Triplets(Triplets), rows(rows), cols(cols), warm(nullptr), obj(1)
{
    var_lb.conservativeResizeLike(Vector::Zero(cols));
    var_ub.conservativeResizeLike(Vector::Ones(cols));
#if DEBUG == 1    
    debug_depth = 0;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3f498
movq %r14, 0x18(%rbx)
movq %r12, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x38(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
andq $0x0, 0x58(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x60(%rbx)
movq %rsp, %rdi
movq %r12, %rsi
callq 0xced2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3c2be
movq %rsp, %rdi
movq %r12, %rsi
callq 0x333bc
movq %rsp, %rsi
movq %r15, %rdi
callq 0x3c2be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3ce55
movq %rax, %r12
leaq 0x50(%rbx), %rdi
callq 0xbee0
movq %r15, %rdi
callq 0xbee0
movq %r14, %rdi
callq 0xbee0
movq %rbx, %rdi
callq 0x3419c
movq %r12, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnG.cpp
// Function: BnBNode::BnBNode(BnBNode*)
BnBNode::BnBNode(BnBNode* node) : Triplets(node->Triplets), rows(node->rows), cols(node->cols), obj(1)
{
    warm = new Vector(node->sol);
    var_lb = node->var_lb;
    var_ub = node->var_ub;
#if DEBUG == 1    
    debug_depth = 1 + node->debug_depth;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
callq 0x3f498
movups 0x18(%r12), %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x38(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x60(%rbx)
pushq $0x10
popq %rdi
callq 0x3f833
movq %rax, %r13
leaq 0x50(%r12), %rsi
movq %rax, %rdi
callq 0xe746
movq %r13, 0x48(%rbx)
leaq 0x28(%r12), %rsi
movq %r14, %rdi
callq 0xe787
addq $0x38, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xe787
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r13, %rdi
callq 0x93c0
jmp 0x3cf17
movq %rax, %r12
leaq 0x50(%rbx), %rdi
callq 0xbee0
movq %r15, %rdi
callq 0xbee0
movq %r14, %rdi
callq 0xbee0
movq %rbx, %rdi
callq 0x3419c
movq %r12, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnG.cpp
// Function: GenericBnBSolver::InitNodeFrom(BnBNode*)
BnBNode* GenericBnBSolver::InitNodeFrom(BnBNode* node)
{
    BnBNode* newnode;
    if (node == nullptr)
    {
        newnode = new BnBNode(Triplets, nr_rows, nr_cols);
        newnode->warm = new Vector(sys_sol);     
    }    
    else
        newnode = new BnBNode(node);
#if DEBUG == 1
    debug_lock.lock();
    newnode->debug_nodeid = debug_nodecnt++;
    newnode->debug_parent = (node == nullptr) ? 0 : node->debug_nodeid;    
    debug_lock.unlock();
#endif
    return newnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $0x68
popq %rdi
callq 0x9340
movq %rax, %rbx
testq %r15, %r15
je 0x3d38c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ce82
jmp 0x3d3ca
leaq 0x88(%r14), %rsi
movslq 0x108(%r14), %rdx
movslq 0x10c(%r14), %rcx
movq %rbx, %rdi
callq 0x3cdd0
pushq $0x10
popq %rdi
callq 0x3f833
movq %rax, %r15
addq $0x120, %r14            # imm = 0x120
movq %rax, %rdi
movq %r14, %rsi
callq 0xe746
movq %r15, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x93c0
jmp 0x3d3f0
jmp 0x3d3e2
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x9350
movq %r14, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnG.cpp
// Function: GenericBnBSolver::MakeNode(BnBNode*, unsigned long, double)
BnBNode* GenericBnBSolver::MakeNode(BnBNode* parent, size_t index, double val)
{
    BnBNode* node = InitNodeFrom(parent);
    node->FixVar(index, val);
#if DEBUG == 1
    node->debug_varid  = index;
    node->debug_varval = val;  
#endif
    OnNodeInit(node, index, val);
    return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, %r14
callq 0x3d364
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x3cfd0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movsd 0x8(%rsp), %xmm0
callq *0x98(%rax)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/BnG.cpp
// Function: DFBnBSolver::EvalOpen()
vector<BnBNode*> DFBnBSolver::EvalOpen()
{
    BnBNode* lt = Open.back(); Open.pop_back();

    if (Open.size() > 1)
    {
        BnBNode* rt = Open.back(); 
        if (lt->obj == 1 && !SolveNode(lt, PGTOL, NUMTOL)) lt->obj = 2;
        if (lt->warm == rt->warm) // TODO this is horrible.
        {
            Open.pop_back();
            if (rt->obj == 1 && !SolveNode(rt, PGTOL, NUMTOL)) rt->obj = 2;
            if (lt->obj < rt->obj) swap(lt, rt); // if (lt->obj > rt->obj) swap(lt, rt);
            if (rt->obj < 1) Open.push_back(rt);         
        }        
    }

    vector<BnBNode*> v;
    if (!(lt->obj == 2 || (lt->obj == 1 && !SolveNode(lt, PGTOL, NUMTOL))))
        v.push_back(lt);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x168(%rsi), %rax
leaq -0x8(%rax), %rcx
movq -0x8(%rax), %r15
movq %r15, 0x8(%rsp)
movq %rcx, 0x168(%rsi)
subq 0x160(%rsi), %rcx
cmpq $0x9, %rcx
jb 0x3e347
movq -0x10(%rax), %r12
movq %r12, (%rsp)
movsd 0x60(%r15), %xmm0
ucomisd 0x155ad(%rip), %xmm0    # 0x53820
movabsq $0x4000000000000000, %r13 # imm = 0x4000000000000000
jne 0x3e2a5
jp 0x3e2a5
movq (%r14), %rax
movsd 0x155a4(%rip), %xmm0    # 0x53830
movsd 0x3014c(%rip), %xmm1    # 0x6e3e0
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
testb %al, %al
jne 0x3e2a5
movq %r13, 0x60(%r15)
movq 0x48(%r15), %rax
cmpq 0x48(%r12), %rax
je 0x3e2b8
movq %r15, %r12
jmp 0x3e344
addq $-0x8, 0x168(%r14)
movsd 0x60(%r12), %xmm0
ucomisd 0x15551(%rip), %xmm0    # 0x53820
jne 0x3e309
jp 0x3e309
movq (%r14), %rax
movsd 0x15552(%rip), %xmm0    # 0x53830
movsd 0x300fa(%rip), %xmm1    # 0x6e3e0
movq %r14, %rdi
movq %r12, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x3e2fc
movsd 0x60(%r12), %xmm0
jmp 0x3e309
movq %r13, 0x60(%r12)
movsd 0x300df(%rip), %xmm0    # 0x6e3e8
movsd 0x60(%r15), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3e320
movq %r12, 0x8(%rsp)
movq %r15, (%rsp)
jmp 0x3e327
movq %r15, %r12
movapd %xmm0, %xmm1
movsd 0x154f1(%rip), %xmm0    # 0x53820
ucomisd %xmm1, %xmm0
jbe 0x3e344
leaq 0x160(%r14), %rdi
movq %rsp, %rsi
callq 0x3f4f8
movq %r12, %r15
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movsd 0x60(%r15), %xmm0
ucomisd 0x30086(%rip), %xmm0    # 0x6e3e8
jne 0x3e366
jnp 0x3e39f
ucomisd 0x154b2(%rip), %xmm0    # 0x53820
jne 0x3e392
jp 0x3e392
movq (%r14), %rax
movsd 0x154b3(%rip), %xmm0    # 0x53830
movsd 0x3005b(%rip), %xmm1    # 0x6e3e0
movq %r14, %rdi
movq %r15, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x3e39f
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f4f8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f7d6
movq %r14, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/./Eigen/src/Core/util/Memory.h
// Function: void* Eigen::internal::conditional_aligned_malloc<false>(unsigned long)
EIGEN_DEVICE_FUNC inline void* conditional_aligned_malloc<false>(std::size_t size)
{
  check_that_malloc_is_allowed();

  void *result = std::malloc(size);
  if(!result && size)
    throw_std_bad_alloc();
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x9450
movq %rax, %rbx
testq %rax, %rax
setne %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x3f857
callq 0xe355
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/LP.h
// Function: int LP::Add<CrossingConstraint>(std::vector<Eigen::Triplet<double, int>, std::allocator<Eigen::Triplet<double, int>>>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, unsigned long&)
int LP::Add(vector<ET>& Triplets, Vector& x, size_t& nr_rows)
{
    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 $0x1e8, %rsp            # imm = 0x1E8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
leaq 0xe0(%rdi), %r12
andl $0x0, (%rsp)
leaq 0x100(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %r8
movq %r14, %r9
callq 0x37d08
movl (%rbx), %esi
movq %rbp, %rdi
callq 0x37f86
cltq
addq %rax, (%rbx)
movq 0x30(%r13), %rcx
movq 0x38(%r13), %rdx
movl $0x1, (%rsp)
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq %r12, %r8
movq %r14, %r9
callq 0x37d08
movl (%rbx), %esi
leaq 0x18(%rsp), %rdi
callq 0x37f86
movslq %eax, %r14
addq (%rbx), %r14
movq %r14, (%rbx)
subl 0x10(%rsp), %r14d
leaq 0x18(%rsp), %rdi
callq 0x34a54
leaq 0x100(%rsp), %rdi
callq 0x34a54
movl %r14d, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x34a54
jmp 0x3f93b
jmp 0x3f938
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x34a54
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Similarity.cpp
// Function: JaccardSim(std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, double)
double JaccardSim(const ls& L1, const ls& L2, double k)
{
    vector<string> I(min(L1.size(), L2.size()));
    auto iit = set_intersection(L1.begin(), L1.end(), L2.begin(), L2.end(), I.begin());
    I.resize(iit - I.begin());
    double i = I.size(), u = L1.size() + L2.size() - I.size();
    double j = pow(i / u, k);
    return j < var_eps ? 0 : 2 * j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x10(%r14), %rax
cmpq %rsi, %rax
cmovbq %rax, %rsi
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x3ffc6
movq (%rbx), %rdi
movq (%r14), %rdx
movq (%r15), %r8
movq %rbx, %rsi
movq %r14, %rcx
callq 0x40098
leaq 0x28(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x40018
leaq 0x28(%rsp), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x5, %rax
movq %rax, %xmm1
movq 0x2cb7d(%rip), %xmm2    # 0x6c910
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2cb81(%rip), %xmm3    # 0x6c920
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x10(%r14), %rcx
addq 0x10(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x9630
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
cmpltsd 0x5765d(%rip), %xmm0    # 0x97450
andnpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xbfca
movaps 0x10(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3fe16
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbfca
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Similarity.cpp
// Function: SymdifSim(std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
double SymdifSim(const ls& L1, const ls& L2)
{
    vector<string> I(min(L1.size(), L2.size()));
    auto iit = set_intersection(L1.begin(), L1.end(), L2.begin(), L2.end(), I.begin());
    I.resize(iit - I.begin());
    double j = I.size();
    return j < var_eps ? 0 : 2 * j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq 0x10(%rbx), %rax
cmpq %rsi, %rax
cmovbq %rax, %rsi
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3ffc6
movq (%r14), %rdi
movq (%rbx), %rdx
movq (%r15), %r8
movq %r14, %rsi
movq %rbx, %rcx
callq 0x40098
leaq 0x8(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x40018
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %xmm0
punpckldq 0x2ca70(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2ca78(%rip), %xmm0    # 0x6c920
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
cmpltsd 0x5758b(%rip), %xmm1    # 0x97450
andnpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
callq 0xbfca
movaps 0x20(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3fee5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbfca
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Similarity.cpp
// Function: EditDistance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double EditDistance(const string & L1, const string & L2, std::vector<std::vector<double>> & cost_matrix)
{
    int i = stoi(L1);
    int j = stoi(L2);
    int n = (int) cost_matrix.size();
    int m = (int) cost_matrix[0].size();
    // cout << (cost_matrix[i][m-1] + cost_matrix[n-1][j] - cost_matrix[i][j]) << " ";
    assert(i < cost_matrix.size() && j < cost_matrix[0].size());
    return (cost_matrix[i][m-1] + cost_matrix[n-1][j] - cost_matrix[i][j]) < var_eps ? 0 : (cost_matrix[i][m-1] + cost_matrix[n-1][j] - cost_matrix[i][j]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0xa
popq %rbp
xorl %esi, %esi
movl %ebp, %edx
callq 0xb789
movl %eax, %r15d
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xb789
movl %eax, %ecx
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
movslq %r15d, %rdx
cmpq %rdx, %rax
jbe 0x3ffa9
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
movq %rdi, %r8
sarq $0x3, %r8
movslq %ecx, %rcx
cmpq %rcx, %r8
jbe 0x3ffa9
imulq $0x18, %rdx, %rdx
shlq $0x1d, %rdi
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
addq %rdi, %r8
movq (%rsi,%rdx), %rdx
sarq $0x1d, %r8
movsd (%rdx,%r8), %xmm1
decl %eax
cltq
imulq $0x18, %rax, %rax
movq (%rsi,%rax), %rax
addsd (%rax,%rcx,8), %xmm1
subsd (%rdx,%rcx,8), %xmm1
movapd %xmm1, %xmm0
cmpltsd 0x574b6(%rip), %xmm0    # 0x97450
andnpd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e564(%rip), %rdi     # 0x6e514
leaq 0x2e591(%rip), %rsi     # 0x6e548
leaq 0x2e59d(%rip), %rcx     # 0x6e55b
pushq $0x2b
popq %rdx
callq 0x9210
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/LPInt.cpp
// Function: LPInt::AddConstraint(std::tuple<int, int> const&, std::tuple<int, int> const&)
void LPInt::AddConstraint(const ii& a, const ii& b)
{
    int i = get<0>(a), j = get<1>(a);
    int k = get<0>(b), l = get<1>(b);
    Triplets.emplace_back(nr_rows, K[i][j], 1.);
    Triplets.emplace_back(nr_rows++, K[k][l], 1.);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movslq 0x4(%rsi), %rcx
movslq (%rsi), %rax
movslq 0x4(%rdx), %r13
movslq (%rdx), %rbx
leaq 0x88(%rdi), %r14
movq 0xe0(%rdi), %rdx
imulq $0x18, %rcx, %rcx
shlq $0x2, %rax
addq (%rdx,%rcx), %rax
leaq 0x108(%rdi), %rsi
movabsq $0x3ff0000000000000, %rbp # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %r12
movq %rbp, (%r12)
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x34634
movl 0x108(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x108(%r15)
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq 0xe0(%r15), %rax
imulq $0x18, %r13, %rcx
shlq $0x2, %rbx
addq (%rax,%rcx), %rbx
movq %rbp, (%r12)
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3467e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: IntegerPackingJRF::getBoundsConstraints(double*, double*)
bool getBoundsConstraints(Scalar* cl, Scalar* cu) override
     {
         Vector::MapType cLower = Vector::MapType(cl, _m);
         Vector::MapType cUpper = Vector::MapType(cu, _m);
         cLower.head(_n) = Vector::Zero(_n);
         cUpper.head(_n) = Vector::Zero(_n);
         cUpper.tail(_A.rows()) = _b;
         cLower.tail(_A.rows()) = Vector::Constant(_A.rows(), -INF);
         return true;
     }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r12
movq %rdi, %r14
movq 0x38(%rdi), %rdx
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0xe296
movq 0x38(%r14), %rdx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xe296
movq 0x30(%r14), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xced2
movq 0x30(%r14), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x40e2e
movq %r13, %rdi
movq %r12, %rsi
callq 0x40faa
movq 0x30(%r14), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xced2
movq 0x30(%r14), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x40e2e
movq %r13, %rdi
movq %r12, %rsi
callq 0x40faa
movq 0x10(%r14), %r12
movq 0x8(%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x40e42
movq %r13, %rdi
movq %r12, %rsi
callq 0x4112a
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xe890
movq 0x8(%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40e42
movq %r14, %rdi
movq %r15, %rsi
callq 0x40faa
movb $0x1, %al
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: IntegerPackingJRF::functionValueConstraints(double const*, double*)
bool functionValueConstraints(const Scalar* variablesPtr,
                                   Scalar* constraintValuesPtr) override
     {
          Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
          Vector::MapType constraintValues = Vector::MapType(constraintValuesPtr, _m);
          Vector t = Vector::Ones(_n);
          constraintValues.head(_n) = x.cwiseProduct(x-t);
          constraintValues.tail(_A.rows()) = _A * x;
          return true;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xebcc
movq 0x38(%rbx), %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xe296
movq 0x30(%rbx), %rsi
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x333bc
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x34154
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4129e
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x41282
movq 0x30(%rbx), %rdx
leaq 0x88(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40e2e
leaq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4132b
movq 0x8(%rbx), %rsi
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x33c26
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rdx
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40e42
leaq 0x40(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x41509
movq (%rsp), %rdi
callq 0x93c0
movb $0x1, %al
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x40ce8
jmp 0x40ce8
jmp 0x40ce8
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x93c0
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: IntegerPackingJRF::gradientConstraintsTimesVector(double const*, double const*, double*)
bool gradientConstraintsTimesVector(const Scalar* variablesPtr,
                                          const Scalar* dualVariablesPtr,
                                          Scalar* gradientPtr) override
      {
           Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
           Vector::ConstMapType y = Vector::ConstMapType(dualVariablesPtr, _m);
           Vector::MapType gradient = Vector::MapType(gradientPtr, _n);
           gradient = (2*x).cwiseProduct(y.head(_n)) - y.head(_n);
           gradient += _A.transpose() * y.tail(_A.rows());
           return true;
       }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rcx, %r12
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rdi), %rdx
leaq 0x38(%rsp), %r13
movq %r13, %rdi
callq 0xebcc
movq 0x38(%r14), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xebcc
movq 0x30(%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xe296
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
leaq 0x98(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rdx
callq 0x41567
movq 0x30(%r14), %rdx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x415d6
leaq 0x120(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x415ba
movq 0x30(%r14), %rdx
leaq 0xd8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x415d6
leaq 0x1b8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x415ea
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x418e5
movq 0x8(%r14), %rax
movb $0x0, (%r12)
movq %rax, 0x8(%r12)
movq 0x10(%rax), %rdx
leaq 0x120(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41606
leaq 0x1b8(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x41b50
movq %r13, %rdi
movq %r14, %rsi
callq 0x4161e
movb $0x1, %al
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Geno.h
// Function: CoveringJRF::getBoundsConstraints(double*, double*)
bool getBoundsConstraints(Scalar* cl, Scalar* cu) override
    {
    // we have equality constraints here
        Vector::MapType(cl, _m) = _b;
        Vector::MapType(cu, _m) = Vector::Constant(_m, INF);
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq 0x38(%rdi), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xe296
movq %r12, %rdi
movq %r15, %rsi
callq 0x338ce
movq 0x38(%r14), %rsi
leaq 0x2e8dc(%rip), %rdx     # 0x71628
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe890
movq 0x38(%r14), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe296
movq %r14, %rdi
movq %r15, %rsi
callq 0x3374d
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Parallel.cpp
// Function: ParallelSolver::Callback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, GenericBnBSolver*)
void ParallelSolver::Callback(string filename,string outScoreFile, GenericBnBSolver* solver)
{
#if DEBUG == 1
    solver->debug_file = filename + '_' + typeid(*solver).name();
#endif

    solver->Solve("");    

    if (!sol && filename != "") 
    {
        thr_slock.lock(); 
        sol = 1; 
        thr_val = this_thread::get_id();
        cout << typeid(*solver).name() << endl;
        thr_slock.unlock();
        solver->WriteSolution(filename);    
        // write the objective function 
        ofstream score(outScoreFile);
        score << solver->moptVal << endl;
        // cout << "my score: "  << solver->moptVal << endl;
        score.close();
    }
    thr_cond.notify_all();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x280f1(%rip), %rsi     # 0x6c99a
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0xb7a6
leaq 0xc9a5(%rip), %rsi      # 0x51264
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb7a6
movq (%r14), %rax
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
callq 0x9708
leaq 0x30(%rsp), %rdi
callq 0x9708
cmpb $0x0, 0x151(%rbx)
jne 0x449ce
leaq 0x28091(%rip), %rsi     # 0x6c99a
movq %r12, %rdi
callq 0x312d5
testb %al, %al
je 0x449ce
leaq 0x28(%rbx), %r13
movq %r13, %rdi
callq 0x36f8c
movb $0x1, 0x151(%rbx)
callq 0x92e0
xchgq %rax, 0x80(%rbx)
movq (%r14), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
movq 0x5265a(%rip), %rdi     # 0x96fb0
callq 0x9330
movq %rax, %rdi
callq 0x9170
movq %r13, %rdi
callq 0x9280
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x9470
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *0x18(%rax)
leaq 0x50(%rsp), %rdi
callq 0x9708
leaq 0x70(%rsp), %r12
pushq $0x10
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x96e0
movsd 0x20(%r14), %xmm0
movq %r12, %rdi
callq 0x9540
movq %rax, %rdi
callq 0x9170
leaq 0x70(%rsp), %rdi
callq 0x94a0
leaq 0x70(%rsp), %rdi
callq 0x94f0
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x95e0
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x44a1b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x94f0
jmp 0x44a25
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9708
jmp 0x44a16
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x9708
jmp 0x44a25
movq %rax, %rbx
movq %rbx, %rdi
callq 0x9640
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Parallel.cpp
// Function: ParallelSolver::PushUB(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double, GenericBnBSolver&)
bool ParallelSolver::PushUB(Vector& var, double val, GenericBnBSolver& solver)
{
    bool f = false;
    thr_block.lock();
    if (val < sys_ub * 1.001)
    {
#if DEBUG == 1 
        solver.debug_log << "push: " << val << " > " << sys_ub << endl;
#endif
        sys_ub  = val;
        sys_sol = var;
        f = true;
    }
    thr_block.unlock();
    return f;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x36f8c
movsd (%rsp), %xmm0
movsd 0xa0(%rbx), %xmm1
mulsd 0x2c9db(%rip), %xmm1    # 0x71698
ucomisd %xmm0, %xmm1
jbe 0x44ceb
movsd %xmm0, 0xa0(%rbx)
leaq 0x90(%rbx), %rdi
movq %r14, %rsi
movsd %xmm1, 0x8(%rsp)
callq 0xe787
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm1
seta %bpl
movq %rbx, %rdi
callq 0x9280
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Parallel.cpp
// Function: ParallelSolver::PullUB(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double&, GenericBnBSolver&)
bool ParallelSolver::PullUB(Vector& var, double& val, GenericBnBSolver& solver)
{
    bool f = false;
    thr_block.lock();
    if (val > sys_ub * 0.999)
    {
#if DEBUG == 1
        solver.debug_log << "pull: " << val << " < " << sys_ub << endl;
#endif
        val = sys_ub;
        var = sys_sol;
        f = true;
    }
    thr_block.unlock();
    return f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x36f8c
movsd (%r15), %xmm1
movsd 0xa0(%rbx), %xmm0
movsd 0x2931d(%rip), %xmm2    # 0x6e050
mulsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x44d69
movsd %xmm0, (%r15)
leaq 0x90(%rbx), %rsi
movq %r14, %rdi
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0xe787
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm1
seta %bpl
movq %rbx, %rdi
callq 0x9280
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/EditDist.cpp
// Function: GetNumTrees(newick_node*, std::vector<newick_node*, std::allocator<newick_node*>>&)
int GetNumTrees(newick_node* root, vn& N)
{
    int k = 0, s = 1, f = 1;
    N.push_back(root);
    for (newick_child* child = root->child; child; child = child->next)
    {
        f *= ++k;
        s *= GetNumTrees(child->node, N);
    }
    return s * f;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2dde8
pushq $0x1
popq %r15
movq (%r14), %r12
movl %r15d, %r14d
movl %r15d, %ebp
movq (%r12), %r12
testq %r12, %r12
je 0x4b7b9
imull %r15d, %ebp
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x4b764
imull %eax, %r14d
addq $0x8, %r12
incl %r15d
jmp 0x4b793
imull %r14d, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq