LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x10(%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x99a50
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x99a80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x99ab0
testb $0x1, %al
jne 0xc2920
jmp 0xc2a73
leaq -0x20(%rbp), %rdi
callq 0x99af0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xacd60
movq -0x88(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq 0x18(%rax), %rdi
callq 0xa8ec0
movq %rax, -0x90(%rbp)
jmp 0xc295d
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rdx
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc2a90
jmp 0xc297d
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xc0090
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xbfea0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xc0680
testb $0x1, %al
jne 0xc29ba
jmp 0xc2a1a
leaq -0x70(%rbp), %rdi
callq 0xc0530
movq -0x88(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movl -0x80(%rbp), %esi
movl -0x7c(%rbp), %edx
callq 0xbd0b0
movsd %xmm0, -0xa0(%rbp)
jmp 0xc29e6
movsd -0xa0(%rbp), %xmm0
addsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc06c0
jmp 0xc29a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa9390
jmp 0xc2a7f
movsd -0x60(%rbp), %xmm0
movsd 0x68f39(%rip), %xmm1    # 0x12b960
subsd %xmm1, %xmm0
movsd 0x4b235(%rip), %xmm1    # 0x10dc68
ucomisd %xmm1, %xmm0
jbe 0xc2a5c
movq -0x88(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %eax
movl %eax, %ecx
incl %ecx
movl %ecx, -0x10(%rbp)
addl %eax, %esi
leaq -0x48(%rbp), %rdx
callq 0xc05c0
jmp 0xc2a5a
jmp 0xc2a5c
leaq -0x48(%rbp), %rdi
callq 0xa9390
leaq -0x20(%rbp), %rdi
callq 0x99b10
jmp 0xc290a
movl -0x10(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xa7c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc36f0
movq %rax, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc3740
leaq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc3780
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc36a0
movq %rax, -0x70(%rbp)
movsd %xmm0, -0x68(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xc3740
leaq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xc3780
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rdx
addq $0x28, %rdx
callq 0xbd110
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xc2b79
cmpq $0x0, -0x38(%rbp)
je 0xc2b5c
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0xc2b79
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc2a90
jmp 0xc2bfd
cmpq $0x0, -0x38(%rbp)
je 0xc2bad
cmpq $0x0, -0x40(%rbp)
je 0xc2b93
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0xc2bad
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0xc2a90
jmp 0xc2bfb
xorl %eax, %eax
cmpq $0x0, -0x40(%rbp)
movb %al, -0x89(%rbp)
jne 0xc2bcc
cmpq $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xc2bd8
jmp 0xc2bda
jmp 0xc2bf9
leaq 0x68da2(%rip), %rdi     # 0x12b983
leaq 0x68dad(%rip), %rsi     # 0x12b995
movl $0x91, %edx
leaq 0x68dbc(%rip), %rcx     # 0x12b9b0
callq 0xa2b0
jmp 0xc2bfb
jmp 0xc2bfd
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
callq 0xc33f0
cmpq $0x0, %rax
je 0xc2dcb
movq -0x48(%rbp), %rsi
movq $0x0, -0x18(%rbp)
addq $0x40, %rsi
leaq -0x20(%rbp), %rdi
callq 0xbced0
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0xc3470
movb %al, -0x49(%rbp)
jmp 0xc2c69
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xc2c72
jmp 0xc2cb2
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
movslq %eax, %rsi
addq $0x38, %rdi
callq 0xc3490
movl $0x2, -0x30(%rbp)
jmp 0xc2d00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbcf00
jmp 0xc2dd1
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rsi
addq $0x38, %rdi
callq 0xc3500
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0xc3570
movq %rax, -0x58(%rbp)
jmp 0xc2cdf
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x68, %rdi
callq 0xc3590
jmp 0xc2cf9
movl $0x0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xbcf00
movl -0x30(%rbp), %eax
testl %eax, %eax
je 0xc2d17
jmp 0xc2d12
jmp 0xc2c27
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa8ec0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xc2de0
movq -0x48(%rbp), %rsi
addq $0x40, %rsi
leaq -0x38(%rbp), %rdi
callq 0xbced0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xc2dbd
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x145d0
movq %rax, %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0xc2dad
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
movq -0x40(%rbp), %rsi
callq 0xc35b0
jmp 0xc2d94
jmp 0xc2dad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbcf00
jmp 0xc2dd1
jmp 0xc2daf
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xc2d50
leaq -0x38(%rbp), %rdi
callq 0xbcf00
jmp 0xc2c27
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xa7c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc2e53
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xc2de0
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14920
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc2e0f
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc36a0
movq %rax, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x14920
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xc0f90
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %ecx, %ecx
callq 0xc35e0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xc2f78
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xc35e0
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0xc2f68
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xc2f6a
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xc2f1b
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc3670
movq %rax, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x228, %rdi            # imm = 0x228
movq -0x10(%rbp), %rsi
callq 0x145f0
movsd -0x58(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movsd %xmm0, (%rax)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x238, %rdi            # imm = 0x238
movq -0x10(%rbp), %rsi
callq 0x145f0
movsd -0x50(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x1f0, %rdi            # imm = 0x1F0
movq -0x10(%rbp), %rsi
callq 0x997b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x48(%rbp), %rdi
andb $0x1, %al
movb %al, -0x29(%rbp)
addq $0x228, %rdi            # imm = 0x228
movq -0x10(%rbp), %rsi
callq 0x145f0
movq -0x48(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
addq $0x238, %rdi            # imm = 0x238
movq -0x10(%rbp), %rsi
callq 0x145f0
movq -0x48(%rbp), %rdi
movsd 0x4020d(%rip), %xmm0    # 0x10dc68
movsd %xmm0, (%rax)
addq $0x1f0, %rdi            # imm = 0x1F0
movq -0x10(%rbp), %rsi
callq 0x997b0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x99840
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: canzarlab[P]Trajan/./Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::internal::conservative_resize_like_impl<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>, true>::run(Eigen::DenseBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>&, Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>> const&)
static void run(DenseBase<Derived>& _this, const DenseBase<OtherDerived>& other)
  {
    if (_this.rows() == other.rows() && _this.cols() == other.cols()) return;

    const Index num_new_elements = other.size() - _this.size();

    const Index new_rows = Derived::RowsAtCompileTime==1 ? 1 : other.rows();
    const Index new_cols = Derived::RowsAtCompileTime==1 ? other.cols() : 1;
    _this.derived().m_storage.conservativeResize(other.size(),new_rows,new_cols);

    if (num_new_elements > 0)
      _this.tail(num_new_elements) = other.tail(num_new_elements);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ce40
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf660
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jne 0xcf5a8
movq -0x8(%rbp), %rdi
callq 0x1ce70
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf690
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jne 0xcf5a8
jmp 0xcf654
movq -0x10(%rbp), %rdi
callq 0xcf6c0
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14700
movq %rax, %rcx
movq -0xb8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf660
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18010
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcf6c0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0xb59c0
cmpq $0x0, -0x18(%rbp)
jle 0xcf654
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xcf700
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x16040
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcf760
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd9030
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0x144b0
jmp 0xd2b86
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x80(%rbp)
callq 0x144b0
jmp 0xd2b99
movq -0x78(%rbp), %rdi
movq $0x0, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, -0x88(%rbp)
callq 0x144b0
jmp 0xd2bb7
movq -0x78(%rbp), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x60(%rax)
addq $0x28, %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x13c30
jmp 0xd2be3
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xcec20
jmp 0xd2bf5
movq -0x78(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xaf2b0
jmp 0xd2c13
movq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcec20
jmp 0xd2c25
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd2c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd2c79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd2c70
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xff40
movq -0x80(%rbp), %rdi
callq 0xff40
movq -0x68(%rbp), %rdi
callq 0xff40
movq -0x70(%rbp), %rdi
callq 0xaefb0
movq -0x28(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd9030
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rdi)
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x144b0
jmp 0xd2cf3
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x40(%rbp)
callq 0x144b0
jmp 0xd2d06
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x48(%rbp)
callq 0x144b0
jmp 0xd2d19
movq -0x38(%rbp), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x60(%rax)
movl $0x10, %edi
callq 0xd9120
movq %rax, -0x50(%rbp)
jmp 0xd2d3b
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x144f0
jmp 0xd2d4e
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, 0x48(%rdi)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
addq $0x28, %rdi
callq 0x145a0
jmp 0xd2d6d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
addq $0x38, %rdi
callq 0x145a0
jmp 0xd2d84
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd2df2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd2de9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd2de0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd2dd7
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd9140
movq -0x48(%rbp), %rdi
callq 0xff40
movq -0x40(%rbp), %rdi
callq 0xff40
movq -0x28(%rbp), %rdi
callq 0xff40
movq -0x30(%rbp), %rdi
callq 0xaefb0
movq -0x18(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd35a9
movl $0x68, %edi
callq 0xa450
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rsi
addq $0x88, %rsi
movslq 0x108(%rax), %rdx
movslq 0x10c(%rax), %rcx
callq 0xd2b30
jmp 0xd353a
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x10, %edi
callq 0xd9120
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
addq $0x120, %rsi            # imm = 0x120
callq 0x144f0
jmp 0xd3568
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0xd35ee
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0xa460
jmp 0xd35f8
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd9140
jmp 0xd35f8
movl $0x68, %edi
callq 0xa450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd2ca0
jmp 0xd35c8
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xd35ee
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0xa460
jmp 0xd35f8
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd34e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
callq 0xd2ef0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movl %eax, %edx
movsd -0x20(%rbp), %xmm0
movq (%rdi), %rax
callq *0x98(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/LP.h
// Function: int LP::Add<2>(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)
{
    static_assert(N == 1 || N == 2, "invalid constraint");
    if (N == 1)
        return Add<CrossingConstraint>(Triplets, x, nr_rows);
    return (dag ? Add<AntichainConstraint>() : Add<IndependentSetConstraint>(Triplets, x, nr_rows));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x68(%rax)
je 0xd9324
movq -0x28(%rbp), %rdi
callq 0xb6040
movl %eax, -0x2c(%rbp)
jmp 0xd933c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xda390
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x19830
movq -0x8(%rbp), %rdi
callq 0xa5c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xda1b1
cmpq $0x0, -0x8(%rbp)
je 0xda1b1
callq 0x19700
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %r8
movq %r8, -0x220(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rsi
movq 0x30(%r8), %rdx
movq 0x38(%r8), %rcx
addq $0xe0, %r8
movq -0x18(%rbp), %r9
movq %rsp, %rax
movl $0x0, (%rax)
leaq -0x110(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0xc23e0
movq -0x218(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0xc28c0
movl %eax, -0x20c(%rbp)
jmp 0xda28c
movq -0x220(%rbp), %r8
movl -0x20c(%rbp), %eax
movslq %eax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq 0x30(%r8), %rcx
movq 0x38(%r8), %rdx
addq $0xe0, %r8
movq -0x18(%rbp), %r9
movq %rsp, %rax
movl $0x1, (%rax)
leaq -0x208(%rbp), %rdi
callq 0xc23e0
jmp 0xda2d7
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x208(%rbp), %rdi
callq 0xc28c0
movl %eax, -0x224(%rbp)
jmp 0xda2f1
movl -0x224(%rbp), %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
callq 0xb5bb0
leaq -0x110(%rbp), %rdi
callq 0xb5bb0
movl -0x228(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0xda371
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0xb5bb0
leaq -0x110(%rbp), %rdi
callq 0xb5bb0
movq -0x118(%rbp), %rdi
callq 0xa7c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdc140
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc140
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x156f0
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc9c70
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xdc170
jmp 0xdbdcd
leaq -0x39(%rbp), %rdi
callq 0x11300
movq -0x8(%rbp), %rdi
callq 0xdc250
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdc280
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc250
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc280
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xf0b0
movq %rax, -0x80(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x80(%rbp), %r8
callq 0xdc1e0
movq %rax, -0xa8(%rbp)
jmp 0xdbe39
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xf0b0
movq %rax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xca530
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0xdc2b0
jmp 0xdbe7c
leaq -0x28(%rbp), %rdi
callq 0xca660
movq %rax, %xmm0
movaps 0x4e2bf(%rip), %xmm1    # 0x12a150
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4e2c3(%rip), %xmm1    # 0x12a160
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x90(%rbp), %xmm1
movsd 0xc567c(%rip), %xmm0    # 0x1a1540
ucomisd %xmm1, %xmm0
jbe 0xdbed7
xorps %xmm0, %xmm0
movsd %xmm0, -0xb8(%rbp)
jmp 0xdbeef
movsd 0x2f4c9(%rip), %xmm0    # 0x10b3a8
mulsd -0x90(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x110d0
movsd -0xc0(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x11300
jmp 0xdbf45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x110d0
movq -0x48(%rbp), %rdi
callq 0xa7c0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdda00
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdda20
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdda00
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdda20
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0x60(%rbp)
movq %rdi, %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, -0x58(%rbp)
addq $0xe0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x993b0
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x145d0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movsd 0x30b97(%rip), %xmm0    # 0x10dc68
movsd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rcx
callq 0xb4c70
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0x48(%rbp)
movl 0x108(%rdi), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x108(%rdi)
movl %eax, -0x34(%rbp)
addq $0xe0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x993b0
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0x145d0
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movsd 0x30b39(%rip), %xmm0    # 0x10dc68
movsd %xmm0, -0x40(%rbp)
leaq -0x34(%rbp), %rsi
leaq -0x40(%rbp), %rcx
callq 0xb4d00
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x1f8(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x32(%rbp), %rdi
callq 0x160e0
movq -0x1f8(%rbp), %rsi
movq -0x1f0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x32(%rbp), %rcx
callq 0x16120
movq -0x1d0(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x1e8(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x52(%rbp), %rdi
callq 0x160e0
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x52(%rbp), %rcx
callq 0x16120
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0x13c30
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xde250
leaq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xde2a0
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x13c30
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xde250
leaq -0x118(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xde2a0
movq -0x1d0(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x1d8(%rbp)
movq 0x8(%rax), %rdi
callq 0xafdc0
movq %rax, %rdx
leaq -0x160(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xde2e0
movq -0x1d8(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0xde340
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xafdc0
movq %rax, %rsi
movsd 0x2d5b3(%rip), %xmm0    # 0x10b3b0
movsd %xmm0, -0x180(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0x180(%rbp), %rdx
callq 0x1b630
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xafdc0
movq %rax, %rdx
leaq -0x1c8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xde2e0
leaq -0x1c8(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0xde2a0
movb $0x1, %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x200(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x32(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x160e0
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
movq -0x1f0(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x1cea0
movq -0x1d0(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x1e8(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x52(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x160e0
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdx
movq -0x1d8(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x16120
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xaf2b0
movq -0x1c8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xaf2f0
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0xdf940
jmp 0xddf66
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0xdf8d0
jmp 0xddf7f
movq -0x1d0(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x148(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xde250
jmp 0xddf9c
leaq -0x148(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xdf9b0
jmp 0xddfb1
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x168(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0xb15a0
jmp 0xddfce
movq -0x1d0(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xafdc0
movq %rax, %rdx
leaq -0x1b0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xde2e0
jmp 0xddff3
leaq -0x1b0(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0xdf9f0
jmp 0xde008
leaq -0x68(%rbp), %rdi
callq 0xff40
movb $0x1, %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf8(%rbp)
movl %eax, -0xfc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xff40
movq -0xf8(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x3d0, %rsp            # imm = 0x3D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x398(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x3c8(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x3c0(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x160e0
movq -0x3c8(%rbp), %rsi
movq -0x3c0(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x3a(%rbp), %rcx
callq 0x1cea0
movq -0x398(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x3b8(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x3b0(%rbp)
leaq -0x5a(%rbp), %rdi
callq 0x160e0
movq -0x3b8(%rbp), %rsi
movq -0x3b0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x5a(%rbp), %rcx
callq 0x1cea0
movq -0x398(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x3a8(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x3a0(%rbp)
leaq -0x7a(%rbp), %rdi
callq 0x160e0
movq -0x3a8(%rbp), %rsi
movq -0x3a0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x7a(%rbp), %rcx
callq 0x16120
movl $0x2, -0x24c(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x24c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xe0ac0
movq -0x398(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x298(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe0be0
leaq -0x208(%rbp), %rdi
leaq -0x248(%rbp), %rsi
leaq -0x298(%rbp), %rdx
callq 0xe0b70
movq -0x398(%rbp), %rax
movq 0x30(%rax), %rdx
leaq -0x2e0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe0be0
leaq -0x170(%rbp), %rdi
leaq -0x208(%rbp), %rsi
leaq -0x2e0(%rbp), %rdx
callq 0xe0c30
leaq -0x78(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0xe0ca0
movq -0x398(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xb23e0
movb %al, %cl
movq -0x398(%rbp), %rax
movb %cl, -0x348(%rbp)
movq %rdx, -0x340(%rbp)
movq 0x8(%rax), %rdi
callq 0xafdc0
movq %rax, %rdx
leaq -0x390(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe0d30
leaq -0x338(%rbp), %rdi
leaq -0x348(%rbp), %rsi
leaq -0x390(%rbp), %rdx
callq 0xe0ce0
leaq -0x78(%rbp), %rdi
leaq -0x338(%rbp), %rsi
callq 0xe0d90
movb $0x1, %al
andb $0x1, %al
addq $0x3d0, %rsp            # imm = 0x3D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/Parallel.cpp
// Function: ParallelSolver::Finished()
bool ParallelSolver::Finished()
{
    thr_slock.lock();  
    bool b = sol; 
    thr_slock.unlock();
    return sol; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
callq 0xbec90
movq -0x18(%rbp), %rdi
movb 0x151(%rdi), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x28, %rdi
callq 0xbecc0
movq -0x18(%rbp), %rax
movb 0x151(%rax), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xbec90
movq -0x30(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movsd 0x42b3d(%rip), %xmm0    # 0x12f4a8
mulsd 0xa0(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xec99e
movq -0x30(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0xa0(%rdi)
movq -0x10(%rbp), %rsi
addq $0x90, %rdi
callq 0x145a0
movb $0x1, -0x21(%rbp)
movq -0x30(%rbp), %rdi
callq 0xbecc0
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xbec90
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd 0x3f0bb(%rip), %xmm1    # 0x12bab8
mulsd 0xa0(%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xeca33
movq -0x30(%rbp), %rsi
movsd 0xa0(%rsi), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x90, %rsi
movq -0x10(%rbp), %rdi
callq 0x145a0
movb $0x1, -0x21(%rbp)
movq -0x30(%rbp), %rdi
callq 0xbecc0
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x99890
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfae79
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfae00
imull -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfae3d
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/src/EditDist.cpp
// Function: GenPerms(std::vector<newick_node*, std::allocator<newick_node*>>&, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>, std::allocator<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>>&)
void GenPerms(vn& v, int k, vvi& S, vvvi& P)
{
    if (k == v.size())
    {
        P.push_back(S);
        return;
    }
    int c = 0;
    for (newick_child* child = v[k]->child; child; child = child->next)
        c++;

    vector<int> I(c);
    iota(I.begin(), I.end(), 0);
    do
    {
        S.push_back(I);
        GenPerms(v, k + 1, S, P);
        S.pop_back();
    } while (next_permutation(I.begin(), I.end()));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f690
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jne 0xfaedf
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfe2b0
jmp 0xfb00d
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xa19e0
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfaf1b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xfaefd
movslq -0x24(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x14c70
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x14c90
jmp 0xfaf4f
leaq -0x49(%rbp), %rdi
callq 0x14d00
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x9e780
movq -0xa0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x9e610
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
xorl %edx, %edx
callq 0xfe320
jmp 0xfaf8d
jmp 0xfaf8f
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xfe380
jmp 0xfaf9e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
incl %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xfae90
jmp 0xfafb6
movq -0x18(%rbp), %rdi
callq 0xfe3f0
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x9e780
movq -0xb0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x9e610
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xfe420
movb %al, -0xa1(%rbp)
jmp 0xfaff8
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0xfaf8f
jmp 0xfb004
leaq -0x48(%rbp), %rdi
callq 0x14b50
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x14d00
jmp 0xfb042
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14b50
movq -0x58(%rbp), %rdi
callq 0xa7c0
nopl (%rax,%rax)
// File: canzarlab[P]Trajan/src/EditDist.cpp
// Function: CalcSubtreeSizes(newick_node*, std::map<newick_node*, int, std::less<newick_node*>, std::allocator<std::pair<newick_node* const, int>>>&)
int CalcSubtreeSizes(newick_node* root, map<newick_node*, int>& S)
{
    int s = 1;
    for (newick_child* child = root->child; child; child = child->next)
        s += CalcSubtreeSizes(child->node, S);
    return S[root] = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfb45d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfb410
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfb432
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xfe460
movq %rax, %rcx
movl -0x24(%rbp), %eax
movl %eax, (%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop