LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/range.h
// Function: Beacon<float, 2>::RangeSolver::setCoefficients()
void Beacon<F, D>::RangeSolver::setCoefficients() {
    int n = B.A.rows();
    G.resize(n, D+1);
    h.resize(n, 1);
    G << B.A, Matrix<F, Dynamic, 1>::Constant(n, 1, -0.5);
    h << (1.0 / 2.0) * (
        B.A.array().pow(2.0).matrix().rowwise().sum() -
        B.R.array().pow(2.0).matrix()
    );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq 0x8(%rax), %r15
leaq 0x10(%rdi), %r13
movl $0x3, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0xdc20
leaq 0x20(%rbx), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xdbd0
movq 0x8(%rbx), %rax
leaq 0x68(%rsp), %r12
movq %r13, (%r12)
movq $0x0, 0x8(%r12)
movl $0x2, %ecx
movq %rcx, 0x10(%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdi
leaq 0x30(%rsp), %rbp
movq %rsi, (%rbp)
movq %rdx, 0x8(%rbp)
movq %rcx, 0x10(%rbp)
movq %r13, 0x18(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbp)
movq %rdi, 0x30(%rbp)
movq (%rax), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movq %rdi, 0x10(%rax)
leaq 0x88(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
leaq 0x7(%rsp), %rax
movq %rax, 0x10(%rdi)
movq %rbp, 0x18(%rdi)
callq 0xd090
movq %r15, (%rbp)
movl $0xbf000000, 0xc(%rbp)  # imm = 0xBF000000
leaq 0x30(%rsp), %rsi
movq %r12, %rdi
callq 0xd210
movq 0x8(%rbx), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
jle 0xe36d
movq 0x10(%rdi), %rcx
movq (%r14), %rdx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
leaq (%rsi,%rdi,4), %rdi
xorl %r8d, %r8d
movss 0x16ccb(%rip), %xmm0    # 0x25000
movss (%rsi,%r8,4), %xmm1
mulss %xmm1, %xmm1
movss (%rdi,%r8,4), %xmm2
mulss %xmm2, %xmm2
addss %xmm1, %xmm2
movss (%rcx,%r8,4), %xmm1
mulss %xmm1, %xmm1
subss %xmm1, %xmm2
mulss %xmm0, %xmm2
movss %xmm2, (%rdx,%r8,4)
incq %r8
cmpq %r8, %rax
jne 0xe335
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/beacon.h
// Function: Beacon<float, 2>::checkSize(int)
void Beacon<F, D>::checkSize(int i) {
    if (i >= A.rows()) {
        A.conservativeResize(i + 1, Eigen::NoChange);
        R.conservativeResize(i + 1);
        R(i) = 0.0;
    } 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq %esi, %r15
cmpq %r15, 0x8(%rdi)
jg 0xf0f3
movq %rdi, %rbx
leal 0x1(%r15), %eax
movslq %eax, %r14
movl $0x2, %edx
movq %r14, %rsi
callq 0xdba0
leaq 0x10(%rbx), %rdi
movl $0x1, %ecx
movq %r14, %rsi
movq %r14, %rdx
callq 0xda80
movq 0x10(%rbx), %rax
movl $0x0, (%rax,%r15,4)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/beacon.h
// Function: Beacon<float, 2>::findRow(Eigen::Array<float, 1, 2, 1, 1, 2> const&) const
int Beacon<F, D>::findRow(const Point &a) const {
    int i;
    for (i = 0; i < A.rows(); i++) {
        if (A.row(i).array().isApprox(a)) {
            break;
        }
    }
    return i;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jle 0xf16f
movq (%rdi), %rdx
movsd (%rsi), %xmm0
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
movaps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm1     # xmm1 = xmm1[1,1],xmm2[1,1]
addss %xmm2, %xmm1
leaq (%rdx,%rcx,4), %rsi
xorl %eax, %eax
movss 0x15edf(%rip), %xmm2    # 0x25008
movss (%rdx,%rax,4), %xmm3
movss (%rsi,%rax,4), %xmm4
movaps %xmm3, %xmm5
unpcklps %xmm4, %xmm5            # xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1]
subps %xmm0, %xmm5
mulps %xmm5, %xmm5
movaps %xmm5, %xmm6
shufps $0x55, %xmm5, %xmm6     # xmm6 = xmm6[1,1],xmm5[1,1]
addss %xmm5, %xmm6
mulss %xmm3, %xmm3
mulss %xmm4, %xmm4
addss %xmm3, %xmm4
minss %xmm1, %xmm4
mulss %xmm2, %xmm4
ucomiss %xmm4, %xmm6
jbe 0xf16e
incq %rax
cmpq %rax, %rcx
jne 0xf129
movq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/fix.h
// Function: Beacon<float, 2>::estimateError()
void Beacon<F, D>::estimateError() {
    Ranges R_hat;
    int i, j;

    // FIXME FIXME: this no longer works for RangeSolver
    //
    //std::cout << "\n\nR: " << R << "\n";
    R_hat = calculateRanges(A, X);
    //std::cout << "R_hat pre: " << R_hat << "\n";
    R.minCoeff(&i, &j);
    R_hat = (R_hat.array() - R_hat[i]).matrix(); 
    //std::cout << "R_hat post: " << R_hat << "\n";
    Err = meanSquaredError(R_hat);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x20(%rdi), %rdx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xd6f0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0xf236
cmpq $0x2, %rdx
jl 0xf23f
movq 0x10(%rbx), %rsi
movss (%rsi), %xmm0
movl $0x1, %r8d
xorl %edi, %edi
movss (%rsi,%r8,4), %xmm1
ucomiss %xmm1, %xmm0
cmovaq %r8, %rdi
minss %xmm1, %xmm0
incq %r8
cmpq %r8, %rdx
jne 0xf218
movslq %edi, %rdx
jmp 0xf241
movq $-0x1, %rdx
jmp 0xf241
xorl %edx, %edx
movss (%rax,%rdx,4), %xmm0
leaq 0x3(%rcx), %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
andq $-0x4, %rdx
cmpq $0x4, %rcx
jl 0xf278
movaps %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm1      # xmm1 = xmm1[0,0],xmm0[0,0]
xorl %esi, %esi
movaps (%rax,%rsi,4), %xmm2
subps %xmm1, %xmm2
movaps %xmm2, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq %rdx, %rsi
jl 0xf264
cmpq %rcx, %rdx
jge 0xf293
movss (%rax,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xf27d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd970
movss %xmm0, 0x40(%rbx)
movq (%rsp), %rdi
callq 0xd740
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xf2c0
movq %rax, %rbx
xorl %edi, %edi
callq 0xd740
movq %rbx, %rdi
callq 0xdb20
nop
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/fix.h
// Function: bool Beacon<float, 2>::Update<Beacon<float, 2>::DifferenceSolver>(float, float, int)
bool Beacon<F, D>::Update(F time, F rmsThreshold, int maxTries) {
    if (A.rows() <= D + 1) {
        qfdebug("Not enough readings for a fix");
        return false;
    }
    Beacon b = Fix<Solver>(time, rmsThreshold, maxTries);
    rmsThreshold *= rmsThreshold;
    b.estimateError();
    if (b.Err < rmsThreshold) {
        if (Filter != NULL) {
            Filter->Update(time-Time, b.X);
            X = Filter->Position();
        } else {
            X = b.X;
        }
        qfdebug("Δt=" << (time-Time) << ": " << X << " (" << Err << ") filtered vs " << b.X << " (" << b.Err << ") estimate on " << b.A.rows());
        clipToBound();
        Time = time;
        Err = b.Err;
        Clear();
        return true;
    } else {
        qfdebug("MSE " << b.Err << " exceeded threshold " << rmsThreshold);
        Err = b.Err;
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpq $0x4, 0x8(%rdi)
jge 0xfbd4
xorl %ebp, %ebp
jmp 0xfcbd
movl %esi, %edx
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movss %xmm0, 0x8(%rsp)
movss %xmm1, 0xc(%rsp)
callq 0xdb30
movq %r14, %rdi
callq 0xd500
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm1
movss 0x50(%rsp), %xmm0
ucomiss %xmm0, %xmm1
seta %bpl
jbe 0xfc5a
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xfc61
movss 0x8(%rsp), %xmm0
subss 0x44(%rbx), %xmm0
leaq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movss (%rax), %xmm1
movss %xmm1, 0x20(%rbx)
movss 0x4(%rax), %xmm2
movss %xmm2, 0x24(%rbx)
movss 0x50(%rsp), %xmm0
jmp 0xfc73
movss %xmm0, 0x40(%rbx)
jmp 0xfca9
movsd 0x30(%rsp), %xmm1
movsd %xmm1, 0x20(%rbx)
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
maxss 0x30(%rbx), %xmm1
minss 0x34(%rbx), %xmm1
movss %xmm1, 0x20(%rbx)
maxss 0x38(%rbx), %xmm2
minss 0x3c(%rbx), %xmm2
movss %xmm2, 0x24(%rbx)
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x44(%rbx)
movss %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0xd5b0
movq 0x20(%rsp), %rdi
callq 0xd740
movq 0x10(%rsp), %rdi
callq 0xd740
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0xd740
movq 0x10(%rsp), %rdi
callq 0xd740
movq %rbx, %rdi
callq 0xdb20
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/particle_filter.h
// Function: ParticleFilter<float, 2>::Update(float, Eigen::Array<float, 1, 2, 1, 1, 2> const&)
bool ParticleFilter<F,D>::Update(F dT, const Point &p) {
    weigh(dT, p);
    shuffle();
    X = P.colwise().mean();
    perturb(dT);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movss %xmm0, 0x10(%rsp)
callq 0xd430
movq %rbx, %rdi
callq 0xd050
xorps %xmm0, %xmm0
cvtsi2ssq 0x10(%rbx), %xmm0
leaq 0x8(%rbx), %r13
movss 0xb75f(%rip), %xmm1     # 0x2500c
divss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movb $0x1, %bpl
xorl %r14d, %r14d
leaq 0xf(%rsp), %r15
leaq 0x18(%rsp), %r12
movq 0x10(%rbx), %rax
movq %rax, %rcx
imulq %r14, %rcx
shlq $0x2, %rcx
addq 0x8(%rbx), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %r13, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %r14, 0x40(%rsp)
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x1991d
movq %rcx, 0x50(%rsp)
movq %rax, 0x60(%rsp)
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd560
jmp 0x19920
xorps %xmm0, %xmm0
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0x28(%rbx,%r14,4)
movl $0x1, %r14d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x198c7
movq %rbx, %rdi
movss 0x10(%rsp), %xmm0
callq 0xd350
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/particle_filter.h
// Function: ParticleFilter<float, 2>::shuffle()
void ParticleFilter<F,D>::shuffle() {
    int i = 0, total = 0;
    Particles p_ = P;
    while (i < N) {
        // FIXME: this seems heavy handed
        Weights select(N, 1);
        select << Weights::Random(N, 1).array() * 0.5 + 0.5;
        select -= W;
        for (int j = 0; i < N && j < N; j++) {
            //std::cout << i << ": " << j << " " << W[j] << " > " << select[j] << "\n";
            if (select[j] < 0.) {
                P.row(i)= p_.row(j);
                i++;
            }
            total++;
        }
        //j = (j + 1) % N;
    }
    qfdebug("Particle shuffle took " << total << " iterations");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd770
movl 0x30(%rbx), %eax
testl %eax, %eax
jle 0x1a5d1
xorl %r15d, %r15d
movq %rsp, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movslq %eax, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xdbd0
movslq 0x30(%rbx), %r13
movq (%rsp), %r12
testq %r13, %r13
jle 0x1a4fa
xorl %ebp, %ebp
callq 0xd110
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0xab30(%rip), %xmm0     # 0x25018
movss %xmm0, (%r12,%rbp,4)
incq %rbp
cmpq %rbp, %r13
jne 0x1a4d4
movq (%rsp), %r12
movq 0x18(%rbx), %rax
movq 0x8(%rsp), %rcx
leaq 0x3(%rcx), %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
andq $-0x4, %rdx
cmpq $0x4, %rcx
xorps %xmm1, %xmm1
jl 0x1a534
xorl %esi, %esi
movaps (%r12,%rsi,4), %xmm0
subps (%rax,%rsi,4), %xmm0
movaps %xmm0, (%r12,%rsi,4)
addq $0x4, %rsi
cmpq %rdx, %rsi
jl 0x1a51d
cmpq %rcx, %rdx
jge 0x1a552
movss (%r12,%rdx,4), %xmm0
subss (%rax,%rdx,4), %xmm0
movss %xmm0, (%r12,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x1a539
movl 0x30(%rbx), %eax
cmpl %eax, %r15d
setge %cl
testl %eax, %eax
setle %dl
movq (%rsp), %rdi
orb %cl, %dl
jne 0x1a5c0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
leaq (%rcx,%r8,4), %r8
movl $0x1, %r9d
ucomiss -0x4(%rdi,%r9,4), %xmm1
jbe 0x1a5af
movslq %r15d, %r15
leaq (%rdx,%r15,4), %r10
movss -0x4(%rcx,%r9,4), %xmm0
movss %xmm0, (%r10)
movss -0x4(%r8,%r9,4), %xmm0
movss %xmm0, (%r10,%rsi,4)
incl %r15d
cmpl %eax, %r15d
jge 0x1a5c0
leaq 0x1(%r9), %r10
cmpq %rax, %r9
movq %r10, %r9
jb 0x1a584
callq 0xd740
movl 0x30(%rbx), %eax
cmpl %eax, %r15d
jl 0x1a4ae
movq 0x18(%rsp), %rdi
callq 0xd740
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xd740
movq 0x18(%rsp), %rdi
callq 0xd740
movq %rbx, %rdi
callq 0xdb20
// File: /workspace/github_cpp_makefile_star2_O3/schuyler[P]quickfix/include/quickfix/fix.h
// Function: Eigen::Array<float, 1, 2, 1, 1, 2> Beacon<float, 2>::solveNonLinear<Beacon<float, 2>::DifferenceSolver>(Beacon<float, 2> const&, float)
typename Beacon<F, D>::Point Beacon<F, D>::solveNonLinear(const Beacon &B, F time) {
    Functor functor(B, time);
    functor.setCoefficients();

    NumericalDiff<Functor> numDiff(functor);
    LevenbergMarquardt<NumericalDiff<Functor>, F> lm(numDiff);

    typename Functor::InputType x = functor.solveLinear();
    lm.minimize(x);
    // Turn the [D+1, 1] solution matrix into a [1, D] vector
    Map<Point> y(x.data(), x.size() - 1);
    return y;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xd030
movq %r14, %rdi
callq 0xd300
leaq 0x50(%rsp), %r14
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0xd490
movl $0x42c80000, 0x88(%rsp) # imm = 0x42C80000
movq $0x190, 0x90(%rsp) # imm = 0x190
movsd 0x971e(%rip), %xmm0     # 0x25470
movsd %xmm0, 0x98(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rsp)
movups %xmm0, 0xb0(%rsp)
movups %xmm0, 0xc0(%rsp)
movups %xmm0, 0xd0(%rsp)
movups %xmm0, 0xe0(%rsp)
movups %xmm0, 0xf0(%rsp)
movq %r14, 0x128(%rsp)
movups %xmm0, 0x100(%rsp)
movups %xmm0, 0x110(%rsp)
movb $0x0, 0x120(%rsp)
movups %xmm0, 0x140(%rsp)
movups %xmm0, 0x150(%rsp)
movups %xmm0, 0x160(%rsp)
movups %xmm0, 0x170(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd240
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd3f0
movq 0x8(%rsp), %rdi
movsd (%rdi), %xmm0
movsd %xmm0, (%rbx)
callq 0xd740
movq 0x170(%rsp), %rdi
callq 0xd740
movq 0x160(%rsp), %rdi
callq 0xd740
movq 0x150(%rsp), %rdi
callq 0xd740
movq 0x140(%rsp), %rdi
callq 0xd740
movq 0xf0(%rsp), %rdi
callq 0xd740
movq 0xd8(%rsp), %rdi
callq 0xd740
movq 0xc8(%rsp), %rdi
callq 0xd740
movq 0xb8(%rsp), %rdi
callq 0xd740
movq 0xa8(%rsp), %rdi
callq 0xd740
movq 0xf0db(%rip), %r14      # 0x2af58
addq $0x10, %r14
movq %r14, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0xd740
movq 0x60(%rsp), %rdi
callq 0xd740
movq %r14, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd740
movq 0x28(%rsp), %rdi
callq 0xd740
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xd740
jmp 0x1bed3
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xdb80
movq 0xf071(%rip), %rax      # 0x2af58
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0xd740
movq 0x60(%rsp), %rdi
callq 0xd740
jmp 0x1bf0b
jmp 0x1bf08
movq %rax, %rbx
movq 0xf046(%rip), %rax      # 0x2af58
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd740
movq 0x28(%rsp), %rdi
callq 0xd740
movq %rbx, %rdi
callq 0xdb20
nop
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picogcnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  printf ("c [picogcnf] %.2f seconds: ", picosat_time_stamp ());
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1cfb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x9079
leaq 0xe4e6(%rip), %rdi      # 0x101ed
movb $0x1, %al
callq 0x10c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1140
movq 0x1529b(%rip), %rbx     # 0x16fd8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1100
movq (%rbx), %rdi
callq 0x1130
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/biotomas[P]ipasir/sat/picosat961/picosat-961/picogcnf.c
// Function: callback
static void callback (void * dummy, const int * mus) {
  int remaining;
  const int * p;
  (void) dummy;
  remaining = 0;
  for (p = mus; *p; p++) remaining++;
  assert (remaining <= ngroups);
  msg ("<%d> reduction to %d out of %d (%.0f%%)",
       ++reductions, remaining, ngroups, percent (remaining, ngroups));
}

// Assembly:
pushq %rax
cmpl $0x0, (%rsi)
je 0x1d72
xorl %edx, %edx
cmpl $0x0, 0x4(%rsi,%rdx,4)
leaq 0x1(%rdx), %rdx
jne 0x1d65
jmp 0x1d74
xorl %edx, %edx
movl 0x15396(%rip), %ecx     # 0x17110
cmpl %ecx, %edx
jg 0x1dbb
movl 0x15390(%rip), %esi     # 0x17114
incl %esi
movl %esi, 0x15388(%rip)     # 0x17114
xorpd %xmm0, %xmm0
testl %ecx, %ecx
je 0x1dab
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
cvtsi2sd %ecx, %xmm1
mulsd 0xe291(%rip), %xmm0     # 0x10038
divsd %xmm1, %xmm0
leaq 0xe48f(%rip), %rdi      # 0x10241
movb $0x1, %al
popq %r8
jmp 0x1c9a
leaq 0xe447(%rip), %rdi      # 0x10209
leaq 0xe3a7(%rip), %rsi      # 0x10170
leaq 0xe44e(%rip), %rcx      # 0x1021e
movl $0x45, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: XmlTest(char const*, char const*, char const*, bool)
bool XmlTest (const char* testString, const char* expected, const char* found, bool noEcho )
{
	bool pass = !strcmp( expected, found );
	if ( pass )
		printf ("[pass]");
	else
		printf ("[fail]");

	if ( noEcho )
		printf (" %s\n", testString);
	else
		printf (" %s [%s][%s]\n", testString, expected, found);

	if ( pass )
		++gPass;
	else
		++gFail;
	return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x31a0
movl %eax, %ebx
testl %eax, %eax
leaq 0x6623(%rip), %rax      # 0xedc0
leaq 0x6623(%rip), %rdi      # 0xedc7
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %ebp, %ebp
je 0x87c6
leaq 0x678d(%rip), %rdi      # 0xef47
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x87dd
leaq 0x6601(%rip), %rdi      # 0xedce
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3050
testl %ebx, %ebx
sete %al
leaq 0xda4b(%rip), %rcx      # 0x16234
leaq 0xda48(%rip), %rdx      # 0x16238
cmoveq %rcx, %rdx
incl (%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: XmlTest(char const*, int, int, bool)
bool XmlTest( const char* testString, int expected, int found, bool noEcho )
{
	bool pass = ( expected == found );
	if ( pass )
		printf ("[pass]");
	else
		printf ("[fail]");

	if ( noEcho )
		printf (" %s\n", testString);
	else
		printf (" %s [%d][%d]\n", testString, expected, found);

	if ( pass )
		++gPass;
	else
		++gFail;
	return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl %edx, %esi
leaq 0x65a7(%rip), %rax      # 0xedc0
leaq 0x65a7(%rip), %rdi      # 0xedc7
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %r15d, %r15d
je 0x8843
leaq 0x6710(%rip), %rdi      # 0xef47
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x8858
leaq 0x6592(%rip), %rdi      # 0xeddc
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3050
cmpl %ebx, %ebp
sete %al
leaq 0xd9d0(%rip), %rcx      # 0x16234
leaq 0xd9cd(%rip), %rdx      # 0x16238
cmoveq %rcx, %rdx
incl (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: NullLineEndings(char*)
void NullLineEndings( char* p )
{
	while( p && *p ) {
		if ( *p == '\n' || *p == '\r' ) {
			*p = 0;
			return;
		}
		++p;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x889a
movzbl (%rdi), %eax
testl %eax, %eax
je 0x889a
cmpl $0xd, %eax
je 0x8897
cmpl $0xa, %eax
je 0x8897
incq %rdi
jmp 0x8881
movb $0x0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/main.cpp
// Function: MakeGraphs(int, char**)
pair<Graph*, Graph*> MakeGraphs(int argc, char** argv)
{
    if (argc == 10)
        return {new Tree(argv[1]), new Tree(argv[2])};
    else if (argc == 12)
        return {new Tree(argv[1], argv[2]), new Tree(argv[3], argv[4])};

    int s = stoi(argv[argc - 1]);
    return {MakeDAG(argv[1], argv[2], s), MakeDAG(argv[3], nullptr, s)};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
cmpl $0xc, %edi
je 0xad1e
cmpl $0xa, %edi
jne 0xad5d
movl $0x80, %edi
callq 0x9340
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2ecec
movl $0x80, %edi
callq 0x9340
movq %rax, %r15
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2ecec
jmp 0xadfd
movl $0x80, %edi
callq 0x9340
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x2ec34
movl $0x80, %edi
callq 0x9340
movq %rax, %r15
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %rax, %rdi
callq 0x2ec34
jmp 0xadfd
movslq %edi, %rax
movq -0x8(%rbx,%rax,8), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd5dc
movq 0x10(%rsp), %r12
callq 0x9060
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x94a0
cmpq %r12, (%r13)
je 0xae12
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0xae1e
movl (%r14), %eax
cmpl $0x22, %eax
je 0xae1e
testl %eax, %eax
jne 0xadbe
movl %ebp, (%r14)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xadd9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9350
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl %r15d, %edx
callq 0xac55
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xac55
movq %rax, %r15
movq %r14, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51479(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x5146d(%rip), %rdi     # 0x5c292
callq 0x94d0
jmp 0xae2c
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
jmp 0xae6f
movq %rax, %rbx
jmp 0xae74
jmp 0xae40
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
jmp 0xae6f
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xae59
movl %ebp, (%r14)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xae74
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9350
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/geno/augmentedLagrangian.cpp
// Function: AugmentedLagrangian::setParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool AugmentedLagrangian::setParameter(std::string parameter, Scalar value)
{
	// TODO
	// lower case parameter

	if (parameter == "pgtol")
	{
		_tol = value;
		return true;
	}

	if (parameter == "factr")
	{
		_tolFun = value;
		return true;
	}

	if (parameter == "constraintsTol")
	{
		_constraintsTol = value;
		return true;
	}
	if (parameter == "verbose")
	{
	        _verbose = value;
	        return true;
        }
	        

	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4d686(%rip), %rsi     # 0x5c430
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xedf3
leaq 0x4d679(%rip), %rsi     # 0x5c436
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xedff
leaq 0x4d673(%rip), %rsi     # 0x5c443
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xee0b
leaq 0x4d66f(%rip), %rsi     # 0x5c452
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xee17
xorl %eax, %eax
jmp 0xee31
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
jmp 0xee2f
movsd (%rsp), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0xee2f
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xee2f
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
setp %al
setne %cl
orb %al, %cl
movb %cl, 0x60(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::boundInit()
void LBFGSB::boundInit() {
  _genoNLP.getBounds(_lb.data(), _ub.data());
  Scalar const INF = std::numeric_limits<Scalar>::infinity();
  for (int i = 0; !_constrained && i < _lb.size(); ++i)
    _constrained = (_lb[i] != -INF || _ub[i] != INF);
  for (int i = 0; _boxed && i < _x.size(); ++i)
    _boxed = (_lb[i] != -INF && _ub[i] != INF);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x20(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, 0x258(%rbx)
jne 0x10426
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq 0x30(%rbx), %rsi
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
movsd 0x4c03d(%rip), %xmm0    # 0x5c428
movsd 0x4c00d(%rip), %xmm1    # 0x5c400
cmpq %rdi, %rcx
je 0x10426
ucomisd (%rax,%rdi,8), %xmm0
jb 0x1041f
cmpq %rdi, %rdx
jle 0x1049c
movsd (%rsi,%rdi,8), %xmm2
incq %rdi
ucomisd %xmm1, %xmm2
setb 0x258(%rbx)
jae 0x103f3
jmp 0x10426
movb $0x1, 0x258(%rbx)
testb $0x1, 0x259(%rbx)
je 0x1049a
movq 0x28(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq 0x30(%rbx), %rdi
xorl %r8d, %r8d
testq %rcx, %rcx
cmovleq %r8, %rcx
testq %rax, %rax
cmovleq %r8, %rax
movsd 0x4bfcc(%rip), %xmm0    # 0x5c428
movsd 0x4bf9c(%rip), %xmm1    # 0x5c400
cmpq %r8, %rcx
je 0x1049a
cmpq %r8, %rax
je 0x1049c
ucomisd (%rdx,%r8,8), %xmm0
jae 0x10493
cmpq %r8, %rsi
jle 0x1049c
movsd (%rdi,%r8,8), %xmm2
incq %r8
ucomisd %xmm1, %xmm2
setb 0x259(%rbx)
jb 0x10464
jmp 0x1049a
movb $0x0, 0x259(%rbx)
popq %rbx
retq
leaq 0x4cda2(%rip), %rdi     # 0x5d245
leaq 0x4cdb8(%rip), %rsi     # 0x5d262
leaq 0x4d78e(%rip), %rcx     # 0x5dc3f
movl $0x198, %edx            # imm = 0x198
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::initFeasible()
bool LBFGSB::initFeasible() {
  for (Index i = 0; i < _x.size(); ++i) {
    if (_lb[i] > _ub[i])
      return false;    // infeasible
    if (_lb[i] > _x[i])
      _x[i] = _lb[i];
    if (_ub[i] < _x[i])
      _x[i] = _ub[i];
  }
  return true;
}

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
jle 0x17eca
movq 0x28(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq 0x20(%rdi), %r8
movq 0x38(%rdi), %r9
movq 0x30(%rdi), %rdi
xorl %eax, %eax
testq %rdx, %rdx
cmovleq %rax, %rdx
testq %r9, %r9
cmovleq %rax, %r9
negq %r9
negq %rdx
movq %rcx, %r10
negq %r10
movl $0x1, %r11d
leaq (%rdx,%r11), %rbx
cmpq $0x1, %rbx
je 0x17ed0
leaq (%r9,%r11), %rbx
cmpq $0x1, %rbx
je 0x17ed0
movsd -0x8(%r8,%r11,8), %xmm1
movsd -0x8(%rdi,%r11,8), %xmm0
ucomisd %xmm0, %xmm1
ja 0x17ecc
movsd -0x8(%rsi,%r11,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x17ea5
movsd %xmm1, -0x8(%rsi,%r11,8)
movsd -0x8(%rdi,%r11,8), %xmm0
movapd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x17eb2
movsd %xmm0, -0x8(%rsi,%r11,8)
cmpq %rcx, %r11
setge %al
leaq (%r10,%r11), %rbx
incq %rbx
incq %r11
cmpq $0x1, %rbx
jne 0x17e5e
jmp 0x17ecc
movb $0x1, %al
andb $0x1, %al
popq %rbx
retq
leaq 0x4536e(%rip), %rdi     # 0x5d245
leaq 0x45384(%rip), %rsi     # 0x5d262
leaq 0x45d5a(%rip), %rcx     # 0x5dc3f
movl $0x198, %edx            # imm = 0x198
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::setParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool LBFGSB::setParameter(std::string parameter, Scalar value)
{
  // TODO
  // lower case parameter

  if (parameter == "pgtol")
  {
    _tol = value;
    return true;
  }

  if (parameter == "factr")
  {
    _tolFun = value * std::numeric_limits<Scalar>::epsilon();
    return true;
  }

  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x43448(%rip), %rsi     # 0x5c430
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x1900b
leaq 0x4343b(%rip), %rsi     # 0x5c436
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x19017
xorl %eax, %eax
jmp 0x19030
movl $0x68, %eax
movsd (%rsp), %xmm0
jmp 0x19029
movsd (%rsp), %xmm0
mulsd 0x447f4(%rip), %xmm0    # 0x5d818
movl $0x70, %eax
movsd %xmm0, (%rbx,%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<long, -1, 1, -1, 1>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
    {
      if(size != _Rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_cols = cols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x1f709
movq %rsi, %r15
movq (%r14), %rdi
callq 0x93d0
testq %r15, %r15
je 0x1f704
movq %r15, %rax
shrq $0x3d, %rax
jne 0x1f6d6
leaq (,%r15,8), %rdi
callq 0x9450
cmpq $0x1, %r15
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x1f713
testq %rax, %rax
jne 0x1f706
movl $0x8, %edi
callq 0x9180
movq 0x668c9(%rip), %rcx     # 0x85fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x668d3(%rip), %rsi     # 0x85fc8
movq 0x66894(%rip), %rdx     # 0x85f90
movq %rax, %rdi
callq 0x9640
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3d652(%rip), %rdi     # 0x5cd6c
leaq 0x3d705(%rip), %rsi     # 0x5ce26
leaq 0x3d71d(%rip), %rcx     # 0x5ce45
movl $0xa1, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/LU/FullPivLU.h
// Function: Eigen::FullPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::threshold() const
RealScalar threshold() const
    {
      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
      return m_usePrescribedThreshold ? m_prescribedThreshold
      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
      // and turns out to be identical to Higham's formula used already in LDLt.
                                      : NumTraits<Scalar>::epsilon() * m_lu.diagonalSize();
    }

// Assembly:
movb 0x7a(%rdi), %al
cmpb $0x0, 0x79(%rdi)
jne 0x20cd7
testb $0x1, %al
je 0x20cfe
testb $0x1, %al
je 0x20ce1
movsd 0x70(%rdi), %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
cvtsi2sd %rax, %xmm0
mulsd 0x3cb1b(%rip), %xmm0    # 0x5d818
retq
pushq %rax
leaq 0x41a79(%rip), %rdi     # 0x6277f
leaq 0x40608(%rip), %rsi     # 0x61315
leaq 0x41a97(%rip), %rcx     # 0x627ab
movl $0x13f, %edx            # imm = 0x13F
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: void Eigen::internal::generic_product_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::addTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&)
static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    if((rhs.rows()+dst.rows()+dst.cols())<20 && rhs.rows()>0)
      lazyproduct::addTo(dst, lhs, rhs);
    else
      scaleAndAddTo(dst,lhs, rhs, Scalar(1));
  }

// Assembly:
subq $0x78, %rsp
movq (%rdx), %r8
movq 0x10(%r8), %rcx
testq %rcx, %rcx
jle 0x2953b
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r9
leaq (%rax,%r9), %r10
addq %rcx, %r10
cmpq $0x13, %r10
jg 0x2953b
cmpq %rcx, 0x10(%rsi)
jne 0x29557
movq %rsi, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq (%rsi), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rsi), %rsi
movq %rsi, 0x20(%rsp)
movq (%r8), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%r8), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
cmpq %rsi, %rax
jne 0x29576
cmpq %rdx, %r9
jne 0x29576
movq (%rdi), %rcx
leaq 0x48(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x58(%rsp), %rax
movq %rdx, (%rax)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x7(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rdi, 0x18(%rax)
movq %rax, %rdi
callq 0x296e8
jmp 0x29552
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
callq 0x29596
addq $0x78, %rsp
retq
leaq 0x351ee(%rip), %rdi     # 0x5e74c
leaq 0x35273(%rip), %rsi     # 0x5e7d8
leaq 0x3d9c8(%rip), %rcx     # 0x66f34
movl $0x61, %edx
callq 0x9200
leaq 0x384c2(%rip), %rdi     # 0x61a3f
leaq 0x32fb5(%rip), %rsi     # 0x5c539
leaq 0x3d877(%rip), %rcx     # 0x66e02
movl $0x2c6, %edx            # imm = 0x2C6
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/./Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>> const>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>> const> const&, Eigen::internal::assign_op<double, double> const&)
void run(Kernel &kernel)
  {
    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
    typedef typename Kernel::PacketType PacketType;

    enum { size = DstXprType::InnerSizeAtCompileTime,
           packetSize =unpacket_traits<PacketType>::size,
           vectorizableSize = (size/packetSize)*packetSize };

    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
    {
      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, size>::run(kernel, outer);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
setne %cl
movq 0x20(%rsi), %r15
cmpq %rax, %r15
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x2a0e0
cmpq $0x1, 0x50(%rsi)
jne 0x2a0ff
movq %rdi, %r14
movsd 0x18(%rsi), %xmm1
movq 0x38(%rsi), %rcx
movq 0x8(%rcx), %r12
movq 0x30(%rsi), %rbx
cmpq %rbx, 0x8(%rdi)
je 0x2a0b0
movsd %xmm1, (%rsp)
testq %rbx, %rbx
js 0x2a11e
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xff4c
cmpq %rbx, 0x8(%r14)
jne 0x2a13d
movq (%r14), %rax
movsd (%rsp), %xmm1
testq %rbx, %rbx
jle 0x2a0d4
shlq $0x3, %r12
xorl %ecx, %ecx
movsd (%r15), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
addq %r12, %r15
cmpq %rcx, %rbx
jne 0x2a0bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34a04(%rip), %rdi     # 0x5eaeb
leaq 0x34b10(%rip), %rsi     # 0x5ebfe
leaq 0x3d48b(%rip), %rcx     # 0x67580
movl $0x17a, %edx            # imm = 0x17A
callq 0x9200
leaq 0x33bc0(%rip), %rdi     # 0x5dcc6
leaq 0x33bc7(%rip), %rsi     # 0x5dcd4
leaq 0x34205(%rip), %rcx     # 0x5e319
movl $0x6e, %edx
callq 0x9200
leaq 0x32d53(%rip), %rdi     # 0x5ce78
leaq 0x32bab(%rip), %rsi     # 0x5ccd7
leaq 0x32ed4(%rip), %rcx     # 0x5d007
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
leaq 0x32f3c(%rip), %rdi     # 0x5d080
leaq 0x323ee(%rip), %rsi     # 0x5c539
leaq 0x3d6fc(%rip), %rcx     # 0x6784e
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::Init(newick_node*)
void Graph::Init(newick_node* node)
{
    if (!node->child)
    {
        L.push_back(node);
        Leaf(node);
    }

    node->taxoni = _n++;
    for (newick_child* child = node->child; child; child = child->next)
    {
        newick_node* cnode = child->node;
        newick_parent** parentptr = &cnode->parent;
        if (!cnode->parent)
            Init(cnode);

        while (*parentptr) parentptr = &(*parentptr)->next;
        *parentptr = new newick_parent(node);
        Child(node, child->node);
    }
    clade[node].sort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movq (%rsi), %r15
testq %r15, %r15
je 0x2de08
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
movl %eax, 0x28(%rsi)
jmp 0x2de53
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x2de1c
movq %rsi, (%rax)
addq $0x8, 0x10(%rbx)
jmp 0x2de2b
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x30c50
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rsp), %rax
movq (%rax), %r15
movq 0x70(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x70(%rbx)
movl %ecx, 0x28(%rax)
testq %r15, %r15
je 0x2deae
movq (%r15), %r14
cmpq $0x0, 0x30(%r14)
jne 0x2de68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dde0
addq $0x30, %r14
movq %r14, %r12
movq (%r14), %rax
leaq 0x8(%rax), %r14
testq %rax, %rax
jne 0x2de6c
movl $0x10, %edi
callq 0x9340
movq %rax, %r14
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x3c868
movq %r14, (%r12)
movq (%rsp), %rsi
movq (%r15), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x8(%r15), %r15
jmp 0x2de4e
addq $0x20, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2f808
movq %rax, %rdi
callq 0x2f86e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x9350
movq %rbx, %rdi
callq 0x9680
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::TransitiveClosure()
void Graph::TransitiveClosure()
{
    D.resize(_n, vb(_n));
    vvb C(_n, vb(_n));
    for (newick_node* leaf : L)
        TransitiveClosure(leaf, leaf, C);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %r14
leaq 0x30(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
callq 0x306d4
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x2f7c6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2e19a
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x70(%rbx), %r14
leaq 0x6(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %r14, %rsi
callq 0x306d4
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
callq 0x2f702
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2e1e6
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
cmpq %r12, %r15
je 0x2e212
leaq 0x30(%rsp), %r14
movq (%r15), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
callq 0x2ea82
addq $0x8, %r15
cmpq %r12, %r15
jne 0x2e1f8
leaq 0x30(%rsp), %rdi
callq 0xd91a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2e26e
leaq 0x8(%rsp), %rdi
callq 0x977a
jmp 0x2e26e
jmp 0x2e25c
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2e26e
leaq 0x8(%rsp), %rdi
callq 0x9762
jmp 0x2e26e
movq %rax, %rbx
jmp 0x2e26e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xd91a
movq %rbx, %rdi
callq 0x9680
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::TransitiveReduction(newick_node*, std::vector<bool, std::allocator<bool>>&)
void LDAG::TransitiveReduction(newick_node* node, vb& C)
{
    if (C[node->taxoni])
        return;

    C[node->taxoni] = true;
    for (newick_child* child = node->child; child; child = child->next)
    {
        TransitiveReduction(child->node, C);
        for (newick_child* cchild = child->node->child; cchild; cchild = cchild->next)
        {
            vb CC(_n);
            TransitiveReduction(node, cchild->node, CC);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movslq 0x28(%rsi), %rcx
leal 0x3f(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
movq %rdx, 0x10(%rsp)
addq (%rdx), %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %r8
andq %rcx, %r8
xorl %edx, %edx
cmpq %rsi, %r8
setbe %dl
movl $0x1, %esi
shlq %cl, %rsi
movq %rdi, %r15
movq -0x8(%rax,%rdx,8), %rdi
btq %rcx, %rdi
jb 0x2e837
leaq -0x8(,%rdx,8), %rcx
orq %rdi, %rsi
movq %rsi, (%rax,%rcx)
movq (%r14), %rbx
testq %rbx, %rbx
je 0x2e837
leaq 0x20(%rsp), %r12
leaq 0xe(%rsp), %r13
leaq 0xf(%rsp), %rbp
movq (%rbx), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x2e738
movq %rbx, 0x18(%rsp)
movq (%rbx), %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x2e829
movq 0x70(%r15), %rsi
movb $0x0, 0xe(%rsp)
movq %r12, %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x306d4
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x2e944
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2e823
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9350
movq 0x8(%rbx), %rbx
jmp 0x2e7df
movq 0x18(%rsp), %rbx
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2e7c4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Wipe(newick_node*)
void LDAG::Wipe(newick_node* node)
{
    node->taxoni = -1;
    for (newick_child* child = node->child; child; child = child->next)
        if (child->node->taxoni != -1)
            Wipe(child->node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, 0x28(%rsi) # imm = 0xFFFFFFFF
movq (%rsi), %r14
testq %r14, %r14
je 0x2e876
movq %rdi, %rbx
movq (%r14), %rsi
cmpl $-0x1, 0x28(%rsi)
je 0x2e86d
movq %rbx, %rdi
callq 0x2e846
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2e85c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Renumerate(newick_node*)
void LDAG::Renumerate(newick_node* node)
{
    node->taxoni = _n++;
    for (newick_child* child = node->child; child; child = child->next)
        if (child->node->taxoni == -1)
            Renumerate(child->node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x70(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rdi)
movl %eax, 0x28(%rsi)
movq (%rsi), %r14
testq %r14, %r14
je 0x2e8b6
movq %rdi, %rbx
movq (%r14), %rsi
cmpl $-0x1, 0x28(%rsi)
jne 0x2e8ad
movq %rbx, %rdi
callq 0x2e87e
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2e89c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::GenPaths(newick_node*, std::vector<newick_node*, std::allocator<newick_node*>>&)
void LDAG::GenPaths(newick_node* node, vn& T)
{
    T.push_back(node);
    if (!node->child)
        P.push_back(T);
    for (newick_child* child = node->child; child; child = child->next)
        GenPaths(child->node, T);
    T.pop_back();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x8(%rdx), %rax
cmpq 0x10(%rdx), %rax
je 0x2e8e6
movq %rsi, (%rax)
addq $0x8, 0x8(%rbx)
jmp 0x2e8fc
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x30c50
movq (%r15), %rsi
movq (%rsi), %r15
testq %r15, %r15
jne 0x2e91d
leaq 0xf0(%r14), %rdi
movq %rbx, %rsi
callq 0x2f79a
movq 0x8(%rsp), %rax
movq (%rax), %r15
jmp 0x2e92f
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2e8be
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x2e91d
addq $-0x8, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::TransitiveReduction(newick_node*, newick_node*, std::vector<bool, std::allocator<bool>>&)
void LDAG::TransitiveReduction(newick_node* parent, newick_node* node, vb& C)
{
    C[node->taxoni] = true;
    Reduce(&parent->child, node);
    Reduce(&node->parent, parent);
    for (newick_child* child = node->child; child; child = child->next)
        if (!C[child->node->taxoni])
            TransitiveReduction(parent, child->node, C);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movslq 0x28(%rdx), %rcx
leal 0x3f(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq (%rbx), %rax
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
leaq 0x3f(%r12), %r8
andq %rcx, %r8
xorl %r9d, %r9d
cmpq %r12, %r8
setbe %r9b
movl $0x1, %r8d
shlq %cl, %r8
orq %r8, -0x8(%rax,%r9,8)
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
testq %rax, %rax
je 0x2e9c3
movq %r14, %rcx
movq 0x8(%rax), %rsi
cmpq %rdx, (%rax)
je 0x2e9b8
addq $0x8, %rax
movq %rax, %rcx
jmp 0x2e9bb
movq %rsi, (%rcx)
movq %rsi, %rax
testq %rsi, %rsi
jne 0x2e9a6
movq 0x30(%rdx), %rax
testq %rax, %rax
je 0x2e9ed
leaq 0x30(%rdx), %rcx
movq 0x8(%rax), %rsi
cmpq %r14, (%rax)
je 0x2e9e2
addq $0x8, %rax
movq %rax, %rcx
jmp 0x2e9e5
movq %rsi, (%rcx)
movq %rsi, %rax
testq %rsi, %rsi
jne 0x2e9d0
movq (%rdx), %r13
testq %r13, %r13
je 0x2ea4d
movq (%rbx), %rax
leaq 0x3f(%r12), %rbp
movq (%r13), %rdx
movslq 0x28(%rdx), %rcx
leal 0x3f(%rcx), %esi
testq %rcx, %rcx
cmovnsl %ecx, %esi
sarl $0x6, %esi
movslq %esi, %rsi
leaq (%rax,%rsi,8), %rsi
movq %rcx, %rdi
andq %rbp, %rdi
xorl %r8d, %r8d
cmpq %r12, %rdi
setbe %r8b
movq -0x8(%rsi,%r8,8), %rsi
btq %rcx, %rsi
jb 0x2ea44
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2e944
movq (%rbx), %rax
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x2e9fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Reduce(newick_child**, newick_node*)
void LDAG::Reduce(newick_child** childptr, newick_node* node)
{
    while (*childptr)
    {
        if ((*childptr)->node == node)
            *childptr = (*childptr)->next;
        else childptr = &(*childptr)->next;
    }
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0x2ea81
movq 0x8(%rax), %rcx
cmpq %rdx, (%rax)
je 0x2ea76
addq $0x8, %rax
movq %rax, %rsi
jmp 0x2ea79
movq %rcx, (%rsi)
movq %rcx, %rax
testq %rcx, %rcx
jne 0x2ea64
retq