LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r12
xorpd %xmm0, %xmm0
testq %r12, %r12
je 0x3c480
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movq (%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3c438
maxsd (%rsp), %xmm0
movq 0x8(%r12), %r12
movapd %xmm0, %xmm1
testq %r12, %r12
jne 0x3c459
movq 0x30(%r15), %rax
testq %rax, %rax
xorpd %xmm3, %xmm3
je 0x3c4d2
movq 0xd0(%rbx), %rcx
movslq 0x28(%r14), %rdx
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm3
movq (%rax), %rsi
movq 0x8(%rax), %rax
movslq 0x28(%rsi), %rsi
leaq (%rsi,%rsi,2), %rsi
movq (%rcx,%rsi,8), %rsi
movsd (%rsi,%rdx,8), %xmm2
cmplesd %xmm2, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, %xmm1
testq %rax, %rax
jne 0x3c4a0
movslq 0x28(%r15), %rax
movslq 0x28(%r14), %rcx
movq 0x20(%rbx), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0x30(%rbx)
movl %eax, %esi
cmovnel %ecx, %esi
movl %ecx, %edi
cmovnel %eax, %edi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movslq %edi, %rdi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx,%rdi,4), %rdx
cmpq $-0x1, %rdx
je 0x3c51f
testl %edx, %edx
js 0x3c54f
movq 0x28(%rbx), %rsi
cmpq %rdx, 0x8(%rsi)
jle 0x3c54f
movq (%rsi), %rsi
movsd (%rsi,%rdx,8), %xmm1
jmp 0x3c523
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movq 0xd0(%rbx), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movsd %xmm3, (%rax,%rcx,8)
movapd %xmm3, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x20ccf(%rip), %rdi     # 0x5d225
leaq 0x20ce5(%rip), %rsi     # 0x5d242
leaq 0x20d01(%rip), %rcx     # 0x5d265
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c5d8
movq 0xd0(%rdi), %rdi
xorpd %xmm1, %xmm1
xorl %eax, %eax
movapd %xmm1, %xmm0
testb %cl, %cl
movq (%rdx), %r8
movq %r8, %r9
cmovneq %rsi, %r9
movq 0x8(%rdx), %rdx
movq %rsi, %r10
cmovneq %r8, %r10
movslq 0x28(%r10), %r10
leaq (%r10,%r10,2), %r10
movslq 0x28(%r9), %r9
movq (%rdi,%r10,8), %r10
movsd (%r10,%r9,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 0x3c584
retq
xorps %xmm0, %xmm0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x458e4
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 0x423d6
leaq 0x28(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x41a26
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x10(%rsi)
callq 0x41a26
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1a15f(%rip), %rdi     # 0x5c53c
leaq 0x1a1ed(%rip), %rsi     # 0x5c5d1
leaq 0x1afe1(%rip), %rcx     # 0x5d3cc
movl $0x4a, %edx
callq 0x9200
jmp 0x423f7
movq %rax, %r14
movq 0x50(%rbx), %rdi
callq 0x93c0
movq 0x38(%rbx), %rdi
callq 0x93c0
movq 0x28(%rbx), %rdi
callq 0x93c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x42429
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x9340
movq %r14, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x458e4
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%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 0x4595c
movq %rax, %r12
leaq 0x50(%r14), %rsi
movq %rax, %rdi
callq 0x1022e
leaq 0x28(%rbx), %r15
movq %r12, 0x48(%rbx)
movq 0x28(%r14), %r13
movq 0x30(%r14), %r12
cmpq %r12, 0x30(%rbx)
je 0x424be
testq %r12, %r12
js 0x425b3
movl $0x1, %ecx
movq %r15, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0x10056
movq 0x30(%rbx), %rax
cmpq %r12, %rax
jne 0x42594
movq (%r15), %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0x424f7
xorl %esi, %esi
movaps (%r13,%rsi,8), %xmm0
movaps %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0x424e4
cmpq %rax, %rdx
jge 0x42510
movsd (%r13,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x424fc
leaq 0x38(%rbx), %r15
movq 0x38(%r14), %r12
movq 0x40(%r14), %r14
cmpq %r14, 0x40(%rbx)
je 0x4253e
testq %r14, %r14
js 0x425b3
movl $0x1, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x10056
movq 0x40(%rbx), %rax
cmpq %r14, %rax
jne 0x42594
movq (%r15), %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0x42572
xorl %esi, %esi
movaps (%r12,%rsi,8), %xmm0
movaps %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0x42560
cmpq %rax, %rdx
jge 0x4258a
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x42577
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1aac5(%rip), %rdi     # 0x5d060
leaq 0x19f77(%rip), %rsi     # 0x5c519
leaq 0x1ad43(%rip), %rcx     # 0x5d2ec
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
leaq 0x1a89e(%rip), %rdi     # 0x5ce58
leaq 0x1a6f6(%rip), %rsi     # 0x5ccb7
leaq 0x1aa1f(%rip), %rcx     # 0x5cfe7
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
movq %rax, %r14
movq %r12, %rdi
callq 0x93c0
jmp 0x425e2
movq %rax, %r14
movq 0x50(%rbx), %rdi
callq 0x93c0
movq 0x38(%rbx), %rdi
callq 0x93c0
movq 0x28(%rbx), %rdi
callq 0x93c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x42611
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x9340
movq %r14, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9330
movq %rax, %rbx
testq %r15, %r15
je 0x42cf0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42432
jmp 0x42d30
leaq 0x88(%r14), %rsi
movslq 0x108(%r14), %rdx
movslq 0x10c(%r14), %rcx
movq %rbx, %rdi
callq 0x42358
movl $0x10, %edi
callq 0x4595c
movq %rax, %r15
addq $0x120, %r14            # imm = 0x120
movq %rax, %rdi
movq %r14, %rsi
callq 0x1022e
movq %r15, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x93c0
jmp 0x42d58
jmp 0x42d48
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x9340
movq %r14, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42cc6
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x426c6
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_O1/canzarlab[P]Trajan/src/BnG.cpp
// Function: DFBnBSolver::EvalOpen()
vector<BnBNode*> DFBnBSolver::EvalOpen()
{
    BnBNode* lt = Open.back(); Open.pop_back();

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x168(%rsi), %rax
leaq -0x8(%rax), %rcx
movq -0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, 0x168(%r14)
subq 0x160(%r14), %rcx
cmpq $0x9, %rcx
jb 0x4441c
movq -0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movsd 0x60(%rsi), %xmm0
ucomisd 0x18083(%rip), %xmm0    # 0x5c3a8
jne 0x44359
jp 0x44359
movq (%r14), %rax
movsd 0x195d4(%rip), %xmm0    # 0x5d908
movsd 0x2becc(%rip), %xmm1    # 0x70208
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x44359
movq 0x8(%rsp), %rax
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rsp), %rsi
cmpq 0x48(%rsi), %rax
jne 0x4441c
addq $-0x8, 0x168(%r14)
movsd 0x60(%rsi), %xmm0
ucomisd 0x18022(%rip), %xmm0    # 0x5c3a8
jne 0x443ba
jp 0x443ba
movq (%r14), %rax
movsd 0x19573(%rip), %xmm0    # 0x5d908
movsd 0x2be6b(%rip), %xmm1    # 0x70208
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x443ba
movq 0x10(%rsp), %rax
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd 0x60(%rcx), %xmm0
ucomisd 0x60(%rax), %xmm0
jbe 0x443da
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsd 0x17fc1(%rip), %xmm0    # 0x5c3a8
ucomisd 0x60(%rax), %xmm0
jbe 0x4441c
movq 0x168(%r14), %rsi
cmpq 0x170(%r14), %rsi
je 0x4440b
movq %rax, (%rsi)
addq $0x8, 0x168(%r14)
jmp 0x4441c
leaq 0x160(%r14), %rdi
leaq 0x10(%rsp), %rdx
callq 0x462ac
xorpd %xmm0, %xmm0
movupd %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%rsp), %rsi
movsd 0x60(%rsi), %xmm0
ucomisd 0x2bdd2(%rip), %xmm0    # 0x70210
jne 0x44442
jnp 0x44491
ucomisd 0x17f5e(%rip), %xmm0    # 0x5c3a8
jne 0x4446b
jp 0x4446b
movq (%r14), %rax
movsd 0x194af(%rip), %xmm0    # 0x5d908
movsd 0x2bda7(%rip), %xmm1    # 0x70208
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x44491
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x44484
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x44491
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x462ac
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x444b3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x9340
movq %r14, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bc9c
movl (%rbx), %esi
movq %rbp, %rdi
callq 0x3bffe
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 0x3bc9c
movl (%rbx), %esi
leaq 0x18(%rsp), %rdi
callq 0x3bffe
movslq %eax, %r14
addq (%rbx), %r14
movq %r14, (%rbx)
leaq 0x40762(%rip), %r15     # 0x866c0
addq $0x10, %r15
leaq 0xe8(%rsp), %rbx
movq %r15, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x30124
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45f92
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
leaq 0x80(%rsp), %rdi
callq 0x3839c
leaq 0x1d0(%rsp), %rbx
movq %r15, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x30124
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x45fcf
movq 0x1c8(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
subl 0x10(%rsp), %r14d
leaq 0x168(%rsp), %rdi
callq 0x3839c
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 0x38356
jmp 0x4600a
jmp 0x46007
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x38356
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4679e
movq (%rbx), %rdi
movq (%r14), %rdx
movq (%r15), %r8
movq %rbx, %rsi
movq %r14, %rcx
callq 0x46858
leaq 0x28(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x46828
leaq 0x28(%rsp), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x5, %rax
movq %rax, %xmm1
movq 0x28d89(%rip), %xmm2    # 0x6f200
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x28d8d(%rip), %xmm3    # 0x6f210
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 0x9660
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
cmpltsd 0x41f89(%rip), %xmm0    # 0x88460
andnpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0xdbb4
movaps 0x10(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x464fa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xdbb4
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4679e
movq (%r14), %rdi
movq (%rbx), %rdx
movq (%r15), %r8
movq %r14, %rsi
movq %rbx, %rcx
callq 0x46858
leaq 0x8(%rsp), %rdi
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %rsi
callq 0x46828
leaq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x5, %rax
movq %rax, %xmm0
punpckldq 0x28c7c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x28c84(%rip), %xmm0    # 0x6f210
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
cmpltsd 0x41eb7(%rip), %xmm1    # 0x88460
andnpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
callq 0xdbb4
movaps 0x20(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x465c9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdbb4
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
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 0x9490
cmpq %r13, (%rbp)
je 0x46751
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0x4675d
movl (%rbx), %eax
cmpl $0x22, %eax
je 0x4675d
testl %eax, %eax
jne 0x4664c
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movq (%r12), %r12
movl (%rbx), %ebp
movl $0x0, (%rbx)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x9490
cmpq %r12, (%r13)
je 0x46769
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x80000000(%rax), %rdx
cmpq %rcx, %rdx
jb 0x46775
movl (%rbx), %edx
cmpl $0x22, %edx
je 0x46775
testl %edx, %edx
jne 0x466a2
movl %ebp, (%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rsi
movslq %r15d, %r8
cmpq %r8, %rsi
jbe 0x46732
movq 0x8(%rdx), %rdi
subq (%rdx), %rdi
movq %rdi, %r9
sarq $0x3, %r9
cltq
cmpq %rax, %r9
jbe 0x46732
leaq (%r8,%r8,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 0x41d41(%rip), %xmm0    # 0x88460
andnpd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29c03(%rip), %rdi     # 0x7033c
leaq 0x29c30(%rip), %rsi     # 0x70370
leaq 0x29c3c(%rip), %rcx     # 0x70383
movl $0x2b, %edx
callq 0x9200
leaq 0x15b3a(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x15b2e(%rip), %rdi     # 0x5c292
callq 0x94c0
leaq 0x15b22(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x15b16(%rip), %rdi     # 0x5c292
callq 0x94c0
cmpl $0x0, (%rbx)
jne 0x46795
movl %ebp, (%rbx)
jmp 0x46795
cmpl $0x0, (%rbx)
jne 0x46795
movl 0xc(%rsp), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/LPInt.cpp
// Function: LPInt::AddConstraint(std::tuple<int, int> const&, std::tuple<int, int> const&)
void LPInt::AddConstraint(const ii& a, const ii& b)
{
    int i = get<0>(a), j = get<1>(a);
    int k = get<0>(b), l = get<1>(b);
    Triplets.emplace_back(nr_rows, K[i][j], 1.);
    Triplets.emplace_back(nr_rows++, K[k][l], 1.);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movslq 0x4(%rsi), %rcx
movslq (%rsi), %rax
movslq 0x4(%rdx), %r13
movslq (%rdx), %rbx
leaq 0x88(%rdi), %r14
movq 0xe0(%rdi), %rdx
leaq (%rcx,%rcx,2), %rcx
shlq $0x2, %rax
addq (%rdx,%rcx,8), %rax
leaq 0x108(%rdi), %rsi
movabsq $0x3ff0000000000000, %rbp # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %r12
movq %rbp, (%r12)
movq %r14, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x37e6c
movl 0x108(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x108(%r15)
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq 0xe0(%r15), %rax
leaq (,%r13,2), %rcx
addq %r13, %rcx
shlq $0x2, %rbx
addq (%rax,%rcx,8), %rbx
movq %rbp, (%r12)
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37eb2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48218
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x48218
movq %rcx, 0x10(%rsp)
movq %r8, 0x18(%rsp)
cmpq %r8, %rax
jl 0x48237
movq %r8, %r10
testb $0x7, %cl
jne 0x480ff
movl %ecx, %r10d
shrl $0x3, %r10d
andl $0x1, %r10d
cmpq %r8, %r10
cmovgeq %r8, %r10
movq %r8, %r11
subq %r10, %r11
movq %r11, %r9
shrq $0x3f, %r9
addq %r11, %r9
andq $-0x2, %r9
testq %r10, %r10
jle 0x4813d
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 0x4811a
addq %r10, %r9
cmpq $0x2, %r11
jl 0x4816d
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 0x48146
cmpq %r8, %r9
jge 0x48198
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 0x48172
testq %rdx, %rdx
sete %r8b
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rsi
testq %rsi, %rsi
setns %dil
orb %r8b, %dil
je 0x48256
movq %rax, %rdi
subq %rsi, %rdi
movq %rdi, %r8
orq %rsi, %r8
js 0x48237
leaq (%rdx,%rdi,8), %r8
movb $0x0, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movq %rdi, 0x68(%rsp)
movq %rax, 0x78(%rsp)
cmpq %rsi, 0x10(%rcx)
jne 0x48275
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xf(%rsp), %rdx
xorl %ecx, %ecx
callq 0x48294
movb $0x1, %al
addq $0x80, %rsp
popq %rbx
retq
leaq 0x14968(%rip), %rdi     # 0x5cb87
leaq 0x146de(%rip), %rsi     # 0x5c904
leaq 0x15511(%rip), %rcx     # 0x5d73e
movl $0xa3, %edx
callq 0x9200
leaq 0x1458d(%rip), %rdi     # 0x5c7cb
leaq 0x144b1(%rip), %rsi     # 0x5c6f6
leaq 0x2855c(%rip), %rcx     # 0x707a8
movl $0x93, %edx
callq 0x9200
leaq 0x145fd(%rip), %rdi     # 0x5c85a
leaq 0x146a0(%rip), %rsi     # 0x5c904
leaq 0x28629(%rip), %rcx     # 0x70894
movl $0xaf, %edx
callq 0x9200
leaq 0x166ac(%rip), %rdi     # 0x5e928
leaq 0x16731(%rip), %rsi     # 0x5e9b4
leaq 0x286e9(%rip), %rcx     # 0x70973
movl $0x61, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Geno.h
// Function: CoveringJRF::getBoundsConstraints(double*, double*)
bool getBoundsConstraints(Scalar* cl, Scalar* cu) override
    {
    // we have equality constraints here
        Vector::MapType(cl, _m) = _b;
        Vector::MapType(cu, _m) = Vector::Constant(_m, INF);
        return true;
    }

// Assembly:
pushq %rax
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x49f97
movq 0x10(%rdi), %rcx
cmpq 0x8(%rcx), %rax
jne 0x49fb6
movq %rax, %r8
testb $0x7, %sil
jne 0x49ea7
movl %esi, %r8d
shrl $0x3, %r8d
andl $0x1, %r8d
cmpq %rax, %r8
cmovgeq %rax, %r8
movq (%rcx), %rcx
movq %rax, %r10
subq %r8, %r10
movq %r10, %r9
shrq $0x3f, %r9
addq %r10, %r9
andq $-0x2, %r9
testq %r8, %r8
jle 0x49eda
xorl %r11d, %r11d
movsd (%rcx,%r11,8), %xmm0
movsd %xmm0, (%rsi,%r11,8)
incq %r11
cmpq %r11, %r8
jne 0x49ec6
addq %r8, %r9
cmpq $0x2, %r10
jl 0x49ef6
movups (%rcx,%r8,8), %xmm0
movaps %xmm0, (%rsi,%r8,8)
addq $0x2, %r8
cmpq %r9, %r8
jl 0x49ee3
cmpq %rax, %r9
jge 0x49f0f
movsd (%rcx,%r9,8), %xmm0
movsd %xmm0, (%rsi,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x49efb
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x49fd5
movq %rax, %rcx
testb $0x7, %dl
jne 0x49f33
movl %edx, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rax, %r8
subq %rcx, %r8
movq %r8, %rsi
shrq $0x3f, %rsi
addq %r8, %rsi
andq $-0x2, %rsi
movabsq $0x7ff0000000000000, %rdi # imm = 0x7FF0000000000000
testq %rcx, %rcx
jle 0x49f65
xorl %r9d, %r9d
movq %rdi, (%rdx,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x49f59
addq %rcx, %rsi
cmpq $0x2, %r8
jl 0x49f82
movaps 0x2530b(%rip), %xmm0    # 0x6f280
movaps %xmm0, (%rdx,%rcx,8)
addq $0x2, %rcx
cmpq %rsi, %rcx
jl 0x49f75
cmpq %rax, %rsi
jge 0x49f93
movq %rdi, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x49f87
movb $0x1, %al
popq %rcx
retq
leaq 0x12be9(%rip), %rdi     # 0x5cb87
leaq 0x1295f(%rip), %rsi     # 0x5c904
leaq 0x12be8(%rip), %rcx     # 0x5cb94
movl $0xa3, %edx
callq 0x9200
leaq 0x14594(%rip), %rdi     # 0x5e551
leaq 0x145f6(%rip), %rsi     # 0x5e5ba
leaq 0x25381(%rip), %rcx     # 0x6f34c
movl $0x101, %edx            # imm = 0x101
callq 0x9200
leaq 0x12560(%rip), %rdi     # 0x5c53c
leaq 0x125ee(%rip), %rsi     # 0x5c5d1
leaq 0x133e2(%rip), %rcx     # 0x5d3cc
movl $0x4a, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x94e0
testl %eax, %eax
jne 0x4b9af
movq %r14, %rdi
callq 0x9270
movb 0x151(%rbx), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x9210
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
callq 0x94e0
testl %eax, %eax
jne 0x4c00f
movsd 0xa0(%rbx), %xmm2
mulsd 0x25880(%rip), %xmm2    # 0x717c0
movsd (%rsp), %xmm0
ucomisd %xmm0, %xmm2
movapd %xmm0, %xmm1
jbe 0x4bff0
movsd %xmm1, 0xa0(%rbx)
leaq 0x90(%rbx), %r14
movq (%r15), %r12
movq 0x8(%r15), %r15
cmpq %r15, 0x98(%rbx)
je 0x4bf9f
movsd %xmm2, 0x8(%rsp)
testq %r15, %r15
js 0x4c035
movl $0x1, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x10056
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq 0x98(%rbx), %rax
cmpq %r15, %rax
jne 0x4c016
movq (%r14), %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0x4bfd8
xorl %esi, %esi
movapd (%r12,%rsi,8), %xmm0
movapd %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0x4bfc4
cmpq %rax, %rdx
jge 0x4bff0
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4bfdd
ucomisd %xmm1, %xmm2
seta %bpl
movq %rbx, %rdi
callq 0x9270
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x9210
leaq 0x11043(%rip), %rdi     # 0x5d060
leaq 0x104f5(%rip), %rsi     # 0x5c519
leaq 0x112c1(%rip), %rcx     # 0x5d2ec
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
leaq 0x10e1c(%rip), %rdi     # 0x5ce58
leaq 0x10c74(%rip), %rsi     # 0x5ccb7
leaq 0x10f9d(%rip), %rcx     # 0x5cfe7
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x94e0
testl %eax, %eax
jne 0x4c151
movsd (%r15), %xmm1
movsd 0xa0(%rbx), %xmm0
movsd 0x23f4d(%rip), %xmm2    # 0x6ffd8
mulsd %xmm0, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x4c132
movsd %xmm0, (%r15)
movq 0x90(%rbx), %r12
movq 0x98(%rbx), %r15
cmpq %r15, 0x8(%r14)
je 0x4c0e4
movsd %xmm2, (%rsp)
movsd %xmm1, 0x8(%rsp)
testq %r15, %r15
js 0x4c177
movl $0x1, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x10056
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
movq 0x8(%r14), %rax
cmpq %r15, %rax
jne 0x4c158
movq (%r14), %rcx
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0x4c11a
xorl %esi, %esi
movapd (%r12,%rsi,8), %xmm0
movapd %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0x4c106
cmpq %rax, %rdx
jge 0x4c132
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4c11f
ucomisd %xmm2, %xmm1
seta %bpl
movq %rbx, %rdi
callq 0x9270
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x9210
leaq 0x10f01(%rip), %rdi     # 0x5d060
leaq 0x103b3(%rip), %rsi     # 0x5c519
leaq 0x1117f(%rip), %rcx     # 0x5d2ec
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
leaq 0x10cda(%rip), %rdi     # 0x5ce58
leaq 0x10b32(%rip), %rsi     # 0x5ccb7
leaq 0x10e5b(%rip), %rcx     # 0x5cfe7
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x55314
movq %rdi, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x55321
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3177a
movq 0x8(%rsp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x55364
movl $0x1, %r15d
movl $0x1, %ebp
movl $0x1, %r12d
imull %r15d, %ebp
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x552ec
imull %eax, %r12d
movq 0x8(%r14), %r14
incl %r15d
testq %r14, %r14
jne 0x5533f
imull %r12d, %ebp
jmp 0x55369
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_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movslq %esi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jne 0x553b7
movq %r14, %rdi
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x57e3e
movl %esi, %ebp
movq %rdi, %r15
movq (%rcx,%rax,8), %rax
movq (%rax), %rax
xorl %esi, %esi
testq %rax, %rax
je 0x553d3
movq 0x8(%rax), %rax
incq %rsi
jmp 0x553c5
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0xf540
movq (%r12), %rax
movq 0x8(%r12), %rcx
cmpq %rcx, %rax
je 0x55402
xorl %edx, %edx
movl %edx, (%rax)
incl %edx
addq $0x4, %rax
cmpq %rcx, %rax
jne 0x553f5
incl %ebp
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x57e6a
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x55378
movq 0x8(%rbx), %rax
leaq -0x18(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x18(%rax), %rdi
testq %rdi, %rdi
je 0x55445
movq -0x8(%rax), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x58a30
testb %al, %al
jne 0x55409
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5546f
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x55496
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5577f
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x5574f
addl %eax, %ebp
movq 0x8(%r14), %r14
jmp 0x55767
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x57e96
movl %ebp, (%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3bae8
testl %r14d, %r14d
je 0x55b41
xorl %r12d, %r12d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57e96
movl %r12d, (%rax)
movq 0x18(%rsp), %r13
decq 0x28(%rsp)
movq %r13, %rdi
callq 0x95a0
movl $0x18, %esi
movq %r13, %rdi
callq 0x9340
movq 0x10(%rsp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x55b32
movq 0x18(%rsp), %r13
movl $0x18, %edi
callq 0x9330
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 0x55b08
decl %r14d
incl %r12d
testl %r14d, %r14d
jne 0x55ab7
testl %ebp, %ebp
je 0x55baa
leaq 0x18(%rsp), %r14
movq 0x20(%rsp), %r15
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
decq 0x28(%rsp)
movq %r15, %rdi
callq 0x95a0
movl $0x18, %esi
movq %r15, %rdi
callq 0x9340
movq 0x10(%rsp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x55ba6
movl $0x18, %edi
callq 0x9330
movq (%r15), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x9080
incq 0x28(%rsp)
movq 0x8(%r15), %r15
jmp 0x55b7a
decl %ebp
jne 0x55b4a
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x55bce
movq (%rdi), %r15
movl $0x18, %esi
callq 0x9340
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x55bb9
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x55be4
jmp 0x55be4
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbx, %rdi
je 0x55c06
movq (%rdi), %r15
movl $0x18, %esi
callq 0x9340
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x55bf1
movq %r14, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/EditDist.cpp
// Function: GenTables(newick_node*, int, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
void GenTables(newick_node* root, int n, vvi& L, vvi& T, vvi& D)
{
    map<newick_node*, int> S, R;
    CalcSubtreeSizes(root, S);
    for (int i = n; i >= 0; --i)
        for (int j = 0; j <= n; ++j)
            if (newick_node* node = (i + j && i + j <= n ? GetLastRemoved(root, R, i, j) : nullptr))
                L[i][j] = stoi(node->taxon), T[i][j] = S[node], D[i][j] = R[node];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
leaq 0x80(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x50(%rsp), %rax
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x78(%rsp), %rsi
movq %rdi, 0x8(%rsp)
callq 0x5574f
testl %ebp, %ebp
js 0x55d99
leal 0x1(%rbp), %eax
movq %rax, 0x30(%rsp)
movl %ebp, %r15d
leaq 0x38(%rsp), %r13
leaq (%r15,%r15,2), %r12
xorl %r14d, %r14d
movq %r15, 0x28(%rsp)
movq %r15, %rax
addq %r14, %rax
sete %cl
cmpl %ebp, %eax
setg %al
orb %cl, %al
je 0x55cac
xorl %eax, %eax
jmp 0x55cc1
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x55a74
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x55d7b
movq 0x8(%rax), %rbx
callq 0x9060
movq %rax, %r15
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, (%r15)
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
movl $0xa, %edx
callq 0x9490
cmpq %rbx, 0x40(%rsp)
je 0x55dcb
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x55dbf
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0x55dbf
testl %ecx, %ecx
jne 0x55d28
movl 0x4(%rsp), %ecx
movl %ecx, (%r15)
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, (%rcx,%r14,4)
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
callq 0x57e96
movq 0x28(%rsp), %r15
movl (%rax), %eax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, (%rcx,%r14,4)
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x57e96
movl (%rax), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, (%rcx,%r14,4)
incq %r14
cmpq %r14, 0x30(%rsp)
jne 0x55c96
leaq -0x1(%r15), %rax
testq %r15, %r15
movq %rax, %r15
jg 0x55c8a
leaq 0x48(%rsp), %rdi
callq 0x581c4
leaq 0x78(%rsp), %rdi
callq 0x581c4
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64cc(%rip), %rdi      # 0x5c292
callq 0x94c0
leaq 0x64c0(%rip), %rdi      # 0x5c292
callq 0x91d0
jmp 0x55deb
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x55dee
movl 0x4(%rsp), %eax
movl %eax, (%r15)
jmp 0x55dee
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x581c4
leaq 0x78(%rsp), %rdi
callq 0x581c4
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a9c
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movl $0x10, %edi
callq 0x2100
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x49dc
leaq 0x9600(%rip), %rsi      # 0xc0c0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x496c
leaq 0x95f9(%rip), %rsi      # 0xc0cf
leaq 0x68(%rsp), %rdi
callq 0x23c0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2b01
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2b0e
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 0x28(%rsp), %rdi
movabsq $0x7fffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFF
callq 0x4a6c
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x48c4
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x2140
xorl %ebp, %ebp
movq 0xf443(%rip), %rsi      # 0x11fb0
movq 0xf434(%rip), %rdx      # 0x11fa8
movq %rbx, %rdi
callq 0x2340
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b9d
callq 0x21e0
jmp 0x2b9d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bb8
callq 0x21e0
jmp 0x2bb8
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bcf
callq 0x21e0
jmp 0x2bcf
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bea
callq 0x21e0
jmp 0x2bea
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c05
callq 0x21e0
jmp 0x2c05
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2c12
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c34
cmpw $0x2, %di
sete %al
retq
cmpw $0x9, %di
setb %al
jb 0x2c6f
movl %edi, %ecx
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
shrq $0x20, %rcx
leal (%rcx,%rcx,2), %ecx
movl %edi, %edx
subl %ecx, %edx
je 0x2c6f
movl $0x3, %ecx
addl $0x2, %ecx
movzwl %cx, %ecx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
cmpl %eax, %ecx
seta %al
ja 0x2c6f
testl %edx, %edx
jne 0x2c58
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %esi
leaq 0x7(%rsp), %rdx
callq 0x4b20
movq (%rbx), %rsi
movw $0x1, 0x2(%rsi)
cmpw $0x3, %bp
jb 0x2cbc
movzwl %bp, %ecx
movl $0x2, %edi
movl %ecx, %eax
xorl %edx, %edx
divl %edi
movzwl (%rsi,%rdx,2), %edx
imull %edx, %eax
xorl %edx, %edx
divl %ecx
movl %ebp, %eax
subl %edx, %eax
movw %ax, (%rsi,%rdi,2)
incq %rdi
cmpq %rdi, %rcx
jne 0x2c9b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq