LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
movslq 0x28(%rsi), %rcx
leal 0x3f(%rcx), %edx
testq %rcx, %rcx
movq (%rbx), %rax
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rdx
leaq 0x3f(%r15), %r8
andq %rcx, %r8
xorl %r9d, %r9d
cmpq %r15, %r8
setbe %r9b
movl $0x1, %r8d
shlq %cl, %r8
leaq (%rax,%rdx,8), %rcx
orq %r8, -0x8(%rcx,%r9,8)
movq (%rsi), %r12
testq %r12, %r12
je 0x3b63c
movq %rdi, %r14
leaq 0x3f(%r15), %r13
movq (%r12), %rsi
movslq 0x28(%rsi), %rcx
movq 0xb8(%r14), %rdx
incl (%rdx,%rcx,4)
movslq 0x28(%rsi), %rcx
leal 0x3f(%rcx), %edx
testq %rcx, %rcx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rdx
leaq (%rax,%rdx,8), %rdx
movq %rcx, %rdi
andq %r13, %rdi
xorl %r8d, %r8d
cmpq %r15, %rdi
setbe %r8b
movq -0x8(%rdx,%r8,8), %rdx
btq %rcx, %rdx
jb 0x3b632
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3b582
movq (%rbx), %rax
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x3b5e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xf, %eax
xchgq %rax, 0x38(%rdi)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
leaq 0x387(%rip), %rbp       # 0x3ba0e
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x3bd8a
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jb 0x3b691
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x9630
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x3b6c6
leaq 0x20(%rsp), %rdi
callq 0x3a340
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b6f8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3a340
movq %rbx, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x10(%rax), %rbp
cmpq %rbp, %r13
je 0x3b827
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %r12
movq (%r13), %rdx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
movq 0x68(%rax), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3b87e
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
cmpq %rax, %rdi
je 0x3b806
movb 0x30(%r14), %cl
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq (%rsi), %rsi
xorpd %xmm0, %xmm0
movq %rdi, %r8
movl (%r8), %r9d
movl 0x4(%r8), %r10d
testb %cl, %cl
movl %r9d, %r11d
cmovnel %r10d, %r11d
cmovnel %r9d, %r10d
movslq %r11d, %r9
leaq (%r9,%r9,2), %r9
movslq %r10d, %r10
movq (%rsi,%r9,8), %r9
movslq (%r9,%r10,4), %r9
xorpd %xmm1, %xmm1
cmpq $-0x1, %r9
je 0x3b7d1
testl %r9d, %r9d
js 0x3b83c
cmpq %r9, 0x8(%rdx)
jle 0x3b83c
movq (%rdx), %r10
movsd (%r10,%r9,8), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %r8
cmpq %rax, %r8
jne 0x3b78d
addsd 0x3333a(%rip), %xmm0    # 0x6eb20
ucomisd 0x20c0a(%rip), %xmm0    # 0x5c3f8
jbe 0x3b806
leal (%r15,%rbx), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3ab7e
incl %r15d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3b818
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3b73c
jmp 0x3b82a
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21a02(%rip), %rdi     # 0x5d245
leaq 0x21a18(%rip), %rsi     # 0x5d262
leaq 0x21a34(%rip), %rcx     # 0x5d285
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
jmp 0x3b85d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3b876
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x28(%rbx), %r13
movq (%r12), %rax
xorpd %xmm3, %xmm3
testq %rax, %rax
je 0x3b900
movq 0xd0(%r14), %rcx
movslq (%r13), %rdx
leaq (%rdx,%rdx,2), %rdx
movq (%rcx,%rdx,8), %rcx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
movapd %xmm0, %xmm4
movq (%rax), %rdx
movq 0x8(%rax), %rax
movslq 0x28(%rdx), %rsi
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
cmpnlesd %xmm1, %xmm4
movapd %xmm4, %xmm2
andnpd %xmm1, %xmm2
andpd %xmm0, %xmm4
orpd %xmm2, %xmm4
cmovaeq %rdx, %rbp
movapd %xmm4, %xmm0
testq %rax, %rax
jne 0x3b8c8
jmp 0x3b906
xorpd %xmm4, %xmm4
xorl %ebp, %ebp
movq 0x30(%rbx), %rax
testq %rax, %rax
movapd %xmm4, 0x10(%rsp)
je 0x3b96c
movq 0xd0(%r14), %rcx
movslq 0x28(%r12), %rdx
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movapd %xmm0, %xmm3
movq (%rax), %rsi
movq 0x8(%rax), %rax
movslq 0x28(%rsi), %rdi
leaq (%rdi,%rdi,2), %rdi
movq (%rcx,%rdi,8), %rdi
movsd (%rdi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
cmpnlesd %xmm1, %xmm3
movapd %xmm3, %xmm2
andnpd %xmm1, %xmm2
andpd %xmm0, %xmm3
orpd %xmm2, %xmm3
cmovaeq %rsi, %r15
movapd %xmm3, %xmm0
testq %rax, %rax
jne 0x3b92c
jmp 0x3b96f
xorl %r15d, %r15d
movapd %xmm3, 0x20(%rsp)
leaq 0x28(%r12), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3a37c
cmpq $0x0, 0x30(%rbx)
je 0x3b9a7
testq %rbp, %rbp
movapd 0x20(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
je 0x3b9d3
ucomisd %xmm1, %xmm0
jbe 0x3b9b8
jmp 0x3b9d3
testq %rbp, %rbp
movapd 0x20(%rsp), %xmm0
movapd 0x10(%rsp), %xmm1
je 0x3b9db
movq %rbp, %r12
testq %r15, %r15
je 0x3b89e
ucomisd %xmm0, %xmm1
movq %rbp, %r12
jae 0x3b89e
jmp 0x3b9ef
movq %r15, %rbx
jmp 0x3b89a
testq %r15, %r15
jne 0x3b9ef
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3314d(%rip), %rdi     # 0x6eb43
leaq 0x33158(%rip), %rsi     # 0x6eb55
leaq 0x3316c(%rip), %rcx     # 0x6eb70
movl $0x91, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x3bb80
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movq (%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3bb3a
maxsd (%rsp), %xmm0
movq 0x8(%r12), %r12
movapd %xmm0, %xmm1
testq %r12, %r12
jne 0x3bb57
jmp 0x3bb84
xorpd %xmm0, %xmm0
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0x3bbd7
movq 0xd0(%rbx), %rdx
movl 0x28(%r15), %eax
movslq %eax, %rsi
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm2
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
movslq 0x28(%rdi), %rdi
leaq (%rdi,%rdi,2), %rdi
movq (%rdx,%rdi,8), %rdi
movsd (%rdi,%rsi,8), %xmm3
cmplesd %xmm3, %xmm2
andpd %xmm2, %xmm3
andnpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movapd %xmm2, %xmm1
testq %rcx, %rcx
jne 0x3bba3
jmp 0x3bbdf
movl 0x28(%r15), %eax
xorpd %xmm1, %xmm1
movslq 0x28(%r14), %rcx
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0x30(%rbx)
movl %ecx, %esi
cmovnel %eax, %esi
movl %eax, %edi
cmovnel %ecx, %edi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movslq %edi, %rdi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx,%rdi,4), %rdx
cmpq $-0x1, %rdx
je 0x3bc28
testl %edx, %edx
js 0x3bc5a
movq 0x28(%rbx), %rsi
cmpq %rdx, 0x8(%rsi)
jle 0x3bc5a
movq (%rsi), %rsi
movsd (%rsi,%rdx,8), %xmm2
jmp 0x3bc2c
xorpd %xmm2, %xmm2
maxsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movq 0xd0(%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
cltq
movq (%rdx,%rcx,8), %rcx
movsd %xmm1, (%rcx,%rax,8)
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x215e4(%rip), %rdi     # 0x5d245
leaq 0x215fa(%rip), %rsi     # 0x5d262
leaq 0x21616(%rip), %rcx     # 0x5d285
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::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:
testq %rdx, %rdx
je 0x3bce4
movq 0xd0(%rdi), %rdi
xorpd %xmm1, %xmm1
xorl %eax, %eax
movapd %xmm1, %xmm0
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
leaq (%r9,%r9,2), %r9
movslq 0x28(%r10), %r10
movq (%rdi,%r9,8), %r9
movsd (%r9,%r10,8), %xmm2
ucomisd %xmm1, %xmm2
cmpnlesd %xmm2, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm1, %xmm0
orpd %xmm3, %xmm0
cmovaeq %r8, %rax
movapd %xmm0, %xmm1
testq %rdx, %rdx
jne 0x3bc90
retq
xorps %xmm0, %xmm0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x450a6
movq %r15, 0x18(%rbx)
movq %r14, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
xorl %eax, %eax
movq %rax, 0x58(%rbx)
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, 0x60(%rbx)
movq %r14, 0x8(%rsp)
movq %rax, 0x18(%rsp)
testq %r14, %r14
js 0x41c7e
leaq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x41168
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x10(%rsi)
callq 0x41168
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a8d7(%rip), %rdi     # 0x5c55c
leaq 0x1a965(%rip), %rsi     # 0x5c5f1
leaq 0x1b759(%rip), %rcx     # 0x5d3ec
movl $0x4a, %edx
callq 0x9200
jmp 0x41c9f
movq %rax, %r14
movq 0x50(%rbx), %rdi
callq 0x93d0
movq 0x38(%rbx), %rdi
callq 0x93d0
movq 0x28(%rbx), %rdi
callq 0x93d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x41cd1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x9350
movq %r14, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
callq 0x450a6
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x60(%rbx)
movl $0x10, %edi
callq 0x4511e
movq %rax, %r15
leaq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x10120
leaq 0x28(%rbx), %r12
movq %r15, 0x48(%rbx)
movq 0x28(%r14), %r13
movq 0x30(%r14), %r15
cmpq %r15, 0x30(%rbx)
je 0x41d69
testq %r15, %r15
js 0x41e2c
movl $0x1, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0xff4c
cmpq %r15, 0x30(%rbx)
jne 0x41e4b
movq (%r12), %rax
movq %r15, %rcx
shrq $0x3f, %rcx
addq %r15, %rcx
andq $-0x2, %rcx
cmpq $0x2, %r15
jl 0x41d96
xorl %edx, %edx
movaps (%r13,%rdx,8), %xmm0
movaps %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x41d83
cmpq %r15, %rcx
jge 0x41daf
movsd (%r13,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x41d9b
leaq 0x38(%rbx), %r15
movq 0x38(%r14), %r12
movq 0x40(%r14), %r14
cmpq %r14, 0x40(%rbx)
je 0x41ddf
testq %r14, %r14
js 0x41e2c
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xff4c
cmpq %r14, 0x40(%rbx)
jne 0x41e4b
movq (%r15), %rax
movq %r14, %rcx
shrq $0x3f, %rcx
addq %r14, %rcx
andq $-0x2, %rcx
cmpq $0x2, %r14
jl 0x41e0a
xorl %edx, %edx
movaps (%r12,%rdx,8), %xmm0
movaps %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x41df8
cmpq %r14, %rcx
jge 0x41e22
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x41e0f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1b045(%rip), %rdi     # 0x5ce78
leaq 0x1ae9d(%rip), %rsi     # 0x5ccd7
leaq 0x1b1c6(%rip), %rcx     # 0x5d007
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
leaq 0x1b22e(%rip), %rdi     # 0x5d080
leaq 0x1a6e0(%rip), %rsi     # 0x5c539
leaq 0x1b4ac(%rip), %rcx     # 0x5d30c
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
movq %rax, %r14
movq %r15, %rdi
callq 0x93d0
jmp 0x41e7a
movq %rax, %r14
movq 0x50(%rbx), %rdi
callq 0x93d0
movq 0x38(%rbx), %rdi
callq 0x93d0
movq 0x28(%rbx), %rdi
callq 0x93d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x41ea9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x9350
movq %r14, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x68, %edi
callq 0x9340
movq %rax, %rbx
testq %r15, %r15
je 0x42594
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41cda
jmp 0x425d4
leaq 0x88(%r14), %rsi
movslq 0x108(%r14), %rdx
movslq 0x10c(%r14), %rcx
movq %rbx, %rdi
callq 0x41c00
movl $0x10, %edi
callq 0x4511e
movq %rax, %r15
addq $0x120, %r14            # imm = 0x120
movq %rax, %rdi
movq %r14, %rsi
callq 0x10120
movq %r15, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x93d0
jmp 0x425fc
jmp 0x425ec
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x9350
movq %r14, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4256a
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x41f5e
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_O3/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
movl $0x0, (%rsp)
leaq 0x100(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %r8
movq %r14, %r9
callq 0x3b3dc
movl (%rbx), %esi
movq %rbp, %rdi
callq 0x3b70e
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 0x3b3dc
movl (%rbx), %esi
leaq 0x18(%rsp), %rdi
callq 0x3b70e
movslq %eax, %r14
addq (%rbx), %r14
movq %r14, (%rbx)
leaq 0x3efc0(%rip), %r15     # 0x846c0
addq $0x10, %r15
leaq 0xe8(%rsp), %rbx
movq %r15, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x2f65a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45734
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
leaq 0x80(%rsp), %rdi
callq 0x37c14
leaq 0x1d0(%rsp), %rbx
movq %r15, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x2f65a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45771
movq 0x1c8(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
subl 0x10(%rsp), %r14d
leaq 0x168(%rsp), %rdi
callq 0x37c14
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 0x37bce
jmp 0x457ac
jmp 0x457a9
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x37bce
movq %rbx, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45f4a
movq (%rbx), %rdi
movq (%r14), %rdx
movq (%r15), %r8
movq %rbx, %rsi
movq %r14, %rcx
callq 0x46006
leaq 0x28(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x45fd6
leaq 0x28(%rsp), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x5, %rax
movq %rax, %xmm1
movq 0x2817d(%rip), %xmm2    # 0x6dda0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x28181(%rip), %xmm3    # 0x6ddb0
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 0x9670
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
cmpltsd 0x407e5(%rip), %xmm0    # 0x86468
andnpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xdb72
movaps 0x10(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x45ca6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdb72
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 0x45f4a
movq (%r14), %rdi
movq (%rbx), %rdx
movq (%r15), %r8
movq %r14, %rsi
movq %rbx, %rcx
callq 0x46006
leaq 0x8(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x45fd6
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %xmm0
punpckldq 0x28070(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x28078(%rip), %xmm0    # 0x6ddb0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
cmpltsd 0x40713(%rip), %xmm1    # 0x86468
andnpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
callq 0xdb72
movaps 0x20(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x45d75
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdb72
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq (%rdi), %r13
callq 0x9060
movq %rax, %rbx
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x0, (%rbx)
leaq 0x10(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x94a0
cmpq %r13, (%rbp)
je 0x45edf
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x45eeb
movl (%rbx), %ebp
cmpl $0x22, %ebp
je 0x45eeb
testl %ebp, %ebp
jne 0x45df8
movl 0xc(%rsp), %ebp
movl %ebp, (%rbx)
movq (%r12), %r12
movl $0x0, (%rbx)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x94a0
cmpq %r12, (%r13)
je 0x45ef7
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x80000000(%rax), %rdx
cmpq %rcx, %rdx
jb 0x45f03
movl (%rbx), %edx
cmpl $0x22, %edx
je 0x45f03
testl %edx, %edx
jne 0x45e4c
movl %ebp, (%rbx)
movq (%r15), %rdx
movq 0x8(%r15), %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rsi
cmpq %r14, %rsi
jbe 0x45f0f
movq 0x8(%rdx), %rdi
subq (%rdx), %rdi
movq %rdi, %r8
sarq $0x3, %r8
cmpq %rax, %r8
jbe 0x45f0f
leaq (%r14,%r14,2), %r8
shlq $0x1d, %rdi
addq %rcx, %rdi
movq (%rdx,%r8,8), %r8
sarq $0x1d, %rdi
movsd (%r8,%rdi), %xmm1
shlq $0x20, %rsi
addq %rcx, %rsi
sarq $0x20, %rsi
leaq (%rsi,%rsi,2), %rcx
movq (%rdx,%rcx,8), %rcx
addsd (%rcx,%rax,8), %xmm1
subsd (%r8,%rax,8), %xmm1
movapd %xmm1, %xmm0
cmpltsd 0x4059c(%rip), %xmm0    # 0x86468
andnpd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x163ac(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x163a0(%rip), %rdi     # 0x5c292
callq 0x94d0
leaq 0x16394(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x16388(%rip), %rdi     # 0x5c292
callq 0x94d0
leaq 0x290d6(%rip), %rdi     # 0x6efec
leaq 0x29103(%rip), %rsi     # 0x6f020
leaq 0x2910f(%rip), %rcx     # 0x6f033
movl $0x2b, %edx
callq 0x9200
cmpl $0x0, (%rbx)
jne 0x45f42
movl %ebp, (%rbx)
jmp 0x45f42
cmpl $0x0, (%rbx)
jne 0x45f42
movl 0xc(%rsp), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x80, %rsp
movq 0x30(%rdi), %r8
testq %r8, %r8
js 0x47ab1
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x47ab1
movq %rcx, 0x10(%rsp)
movq %r8, 0x18(%rsp)
cmpq %r8, %rax
jb 0x47ad0
movq %r8, %r10
testb $0x7, %cl
jne 0x479a7
movl %ecx, %r10d
shrl $0x3, %r10d
andl $0x1, %r10d
cmpq %r8, %r10
cmovaeq %r8, %r10
movq %r8, %r11
subq %r10, %r11
movq %r11, %r9
shrq $0x3f, %r9
addq %r11, %r9
andq $-0x2, %r9
testq %r10, %r10
je 0x479e5
xorl %ebx, %ebx
movsd (%rsi,%rbx,8), %xmm0
addsd %xmm0, %xmm0
movsd (%rdx,%rbx,8), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rbx,8)
incq %rbx
cmpq %rbx, %r10
jne 0x479c2
addq %r10, %r9
cmpq $0x2, %r11
jl 0x47a15
movupd (%rsi,%r10,8), %xmm0
addpd %xmm0, %xmm0
movupd (%rdx,%r10,8), %xmm1
mulpd %xmm1, %xmm0
subpd %xmm1, %xmm0
movapd %xmm0, (%rcx,%r10,8)
addq $0x2, %r10
cmpq %r9, %r10
jl 0x479ee
cmpq %r8, %r9
jge 0x47a40
movsd (%rsi,%r9,8), %xmm0
addsd %xmm0, %xmm0
movsd (%rdx,%r9,8), %xmm1
mulsd %xmm1, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0x47a1a
testq %rdx, %rdx
sete %sil
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
setns %r8b
orb %sil, %r8b
je 0x47aef
movq %rax, %r8
subq %rcx, %r8
movq %r8, %rsi
orq %rcx, %rsi
js 0x47ad0
leaq (%rdx,%r8,8), %r9
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
movq %rdi, 0x8(%rsi)
movq %r9, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rdx, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq %r8, 0x40(%rsi)
movq %rax, 0x50(%rsi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
xorl %ecx, %ecx
callq 0x47b0e
movb $0x1, %al
addq $0x80, %rsp
popq %rbx
retq
leaq 0x150ef(%rip), %rdi     # 0x5cba7
leaq 0x14e65(%rip), %rsi     # 0x5c924
leaq 0x15c98(%rip), %rcx     # 0x5d75e
movl $0xa3, %edx
callq 0x9200
leaq 0x14d14(%rip), %rdi     # 0x5c7eb
leaq 0x14c38(%rip), %rsi     # 0x5c716
leaq 0x27973(%rip), %rcx     # 0x6f458
movl $0x93, %edx
callq 0x9200
leaq 0x14d84(%rip), %rdi     # 0x5c87a
leaq 0x14e27(%rip), %rsi     # 0x5c924
leaq 0x27a40(%rip), %rcx     # 0x6f544
movl $0xaf, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x94f0
testl %eax, %eax
jne 0x4b36f
movq %r14, %rdi
callq 0x9280
movb 0x151(%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x9220
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x94f0
testl %eax, %eax
jne 0x4b9f6
movsd 0xa0(%rbx), %xmm2
mulsd 0x249fa(%rip), %xmm2    # 0x70320
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm0, %xmm1
jbe 0x4b9d7
movsd %xmm1, 0xa0(%rbx)
leaq 0x90(%rbx), %r15
movq (%r14), %r12
movq 0x8(%r14), %r14
cmpq %r14, 0x98(%rbx)
je 0x4b992
movsd %xmm2, 0x8(%rsp)
testq %r14, %r14
js 0x4b9fd
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xff4c
cmpq %r14, 0x98(%rbx)
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
jne 0x4ba1c
movq (%r15), %rax
movq %r14, %rcx
shrq $0x3f, %rcx
addq %r14, %rcx
andq $-0x2, %rcx
cmpq $0x2, %r14
jl 0x4b9bf
xorl %edx, %edx
movapd (%r12,%rdx,8), %xmm0
movapd %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x4b9ab
cmpq %r14, %rcx
jge 0x4b9d7
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x4b9c4
ucomisd %xmm1, %xmm2
seta %bpl
movq %rbx, %rdi
callq 0x9280
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x9220
leaq 0x11474(%rip), %rdi     # 0x5ce78
leaq 0x112cc(%rip), %rsi     # 0x5ccd7
leaq 0x115f5(%rip), %rcx     # 0x5d007
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
leaq 0x1165d(%rip), %rdi     # 0x5d080
leaq 0x10b0f(%rip), %rsi     # 0x5c539
leaq 0x118db(%rip), %rcx     # 0x5d30c
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x94f0
testl %eax, %eax
jne 0x4bb3a
movsd (%r14), %xmm1
movsd 0xa0(%rbx), %xmm0
movsd 0x23205(%rip), %xmm2    # 0x6ec78
mulsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x4bb1b
movsd %xmm0, (%r14)
movq 0x90(%rbx), %r12
movq 0x98(%rbx), %r14
cmpq %r14, 0x8(%r15)
je 0x4bad6
movsd %xmm2, (%rsp)
movsd %xmm1, 0x8(%rsp)
testq %r14, %r14
js 0x4bb41
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xff4c
cmpq %r14, 0x8(%r15)
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
jne 0x4bb60
movq (%r15), %rax
movq %r14, %rcx
shrq $0x3f, %rcx
addq %r14, %rcx
andq $-0x2, %rcx
cmpq $0x2, %r14
jl 0x4bb03
xorl %edx, %edx
movapd (%r12,%rdx,8), %xmm0
movapd %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x4baef
cmpq %r14, %rcx
jge 0x4bb1b
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x4bb08
ucomisd %xmm2, %xmm1
seta %bpl
movq %rbx, %rdi
callq 0x9280
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x9220
leaq 0x11330(%rip), %rdi     # 0x5ce78
leaq 0x11188(%rip), %rsi     # 0x5ccd7
leaq 0x114b1(%rip), %rcx     # 0x5d007
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
leaq 0x11519(%rip), %rdi     # 0x5d080
leaq 0x109cb(%rip), %rsi     # 0x5c539
leaq 0x11797(%rip), %rcx     # 0x5d30c
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rsi
cmpq 0x10(%rbx), %rsi
je 0x54ca8
movq %rdi, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x54cbb
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x30c50
movq (%r14), %rdi
movq (%rdi), %r14
testq %r14, %r14
je 0x54cf9
movl $0x1, %r15d
movl $0x1, %ebp
movl $0x1, %r12d
imull %r15d, %ebp
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x54c80
imull %eax, %r12d
movq 0x8(%r14), %r14
incl %r15d
testq %r14, %r14
jne 0x54cd4
imull %r12d, %ebp
jmp 0x54cfe
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq (%rdi), %r14
movl $0x1, %ebp
testq %r14, %r14
je 0x551f9
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x551c9
addl %eax, %ebp
movq 0x8(%r14), %r14
jmp 0x551e1
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x577d0
movl %ebp, (%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/EditDist.cpp
// Function: GetLastRemoved(newick_node*, std::map<newick_node*, int, std::less<newick_node*>, std::allocator<std::pair<newick_node* const, int>>>&, int, int)
newick_node* GetLastRemoved(newick_node* root, map<newick_node*, int>& R, int i, int j)
{
    list<newick_node*> D(1, root);
    int ii = 0;
    while (i--)
    {
        root = D.front();
        R[root] = ii++;
        D.pop_front();
        auto it = D.begin();
        for (newick_child* child = root->child; child; child = child->next)
            D.insert(it, child->node);
    }
    while (j--)
    {
        root = D.back();
        D.pop_back();
        for (newick_child* child = root->child; child; child = child->next)
            D.push_back(child->node);
    }
    return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, 0x30(%rsp)
leaq 0x10(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x18(%rsp), %rbx
leaq 0xf(%rsp), %rcx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x3b228
testl %r14d, %r14d
je 0x555be
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x577d0
movl %r12d, (%rax)
movq 0x18(%rsp), %r13
decq 0x28(%rsp)
movq %r13, %rdi
callq 0x95b0
movl $0x18, %esi
movq %r13, %rdi
callq 0x9350
movq 0x10(%rsp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x555af
movq 0x18(%rsp), %r13
movl $0x18, %edi
callq 0x9340
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0x9080
incq 0x28(%rsp)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x55585
decl %r14d
incl %r12d
testl %r14d, %r14d
jne 0x55534
testl %ebp, %ebp
je 0x55627
leaq 0x18(%rsp), %r14
movq 0x20(%rsp), %r15
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
decq 0x28(%rsp)
movq %r15, %rdi
callq 0x95b0
movl $0x18, %esi
movq %r15, %rdi
callq 0x9350
movq 0x10(%rsp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x55623
movl $0x18, %edi
callq 0x9340
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x9080
incq 0x28(%rsp)
movq 0x8(%r15), %r15
jmp 0x555f7
decl %ebp
jne 0x555c7
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x5564b
movq (%rdi), %r15
movl $0x18, %esi
callq 0x9350
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x55636
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55661
jmp 0x55661
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x55683
movq (%rdi), %r15
movl $0x18, %esi
callq 0x9350
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x5566e
movq %r14, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: check_overflow(long)
void check_overflow(index_t i) {
	if
#ifdef USE_COEFFICIENTS
	    (i > max_simplex_index)
#else
	    (i < 0)
#endif
		throw std::overflow_error("simplex index " + std::to_string((uint64_t)i) +
		                          " in filtration is larger than maximum index " +
		                          std::to_string(max_simplex_index));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
testq %rdi, %rdi
js 0x2a8c
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x49b7
leaq 0x9610(%rip), %rsi      # 0xc0c0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x4947
leaq 0x9609(%rip), %rsi      # 0xc0cf
leaq 0x68(%rsp), %rdi
callq 0x23b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2af1
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2afe
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movabsq $0x7fffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFF
callq 0x4a47
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x489f
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x2140
xorl %ebp, %ebp
movq 0xf453(%rip), %rsi      # 0x11fb0
movq 0xf444(%rip), %rdx      # 0x11fa8
movq %rbx, %rdi
callq 0x2330
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b8d
callq 0x21d0
jmp 0x2b8d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ba8
callq 0x21d0
jmp 0x2ba8
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bbf
callq 0x21d0
jmp 0x2bbf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bd2
callq 0x21d0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2be5
callq 0x21d0
testb %bpl, %bpl
jne 0x2c07
jmp 0x2c0f
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c07
callq 0x21d0
jmp 0x2c07
movq %rax, %r14
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: is_prime(unsigned short)
bool is_prime(const coefficient_t n) {
	if (!(n & 1) || n < 2) return n == 2;
	for (coefficient_t p = 3; p <= n / p; p += 2)
		if (!(n % p)) return false;
	return true;
}

// Assembly:
testb $0x1, %dil
sete %al
cmpw $0x2, %di
setb %cl
orb %al, %cl
je 0x2c32
cmpw $0x2, %di
sete %cl
jmp 0x2c5c
movb $0x1, %cl
cmpw $0x9, %di
jb 0x2c5c
movl $0x3, %esi
movl %edi, %eax
xorl %edx, %edx
divl %esi
testl %edx, %edx
setne %cl
je 0x2c5c
addl $0x2, %esi
movzwl %si, %esi
movl %edi, %eax
xorl %edx, %edx
divl %esi
cmpl %eax, %esi
jbe 0x2c3f
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: multiplicative_inverse_vector(unsigned short)
std::vector<coefficient_t> multiplicative_inverse_vector(const coefficient_t m) {
	std::vector<coefficient_t> inverse(m);
	inverse[1] = 1;
	// m = a * (m / a) + m % a
	// Multipying with inverse(a) * inverse(m % a):
	// 0 = inverse(m % a) * (m / a) + inverse(a)  (mod m)
	for (coefficient_t a = 2; a < m; ++a) inverse[a] = m - (inverse[m % a] * (m / a)) % m;
	return inverse;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x4afc
movq (%rbx), %rcx
movw $0x1, 0x2(%rcx)
cmpw $0x3, %bp
jb 0x2cbb
movzwl %bp, %esi
movl $0x2, %edi
movl %ebp, %eax
xorl %edx, %edx
divw %di
movzwl %dx, %edx
movzwl (%rcx,%rdx,2), %edx
movzwl %ax, %eax
imull %edx, %eax
xorl %edx, %edx
divl %esi
movl %ebp, %eax
subl %edx, %eax
movw %ax, (%rcx,%rdi,2)
incq %rdi
cmpq %rdi, %r14
jne 0x2c93
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: ripser<compressed_distance_matrix<(compressed_matrix_layout)0>>::get_edges()
std::vector<diameter_index_t> ripser<compressed_lower_distance_matrix>::get_edges() {
	std::vector<diameter_index_t> edges;
	std::vector<index_t> vertices(2);
	for (index_t index = binomial_coeff(n, 2); index-- > 0;) {
		get_simplex_vertices(index, 1, dist.size(), vertices.rbegin());
		value_t length = dist(vertices[0], vertices[1]);
		if (length <= threshold) edges.push_back({length, index});
	}
	return edges;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x10, %edi
callq 0x2210
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x30(%r15), %rax
movq 0x50(%r15), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx,%rax,8), %r12
testq %r12, %r12
jle 0x2ec7
decq %r12
movq %rsp, %r13
movq 0x20(%r15), %rcx
subq 0x18(%r15), %rcx
sarq $0x3, %rcx
decq %rcx
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5cbc
movq %rax, 0x8(%r14)
movq 0x50(%r15), %rcx
movq 0x30(%rcx), %rdx
movq %r12, %rcx
subq (%rdx,%rax,8), %rcx
movq %rcx, (%r14)
xorps %xmm0, %xmm0
cmpq %rax, %rcx
je 0x2e7a
movq 0x18(%r15), %rdx
movq %rax, %rsi
cmovgq %rcx, %rsi
cmovlq %rcx, %rax
movq (%rdx,%rsi,8), %rcx
movss (%rcx,%rax,4), %xmm0
movss 0x40(%r15), %xmm1
ucomiss %xmm0, %xmm1
jb 0x2eb2
movss %xmm0, (%rsp)
movq %r12, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2ea7
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2eb2
movq %rbx, %rdi
movq %r13, %rdx
callq 0x5d18
leaq -0x1(%r12), %rax
incq %r12
cmpq $0x1, %r12
movq %rax, %r12
ja 0x2e25
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2ee2
movq %rax, %r15
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2efa
callq 0x21d0
movq %r15, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: ripser<sparse_distance_matrix>::get_edges()
std::vector<diameter_index_t> ripser<sparse_distance_matrix>::get_edges() {
	std::vector<diameter_index_t> edges;
	for (index_t i = 0; i < n; ++i)
		for (auto n : dist.neighbors[i]) {
			index_t j = get_index(n);
			if (i > j) edges.push_back({get_diameter(n), get_edge_index(i, j)});
		}
	return edges;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rax
testq %rax, %rax
jle 0x2fa9
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq (%r14), %rcx
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %r13
movq 0x8(%rcx,%rdx,8), %rbp
cmpq %rbp, %r13
je 0x2fa1
movq (%r13), %rax
cmpq %rax, %r12
jle 0x2f94
movss 0x8(%r13), %xmm0
movq 0x40(%r14), %rcx
movq 0x30(%rcx), %rcx
addq (%rcx,%r12,8), %rax
movss %xmm0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2f89
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x2f94
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5d18
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x2f4a
movq 0x20(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x2f35
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2fcb
callq 0x21d0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/Ripser[P]ripser/ripser.cpp
// Function: read_lower_distance_matrix(std::istream&)
compressed_lower_distance_matrix read_lower_distance_matrix(std::istream& input_stream) {
	std::vector<value_t> distances;
	value_t value;
	while (input_stream >> value) {
		distances.push_back(value);
		input_stream.ignore();
	}

	return compressed_lower_distance_matrix(std::move(distances));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x23c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x35e4
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x35cf
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x35da
movq %r15, %rdi
movq %r12, %rdx
callq 0x5e50
movq %r14, %rdi
callq 0x2380
jmp 0x3595
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4e56
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3600
callq 0x21d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3611
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3623
callq 0x21d0
movq %rbx, %rdi
callq 0x2350