LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::eps3(double, double, double)
double eps3(double e, double M, double x)
    {
        double t1 = cos(x);
        double t2 = -1 + e*t1;
        double t3 = sin(x);
        double t4 = e*t3;
        double t5 = -x + t4 + M;
        double t6 = t5/(0.5*t5*t4/t2+t2);

        return t5/((0.5*t3 - 1/6*t1*t6)*e*t6+t2);
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm2, (%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd %xmm2, %xmm0
callq 0x6790
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x2a6d6(%rip), %xmm1    # 0x3f700
movsd %xmm1, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x60b0
movapd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm5
mulsd %xmm5, %xmm2
movapd %xmm2, %xmm1
subsd (%rsp), %xmm1
addsd 0x18(%rsp), %xmm1
movsd 0x2a139(%rip), %xmm3    # 0x3f198
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm2, %xmm4
movsd 0x10(%rsp), %xmm2
divsd %xmm2, %xmm4
addsd %xmm2, %xmm4
movapd %xmm2, %xmm6
movapd %xmm1, %xmm2
divsd %xmm4, %xmm2
movsd 0x20(%rsp), %xmm4
mulsd 0x2a64d(%rip), %xmm4    # 0x3f6e0
mulsd %xmm2, %xmm4
mulsd %xmm3, %xmm0
addsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm6, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::ecc_anomaly(double, double, double, double)
double ecc_anomaly(double t, double period, double ecc, double time_peri)
    {
        double tol;
        if (ecc < 0.8) tol = 1e-14;
        else tol = 1e-13;

        double n = 2.*M_PI/period;  // mean motion
        double M = n*(t - time_peri);  // mean anomaly
        double Mnorm = fmod(M, 2.*M_PI);
        double E0 = keplerstart3(ecc, Mnorm);
        double dE = tol + 1;
        double E = M;
        int count = 0;
        while (dE > tol)
        {
            E = E0 - eps3(ecc, Mnorm, E0);
            dE = abs(E-E0);
            E0 = E;
            count++;
            // failed to converge, this only happens for nearly parabolic orbits
            if (count == 100) break;
        }
        return E;
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movsd 0x2a62b(%rip), %xmm4    # 0x3f6f0
xorl %eax, %eax
movsd %xmm2, 0x18(%rsp)
ucomisd %xmm2, %xmm4
seta %al
leaq 0x2a675(%rip), %rcx     # 0x3f750
movsd (%rcx,%rax,8), %xmm2
movsd %xmm2, 0x28(%rsp)
movsd 0x2a062(%rip), %xmm2    # 0x3f150
movapd %xmm2, %xmm4
divsd %xmm1, %xmm4
subsd %xmm3, %xmm0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm2, %xmm1
callq 0x6530
movsd %xmm0, 0x10(%rsp)
callq 0x6790
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x60b0
movsd 0x29eff(%rip), %xmm1    # 0x3f030
movsd 0x28(%rsp), %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm2, %xmm1
movsd 0x20(%rsp), %xmm1
jbe 0x15288
movsd 0x2a5a5(%rip), %xmm4    # 0x3f6f8
movsd 0x8(%rsp), %xmm5
mulsd %xmm5, %xmm4
movsd 0x18(%rsp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm1, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm4
mulsd 0x29eb9(%rip), %xmm2    # 0x3f038
addsd %xmm1, %xmm4
addsd %xmm3, %xmm2
mulsd %xmm5, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd 0x10(%rsp), %xmm4
movl $0x64, %ebx
movapd %xmm4, %xmm1
movsd %xmm4, 0x8(%rsp)
movsd %xmm1, 0x20(%rsp)
movapd %xmm4, %xmm0
callq 0x6790
movsd %xmm0, 0x38(%rsp)
movsd 0x18(%rsp), %xmm2
mulsd %xmm0, %xmm2
addsd 0x2a531(%rip), %xmm2    # 0x3f700
movsd %xmm2, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x60b0
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm7
mulsd %xmm7, %xmm1
movapd %xmm1, %xmm2
subsd %xmm4, %xmm2
addsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm3
movsd 0x29f8a(%rip), %xmm5    # 0x3f198
mulsd %xmm5, %xmm3
mulsd %xmm1, %xmm3
movsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm3
addsd %xmm1, %xmm3
movapd %xmm1, %xmm6
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd 0x38(%rsp), %xmm3
mulsd 0x2a4a2(%rip), %xmm3    # 0x3f6e0
mulsd %xmm1, %xmm3
mulsd %xmm5, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm7, %xmm0
mulsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm6, %xmm0
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
decl %ebx
je 0x15288
movapd %xmm1, %xmm0
subsd %xmm4, %xmm0
andpd 0x29ee8(%rip), %xmm0    # 0x3f160
ucomisd 0x28(%rsp), %xmm0
movapd %xmm1, %xmm4
ja 0x151a2
movapd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::true_anomaly(double, double, double, double)
double true_anomaly(double t, double period, double ecc, double t_peri)
{
    double E = ecc_anomaly(t, period, ecc, t_peri);
    // double E = solve_kepler(t, period, ecc, t_peri);
    double cosE = cos(E);
    double f = acos( (cosE - ecc)/( 1 - ecc*cosE ) );
    // acos gives the principal values ie [0:PI]
    // when E goes above PI we need another condition
    if(E > M_PI)
      f = 2*M_PI - f;

    return f;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm2, 0x8(%rsp)
callq 0x150b8
movsd %xmm0, 0x10(%rsp)
callq 0x6790
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm2
movsd 0x29d6a(%rip), %xmm0    # 0x3f030
subsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x6420
movsd 0x29e71(%rip), %xmm2    # 0x3f150
subsd %xmm0, %xmm2
movsd 0x2a3cd(%rip), %xmm1    # 0x3f6b8
cmpltsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm3
andnpd %xmm0, %xmm3
andpd %xmm2, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::from_prior(DNest4::RNG&)
void RJObject<ConditionalPrior>::from_prior(RNG& rng)
{
	added.resize(0);
	removed.resize(0);

	// Generate the hyperparameters from their prior
	conditional_prior.from_prior(rng);

	int num = max_num_components;

	// Generate from {0, 1, 2, ..., max_num_components}
	if(!fixed)
    {
        if(prior_type == PriorType::uniform)
        {
		    num = rng.rand_int(max_num_components + 1);
        }
        else if(prior_type == PriorType::log_uniform)
        {
            do
            {
                num = rng.rand_int(max_num_components + 1);
            }while(rng.rand() >= 1.0/(num + 1));
        }
    }

	// Resize the vectors of component properties
	components.resize(0);
	u_components.resize(0);

	// Generate components
	num_components = 0;
	for(int i=0; i<num; i++)
		add_component(rng);

    components_changed_flag = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0xe8, %rdi
xorl %esi, %esi
callq 0xba90
leaq 0x100(%rbx), %rdi
xorl %esi, %esi
callq 0xba90
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x84f0
movl 0x8(%rbx), %r15d
cmpb $0x0, 0xc(%rbx)
jne 0x1587a
movl (%rbx), %eax
testl %eax, %eax
je 0x15869
cmpl $0x1, %eax
jne 0x1587a
movl 0x8(%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x3c1d6
movl %eax, %r15d
movq %r14, %rdi
callq 0x3c02c
leal 0x1(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x297d3(%rip), %xmm2    # 0x3f030
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x15832
jmp 0x1587a
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x3c1d6
movl %eax, %r15d
leaq 0xb8(%rbx), %rdi
xorl %esi, %esi
callq 0xba90
leaq 0xd0(%rbx), %rdi
xorl %esi, %esi
callq 0xba90
movl $0x0, 0xb4(%rbx)
testl %r15d, %r15d
jle 0x158b5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18aae
decl %r15d
jne 0x158a5
movb $0x1, 0xb0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::consolidate_diff()
void RJObject<ConditionalPrior>::consolidate_diff()
{
	if(ConditionalPrior::weight_parameter == -1)
	{
		std::cerr<<"# WARNING: consolidate_diff() failed."<<std::endl;
		return;
	}

	for(size_t i=0; i<removed.size(); i++)
	{
		removed[i][ConditionalPrior::weight_parameter] *= -1;
		added.push_back(removed[i]);
	}
	removed.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x100(%rdi), %rsi
cmpq %rsi, 0x108(%rdi)
je 0x15939
leaq 0xe8(%rbx), %r14
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
movq (%rsi,%r15), %rax
addq %r15, %rsi
movsd 0x8(%rax), %xmm0
xorps 0x29e38(%rip), %xmm0    # 0x3f740
movlps %xmm0, 0x8(%rax)
movq %r14, %rdi
callq 0xb8ea
incq %r13
movq 0x100(%rbx), %rsi
movq 0x108(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r15
cmpq %rax, %r13
jb 0x158f5
addq $0x100, %rbx            # imm = 0x100
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc696
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/CommaInitializer.h
// Function: Eigen::CommaInitializer<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::operator,(double const&)
EIGEN_DEVICE_FUNC
  CommaInitializer& operator,(const Scalar& s)
  {
    if (m_col==m_xpr.cols())
    {
      m_row+=m_currentBlockRows;
      m_col = 0;
      m_currentBlockRows = 1;
      eigen_assert(m_row<m_xpr.rows()
        && "Too many rows passed to comma initializer (operator<<)");
    }
    eigen_assert(m_col<m_xpr.cols()
      && "Too many coefficients passed to comma initializer (operator<<)");
    eigen_assert(m_currentBlockRows==1);
    m_xpr.coeffRef(m_row, m_col++) = s;
    return *this;
  }

// Assembly:
pushq %rax
cmpq $0x1, 0x10(%rdi)
jne 0x15a0d
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
cmpq 0x8(%rax), %rcx
jge 0x15a84
movq 0x10(%rdi), %rax
testq %rax, %rax
jg 0x15a46
cmpq $0x1, 0x18(%rdi)
jne 0x15a65
movsd (%rsi), %xmm0
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x10(%rdi)
imulq 0x8(%rcx), %rax
shlq $0x3, %rax
addq (%rcx), %rax
movsd %xmm0, (%rax,%rdx,8)
movq %rdi, %rax
popq %rcx
retq
leaq 0x2a845(%rip), %rdi     # 0x40292
leaq 0x2a6b5(%rip), %rsi     # 0x40109
leaq 0x2a79c(%rip), %rcx     # 0x401f7
movl $0x48, %edx
callq 0x62b0
leaq 0x2a87d(%rip), %rdi     # 0x402e9
leaq 0x2a696(%rip), %rsi     # 0x40109
leaq 0x2a77d(%rip), %rcx     # 0x401f7
movl $0x49, %edx
callq 0x62b0
leaq 0x2a71d(%rip), %rdi     # 0x401a8
leaq 0x2a677(%rip), %rsi     # 0x40109
leaq 0x2a75e(%rip), %rcx     # 0x401f7
movl $0x45, %edx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::perturb(DNest4::RNG&, bool)
double RJObject<ConditionalPrior>::perturb(RNG& rng, bool hyperparameters)
{
	if(max_num_components == 0)
		return 0.;

	added.resize(0);
	removed.resize(0);
    components_changed_flag = true;

	double logH = 0.;

	int which;
    do
    {
        which = (fixed)?(1 + rng.rand_int(2)):(rng.rand_int(3));
    }while(!hyperparameters && which == 1);

	if(which == 0)
	{
		// Do some birth or death
		logH += perturb_num_components(rng);
	}
	else if(which == 1)
	{
		// Change the hyperparameters
		if(rng.rand() <= 0.5)
		{
			logH += conditional_prior.perturb1(rng, components, u_components);
            components_changed_flag = false;
		}
		else
		{
			removed = components;
			logH += conditional_prior.perturb2(rng, components, u_components);
			added = components;
		}
	}
	else if(which == 2)
	{
		logH += perturb_components(rng);
	}

	return logH;
}

// Assembly:
xorpd %xmm1, %xmm1
cmpl $0x0, 0x8(%rdi)
je 0x15e90
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe8(%rdi), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xba90
leaq 0x100(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xba90
movb $0x1, 0xb0(%rbx)
cmpb $0x1, 0xc(%rbx)
jne 0x15da7
movq %r14, %rdi
movl $0x2, %esi
callq 0x3c1d6
incl %eax
jmp 0x15db4
movq %r14, %rdi
movl $0x3, %esi
callq 0x3c1d6
testb %bpl, %bpl
jne 0x15dbe
cmpl $0x1, %eax
je 0x15d90
testl %eax, %eax
je 0x15de1
cmpl $0x1, %eax
je 0x15df9
cmpl $0x2, %eax
xorpd %xmm1, %xmm1
jne 0x15e82
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19444
jmp 0x15dec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x191b4
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0x15e82
movq %r14, %rdi
callq 0x3c02c
movsd 0x2938f(%rip), %xmm1    # 0x3f198
ucomisd %xmm0, %xmm1
jae 0x15e59
leaq 0xb8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x192cc
leaq 0x10(%rbx), %rdi
addq $0xd0, %rbx
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x3e810
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x192cc
movsd (%rsp), %xmm1
jmp 0x15e82
leaq 0x10(%rbx), %rdi
leaq 0xb8(%rbx), %rdx
leaq 0xd0(%rbx), %rcx
movq %r14, %rsi
callq 0x3e67c
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movb $0x0, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::print(std::ostream&) const
void RJObject<ConditionalPrior>::print(std::ostream& out) const
{
	out<<num_dimensions<<' '<<max_num_components<<' ';
	conditional_prior.print(out); out<<' ';
	out<<num_components<<' ';

	// Write out components
	for(int j=0; j<num_dimensions; j++)
	{
		for(int i=0; i<num_components; i++)
			out<<components[i][j]<<' ';

		// Pad with zeros (turned-off components)
		for(int i=num_components; i<max_num_components; i++)
			out<<0.<<' ';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl 0x4(%rdi), %esi
movq %r15, %rdi
callq 0x66e0
movb $0x20, %bpl
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x66e0
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x88f2
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x64a0
movl 0xb4(%r14), %esi
movq %r15, %rdi
callq 0x66e0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
cmpl $0x0, 0x4(%r14)
jle 0x184a2
xorl %r12d, %r12d
leaq 0xb(%rsp), %rbx
leaq 0xa(%rsp), %r13
movl 0xb4(%r14), %ebp
testl %ebp, %ebp
jle 0x1848c
movq %r12, 0x10(%rsp)
xorl %r12d, %r12d
movq %r15, %r13
xorl %r15d, %r15d
movq 0xb8(%r14), %rax
movq (%rax,%r12), %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r13, %rdi
callq 0x6630
movb $0x20, 0xb(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x64a0
incq %r15
movslq 0xb4(%r14), %rbp
addq $0x18, %r12
cmpq %rbp, %r15
jl 0x18416
movq %r13, %r15
movq 0x10(%rsp), %r12
leaq 0xa(%rsp), %r13
jmp 0x1848c
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6630
movb $0x20, 0xa(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x64a0
incl %ebp
cmpl 0x8(%r14), %ebp
jl 0x1846a
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0x183f9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::add_component(DNest4::RNG&)
double RJObject<ConditionalPrior>::add_component(RNG& rng)
{
	if(num_components >= max_num_components)
	{
		std::cerr<<"# WARNING: Trying to add component ";
		std::cerr<<"but already full!"<<std::endl;
		return 0.;
	}

	// Increment counter
	num_components++;

	// Generate component
	std::vector<double> component(num_dimensions);
	for(int j=0; j<num_dimensions; j++)
		component[j] = rng.rand();
	u_components.push_back(component);
	conditional_prior.from_uniform(component);
	components.push_back(component);

	// Accumulate added/removed component info
	added.push_back(component);

	return 0.;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl 0xb4(%rdi), %eax
cmpl 0x8(%rdi), %eax
jge 0x18b6c
movq %rsi, %r14
movq %rdi, %rbx
incl %eax
movl %eax, 0xb4(%rdi)
movslq 0x4(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xbb9c
cmpl $0x0, 0x4(%rbx)
jle 0x18b0f
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3c02c
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x18af0
leaq 0xd0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb8ea
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8782
leaq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb8ea
addq $0xe8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb8ea
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18bc2
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
jmp 0x18bc2
movq 0x3a475(%rip), %rbx     # 0x52fe8
leaq 0x2720c(%rip), %rsi     # 0x3fd86
movl $0x23, %edx
movq %rbx, %rdi
callq 0x64a0
leaq 0x2721c(%rip), %rsi     # 0x3fdaa
movl $0x11, %edx
movq %rbx, %rdi
callq 0x64a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x18bd1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18beb
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, 1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
    {
      if(size != m_rows*_Cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x18d7b
movq %rsi, %r15
movq (%r14), %rdi
callq 0x64d0
testq %r15, %r15
jle 0x18d76
movq %r15, %rax
shrq $0x3d, %rax
jne 0x18d48
leaq (,%r15,8), %rdi
callq 0x6520
cmpq $0x1, %r15
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x18d85
testq %rax, %rax
jne 0x18d78
movl $0x8, %edi
callq 0x61d0
movq 0x3a20f(%rip), %rcx     # 0x52f68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3a239(%rip), %rsi     # 0x52fa0
movq 0x3a1e2(%rip), %rdx     # 0x52f50
movq %rax, %rdi
callq 0x66c0
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x271f1(%rip), %rdi     # 0x3ff7d
leaq 0x2c638(%rip), %rsi     # 0x453cb
leaq 0x2729e(%rip), %rcx     # 0x40038
movl $0xb8, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
      m_cols = cols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x18e31
movq %rsi, %r12
movq (%r15), %rdi
callq 0x64d0
testq %r12, %r12
jle 0x18e2c
movq %r12, %rax
shrq $0x3d, %rax
jne 0x18dfe
leaq (,%r12,8), %rdi
callq 0x6520
cmpq $0x1, %r12
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x18e45
testq %rax, %rax
jne 0x18e2e
movl $0x8, %edi
callq 0x61d0
movq 0x3a159(%rip), %rcx     # 0x52f68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3a183(%rip), %rsi     # 0x52fa0
movq 0x3a12c(%rip), %rdx     # 0x52f50
movq %rax, %rdi
callq 0x66c0
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x27131(%rip), %rdi     # 0x3ff7d
leaq 0x2c578(%rip), %rsi     # 0x453cb
leaq 0x271de(%rip), %rcx     # 0x40038
movl $0xb8, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::perturb_num_components(DNest4::RNG&)
double RJObject<ConditionalPrior>::perturb_num_components(RNG& rng)
{
	double logH = 0.;

	// Work out how many components we will have after the change
	double delta = max_num_components*rng.randh();
	int difference = (int)delta;
	// In case difference is zero, make it +1 or -1. Also, just do this
    // sometimes just because it's gentle
	if(difference == 0)
	{
		if(rng.rand() <= 0.5)
			difference = -1;
		else
			difference =  1;
	}
	int new_num_components = DNest4::mod(num_components + difference, max_num_components + 1);
	difference = new_num_components - num_components;

    // Add to logH for non-uniform prior on N
	if(prior_type == PriorType::log_uniform)
		logH += log(num_components + 1) - log(new_num_components + 1);

	// Now do the required changes
	if(difference > 0)
	{
		for(int i=0; i<difference; i++)
			logH += add_component(rng);
	}
	else
	{
		for(int i=0; i<-difference; i++)
			logH += remove_component(rng);
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cvtsi2sdl 0x8(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x3c0ec
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %edi
testl %edi, %edi
jne 0x191fc
movq %rbx, %rdi
callq 0x3c02c
xorl %edi, %edi
movsd 0x25fa6(%rip), %xmm1    # 0x3f198
ucomisd %xmm0, %xmm1
adcl $-0x1, %edi
orl $0x1, %edi
addl 0xb4(%r14), %edi
movl 0x8(%r14), %esi
incl %esi
callq 0x3c677
movl %eax, %ebp
movl 0xb4(%r14), %eax
movl %ebp, %r15d
subl %eax, %r15d
xorpd %xmm0, %xmm0
cmpl $0x1, (%r14)
jne 0x19259
incl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x63c0
movsd %xmm0, (%rsp)
incl %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
callq 0x63c0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
testl %r15d, %r15d
jle 0x19288
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18aae
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
decl %r15d
jne 0x1925e
jmp 0x192c1
jns 0x192c1
negl %r15d
cmpl $0x2, %r15d
movl $0x1, %ebp
cmovgel %r15d, %ebp
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x196fc
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
decl %ebp
jne 0x1929a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::remove_component(DNest4::RNG&)
double RJObject<ConditionalPrior>::remove_component(RNG& rng)
{
	if(num_components <= 0)
	{
		std::cerr<<"# WARNING: Trying to remove component ";
		std::cerr<<"but already empty!"<<std::endl;
		return 0.;
	}

	// Find one to delete
	int i = rng.rand_int(num_components);

	// Accumulate added/removed component info
	removed.push_back(components[i]);

	// Delete it
	u_components.erase(u_components.begin() + i);
	components.erase(components.begin() + i);

	// Decrement counter
	num_components--;

	return 0.;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0xb4(%rdi), %eax
testl %eax, %eax
jle 0x1976f
movq %rdi, %rbx
movq %rsi, %rdi
movl %eax, %esi
callq 0x3c1d6
leaq 0x100(%rbx), %rdi
leaq 0xb8(%rbx), %r14
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq 0xb8(%rbx), %rsi
addq %r15, %rsi
callq 0xb8ea
leaq 0xd0(%rbx), %rdi
movq 0xd0(%rbx), %rsi
addq %r15, %rsi
callq 0x197ce
addq 0xb8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x197ce
decl 0xb4(%rbx)
jmp 0x197c5
movq 0x39872(%rip), %rbx     # 0x52fe8
leaq 0x2709e(%rip), %rsi     # 0x4081b
movl $0x26, %edx
movq %rbx, %rdi
callq 0x64a0
leaq 0x270b1(%rip), %rsi     # 0x40842
movl $0x12, %edx
movq %rbx, %rdi
callq 0x64a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/AssignEvaluator.h
// Function: void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::internal::assign_op<double, double> const&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;

  SrcEvaluatorType srcEvaluator(src);

  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
  // we need to resize the destination after the source evaluator has been created.
  resize_if_allowed(dst, src, func);

  DstEvaluatorType dstEvaluator(dst);
    
  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());

  dense_assignment_loop<Kernel>::run(kernel);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r14
cmpq %r15, 0x8(%rdi)
jne 0x19f3b
cmpq %r14, 0x10(%rbx)
je 0x19f84
movq %r14, %rax
orq %r15, %rax
js 0x1a008
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x19f6f
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
cmpq %r15, %rax
jl 0x1a027
movq %r14, %rsi
imulq %r15, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x18da4
movq 0x8(%rbx), %rdx
cmpq %r15, %rdx
jne 0x19fe9
movq 0x10(%rbx), %rax
cmpq %r14, %rax
jne 0x19fe9
movq (%rbx), %rcx
imulq %rdx, %rax
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
cmpq $0x2, %rax
jl 0x19fc5
xorl %esi, %esi
movaps (%r12,%rsi,8), %xmm0
movaps %xmm0, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jl 0x19fb3
cmpq %rax, %rdx
jge 0x19fdd
movsd (%r12,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x19fca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2671b(%rip), %rdi     # 0x4070b
leaq 0x2b3fd(%rip), %rsi     # 0x453f4
leaq 0x26954(%rip), %rcx     # 0x40952
movl $0x2eb, %edx            # imm = 0x2EB
callq 0x62b0
leaq 0x26394(%rip), %rdi     # 0x403a3
leaq 0x2b388(%rip), %rsi     # 0x4539e
leaq 0x26515(%rip), %rcx     # 0x40532
movl $0x11d, %edx            # imm = 0x11D
callq 0x62b0
movl $0x8, %edi
callq 0x61d0
movq 0x38f30(%rip), %rcx     # 0x52f68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x38f5a(%rip), %rsi     # 0x52fa0
movq 0x38f03(%rip), %rdx     # 0x52f50
movq %rax, %rdi
callq 0x66c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/SolveTriangular.h
// Function: Eigen::internal::triangular_solver_selector<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 2, 2, 0, -1>::run(Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const> const&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>&)
static void run(const Lhs& lhs, Rhs& rhs)
  {
    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);

    const Index size = lhs.rows();
    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();

    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;

    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);

    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x30(%rdi), %r14
movq (%rdi), %r15
movq 0x10(%rdi), %r12
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %rax
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, -0x10(%rdi)
movaps %xmm0, -0x20(%rdi)
leaq 0x10(%rsp), %rbp
movq %r13, (%rbp)
movq %rax, 0x8(%rbp)
movq %r12, 0x10(%rbp)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, %ecx
movq %rbp, %rsi
callq 0x1bb92
movq 0x10(%rbp), %rax
movq (%rbp), %rcx
imulq %rax, %rcx
movq %rcx, 0x18(%rbp)
imulq 0x8(%rbp), %rax
movq %rax, 0x20(%rbp)
movq (%rbx), %r8
movq %rsp, %rax
movl $0x1, %r9d
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
pushq %rax
pushq 0x30(%rbx)
callq 0x1b302
addq $0x10, %rsp
movq (%rsp), %rdi
callq 0x64d0
movq 0x8(%rsp), %rdi
callq 0x64d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x64d0
movq 0x8(%rsp), %rdi
callq 0x64d0
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::CacheSizes::CacheSizes()
CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
    int l1CacheSize, l2CacheSize, l3CacheSize;
    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
    m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
    m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
    m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rdi)
movq $-0x1, 0x10(%rdi)
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1bf6d
movl (%r14), %eax
testl %eax, %eax
movl $0x8000, %ecx           # imm = 0x8000
cmovgl %eax, %ecx
movslq %ecx, %rax
movq %rax, (%rbx)
movl (%r15), %eax
testl %eax, %eax
movl $0x40000, %ecx          # imm = 0x40000
cmovgl %eax, %ecx
movslq %ecx, %rax
movq %rax, 0x8(%rbx)
movl (%r12), %eax
testl %eax, %eax
movl $0x200000, %ecx         # imm = 0x200000
cmovgl %eax, %ecx
movslq %ecx, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/Solve.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&, Eigen::internal::assign_op<double, double> const&)
static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);

    src.dec()._solve_impl(src.rhs(), dst);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x10(%rax), %rdx
cmpq %rdx, 0x8(%rdi)
je 0x1ef16
testq %rdx, %rdx
js 0x1ef2c
movl $0x1, %ecx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x18cfc
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ef4c
leaq 0x21470(%rip), %rdi     # 0x403a3
leaq 0x26464(%rip), %rsi     # 0x4539e
leaq 0x21751(%rip), %rcx     # 0x40692
movl $0x11d, %edx            # imm = 0x11D
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/SolveTriangular.h
// Function: Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1, 1, 0, 1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&)
static void run(const Lhs& lhs, Rhs& rhs)
  {
    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);

    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1

    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;

    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
                                                  (useRhsDirectly ? rhs.data() : 0));
                                                  
    if(!useRhsDirectly)
      MappedRhs(actualRhs,rhs.size()) = rhs;

    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);

    if(!useRhsDirectly)
      rhs = MappedRhs(actualRhs, rhs.size());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
movq %r15, %rax
shrq $0x3d, %rax
jne 0x1f150
movq %rdi, %rbx
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x1f0e7
xorl %r14d, %r14d
jmp 0x1f124
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15           # imm = 0x4000
ja 0x1f10e
movq %rsp, %r14
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r14
movq %r14, %rsp
movq %r14, %rcx
jmp 0x1f124
callq 0x6520
movq %rax, %r14
testb $0xf, %r14b
jne 0x1f17e
movq %r14, %rcx
testq %r14, %r14
je 0x1f150
movq 0x10(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1f1ba
cmpq $0x4001, %r15           # imm = 0x4001
jb 0x1f145
movq %r14, %rdi
callq 0x64d0
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x61d0
movq 0x33e07(%rip), %rcx     # 0x52f68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x33e31(%rip), %rsi     # 0x52fa0
movq 0x33dda(%rip), %rdx     # 0x52f50
movq %rax, %rdi
callq 0x66c0
leaq 0x20df8(%rip), %rdi     # 0x3ff7d
leaq 0x2623f(%rip), %rsi     # 0x453cb
leaq 0x20ea5(%rip), %rcx     # 0x40038
movl $0xb8, %edx
callq 0x62b0
movq %rax, %rbx
cmpq $0x4001, %r15           # imm = 0x4001
jb 0x1f1b1
movq %r14, %rdi
callq 0x64d0
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/eigen/Eigen/src/Core/CwiseBinaryOp.h
// Function: double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const> const, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>, 3, 0>::run<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const> const, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>(Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const> const, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const> const, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const&)
Index rows() const {
      // return the fixed size type if available to enable compile time optimizations
      if (internal::traits<typename internal::remove_all<LhsNested>::type>::RowsAtCompileTime==Dynamic)
        return m_rhs.rows();
      else
        return m_lhs.rows();
    }

// Assembly:
movq 0x38(%rdx), %rax
movq 0x8(%rax), %rax
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
cmpq $0x3, %rsi
jae 0x208d6
movsd (%rcx), %xmm0
mulsd (%rdx), %xmm0
cmpq $0x2, %rax
jl 0x2098e
movl $0x1, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x208bb
jmp 0x2098e
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rcx), %xmm0
movupd (%rdx), %xmm1
mulpd %xmm0, %xmm1
cmpq $0x4, %rax
jl 0x20967
andq $-0x4, %r8
movupd 0x10(%rcx), %xmm2
movupd 0x10(%rdx), %xmm0
mulpd %xmm2, %xmm0
cmpq $0x8, %rax
jl 0x20942
movl $0x4, %edi
movupd (%rcx,%rdi,8), %xmm2
movupd 0x10(%rcx,%rdi,8), %xmm3
movupd (%rdx,%rdi,8), %xmm4
mulpd %xmm2, %xmm4
addpd %xmm4, %xmm1
movupd 0x10(%rdx,%rdi,8), %xmm2
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm0
addq $0x4, %rdi
cmpq %r8, %rdi
jl 0x20913
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %r8, %rsi
jle 0x20967
movupd (%rcx,%r8,8), %xmm0
movupd (%rdx,%r8,8), %xmm2
mulpd %xmm0, %xmm2
addpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq %rax, %rsi
jge 0x2098e
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x20978
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/trends/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "d1.txt";

    load(datafile, "ms", 2);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(100);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x32858(%rip), %rdx     # 0x53548
leaq 0x32849(%rip), %r14     # 0x53540
leaq 0x24693(%rip), %rcx     # 0x45391
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1e7c9(%rip), %rsi     # 0x3f4e9
movq %r14, %rdi
callq 0x20f17
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2101a
movq %r14, %rdi
movl $0x64, %esi
callq 0x210ec
leaq 0x8(%rsp), %rdi
callq 0x212ca
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212ca
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/trends/../../DNest4/code/StartImpl.h
// Function: DNest4::Sampler<RVmodel> DNest4::setup<RVmodel>(DNest4::CommandLineOptions const&)
Sampler<ModelType> setup(const CommandLineOptions& options)
{
	std::cout<<"# Using "<<options.get_num_threads()<<" thread"<<
		((options.get_num_threads() == 1)?("."):("s."))<<std::endl;

	std::cout<<"# Target compression factor between levels = ";
	std::cout<<options.get_compression()<<std::endl;

	// Load sampler options from file
	Options sampler_options(options.get_options_file().c_str());

	// Create sampler
	Sampler<ModelType> sampler(options.get_num_threads(),
								options.get_compression_double(),
								sampler_options,
								true);

	// Seed RNGs
	sampler.initialise(options.get_seed_uint());

	return sampler;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1dbaf(%rip), %r15     # 0x52f98
leaq 0x11fd5(%rip), %rsi     # 0x473c5
movl $0x8, %edx
movq %r15, %rdi
callq 0x64a0
movl 0x80(%r14), %esi
movq %r15, %rdi
callq 0x66e0
movq %rax, %r12
leaq 0x11fb8(%rip), %rsi     # 0x473ce
movl $0x7, %edx
movq %rax, %rdi
callq 0x64a0
xorl %edx, %edx
cmpl $0x1, 0x80(%r14)
leaq 0x12a3b(%rip), %rax     # 0x47e6f
leaq 0xa246(%rip), %rsi      # 0x3f681
cmoveq %rax, %rsi
setne %dl
incq %rdx
movq %r12, %rdi
callq 0x64a0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %r12, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
leaq 0x11f5a(%rip), %rsi     # 0x473d6
movl $0x2d, %edx
movq %r15, %rdi
callq 0x64a0
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %r15, %rdi
callq 0x64a0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
movq (%r14), %rsi
movq %rsp, %rdi
callq 0x3b81c
movl 0x80(%r14), %ebp
movq %r14, %rdi
callq 0x3b052
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %ecx
callq 0x35610
movq %r14, %rdi
callq 0x3b0e0
movq %rbx, %rdi
movl %eax, %esi
callq 0x35b14
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35522
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3553d
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35558
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x6460
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x212ca
jmp 0x3557b
movq %rax, %r14
movq %rsp, %rdi
callq 0x21748
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/trends/../../DNest4/code/Utils.h
// Function: std::vector<unsigned long, std::allocator<unsigned long>> DNest4::argsort<DNest4::LikelihoodType>(std::vector<DNest4::LikelihoodType, std::allocator<DNest4::LikelihoodType>> const&)
std::vector<size_t> argsort(const std::vector<T>& v)
{
	// initialize original index locations
	std::vector<size_t> idx(v.size());
	for(size_t i=0; i<idx.size(); i++)
		idx[i] = i;

	// sort indexes based on comparing values in v
	std::sort(idx.begin(), idx.end(),
		[&v](size_t i1, size_t i2) {return v[i1] < v[i2];});

	return idx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
leaq 0x7(%rsp), %rdx
callq 0x36876
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq %r15, %rax
subq %r12, %rax
sarq $0x3, %rax
cmpq %r12, %r15
je 0x361c0
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movq %rdx, (%r12,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x361b4
cmpq %r15, %r12
je 0x361ee
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x36900
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x369cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x36214
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6460
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::initialise_output_files() const
void Sampler<ModelType>::initialise_output_files() const
{
	if(!save_to_disk)
		return;

	std::fstream fout;

	// Output headers
	fout.open(options.sample_info_file, std::ios::out);
	fout<<"# level assignment, log likelihood, tiebreaker, ID."<<std::endl;
	fout.close();

	fout.open(options.sample_file, std::ios::out);
	fout<<"# "<<particles[0].description().c_str()<<std::endl;
	fout.close();

	save_levels();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
cmpb $0x1, (%rdi)
jne 0x37a45
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x64c0
leaq 0x88(%rbx), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x6560
leaq 0x30(%rsp), %r14
leaq 0xfc1e(%rip), %rsi      # 0x47553
movl $0x33, %edx
movq %r14, %rdi
callq 0x64a0
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
leaq 0x20(%rsp), %rdi
callq 0x6060
leaq 0x68(%rbx), %rsi
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
callq 0x6560
leaq 0xfbf8(%rip), %rsi      # 0x47587
movl $0x2, %edx
movq %r14, %rdi
callq 0x64a0
movq 0xc8(%rbx), %rsi
movq %rsp, %rdi
callq 0x1251c
movq (%rsp), %r15
testq %r15, %r15
je 0x379cc
movq %r15, %rdi
callq 0x61a0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x64a0
jmp 0x379e5
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x50(%rsp,%rax), %esi
orl $0x1, %esi
callq 0x6690
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %r14, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37a29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x20(%rsp), %rdi
callq 0x6060
movq %rbx, %rdi
callq 0x37a8a
leaq 0x20(%rsp), %rdi
callq 0x60c0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
jmp 0x37a74
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37a77
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
jmp 0x37a77
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::save_levels() const
void Sampler<ModelType>::save_levels() const
{
	if(!save_to_disk)
		return;

	// Output file
	std::fstream fout;
	fout.open(options.levels_file, std::ios::out);
	fout<<"# log_X, log_likelihood, tiebreaker, accepts, tries, exceeds, visits";
	fout<<std::endl;
    fout<<std::setprecision(12);


	for(const Level& level: levels)
	{
		fout<<level.get_log_X()<<' ';
		fout<<level.get_log_likelihood().get_value()<<' ';
		fout<<level.get_log_likelihood().get_tiebreaker()<<' ';
		fout<<level.get_accepts()<<' ';
		fout<<level.get_tries()<<' ';
		fout<<level.get_exceeds()<<' ';
		fout<<level.get_visits()<<std::endl;
	}
	fout.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
cmpb $0x1, (%rdi)
jne 0x37c60
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x64c0
leaq 0xa8(%r14), %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x6560
leaq 0x20(%rsp), %rbx
leaq 0xfab7(%rip), %rsi      # 0x4758a
movl $0x44, %edx
movq %rbx, %rdi
callq 0x64a0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x28(%rsp,%rax)
movq 0x630(%r14), %r12
movq 0x638(%r14), %r13
cmpq %r13, %r12
je 0x37c4c
leaq 0xf(%rsp), %r14
movsd 0x10(%r12), %xmm0
movq %rbx, %rdi
callq 0x6630
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movsd (%r12), %xmm0
movq %rbx, %rdi
callq 0x6630
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movsd 0x8(%r12), %xmm0
movq %rbx, %rdi
callq 0x6630
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movl 0x28(%r12), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movl 0x30(%r12), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movl 0x20(%r12), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x64a0
movl 0x18(%r12), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %r15, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6300
addq $0x38, %r12
cmpq %r13, %r12
jne 0x37b37
leaq 0x10(%rsp), %rdi
callq 0x6060
leaq 0x10(%rsp), %rdi
callq 0x60c0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x37c73
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6710