LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8902
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 0x17dda
xorl %r12d, %r12d
leaq 0xb(%rsp), %rbx
leaq 0xa(%rsp), %r13
movl 0xb4(%r14), %ebp
testl %ebp, %ebp
jle 0x17dc4
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 0x17d4e
movq %r13, %r15
movq 0x10(%rsp), %r12
leaq 0xa(%rsp), %r13
jmp 0x17dc4
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 0x17da2
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0x17d31
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x184a4
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 0xbc58
cmpl $0x0, 0x4(%rbx)
jle 0x18447
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x39a4e
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x18428
leaq 0xd0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb98a
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8792
leaq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb98a
addq $0xe8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb98a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x184fa
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
jmp 0x184fa
movq 0x37b3d(%rip), %rbx     # 0x4ffe8
leaq 0x25910(%rip), %rsi     # 0x3ddc2
movl $0x23, %edx
movq %rbx, %rdi
callq 0x64a0
leaq 0x25920(%rip), %rsi     # 0x3dde6
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 0x18509
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18523
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x186b9
movq %rsi, %r15
movq (%r14), %rdi
callq 0x64d0
testq %r15, %r15
jle 0x186b4
movq %r15, %rax
shrq $0x3d, %rax
jne 0x18686
leaq (,%r15,8), %rdi
callq 0x6520
cmpq $0x1, %r15
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x186c3
testq %rax, %rax
jne 0x186b6
movl $0x8, %edi
callq 0x61d0
movq 0x378d1(%rip), %rcx     # 0x4ff68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x378fb(%rip), %rsi     # 0x4ffa0
movq 0x378a4(%rip), %rdx     # 0x4ff50
movq %rax, %rdi
callq 0x66c0
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x258ef(%rip), %rdi     # 0x3dfb9
leaq 0x2a256(%rip), %rsi     # 0x42927
leaq 0x2599c(%rip), %rcx     # 0x3e074
movl $0xb8, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1876f
movq %rsi, %r12
movq (%r15), %rdi
callq 0x64d0
testq %r12, %r12
jle 0x1876a
movq %r12, %rax
shrq $0x3d, %rax
jne 0x1873c
leaq (,%r12,8), %rdi
callq 0x6520
cmpq $0x1, %r12
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x18783
testq %rax, %rax
jne 0x1876c
movl $0x8, %edi
callq 0x61d0
movq 0x3781b(%rip), %rcx     # 0x4ff68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x37845(%rip), %rsi     # 0x4ffa0
movq 0x377ee(%rip), %rdx     # 0x4ff50
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 0x2582f(%rip), %rdi     # 0x3dfb9
leaq 0x2a196(%rip), %rsi     # 0x42927
leaq 0x258dc(%rip), %rcx     # 0x3e074
movl $0xb8, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39b0e
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %edi
testl %edi, %edi
jne 0x18b2e
movq %rbx, %rdi
callq 0x39a4e
xorl %edi, %edi
movsd 0x24674(%rip), %xmm1    # 0x3d198
ucomisd %xmm0, %xmm1
adcl $-0x1, %edi
orl $0x1, %edi
addl 0xb4(%r14), %edi
movl 0x8(%r14), %esi
incl %esi
callq 0x3a0c3
movl %eax, %ebp
movl 0xb4(%r14), %eax
movl %ebp, %r15d
subl %eax, %r15d
xorpd %xmm0, %xmm0
cmpl $0x1, (%r14)
jne 0x18b8b
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 0x18bba
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x183e6
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
decl %r15d
jne 0x18b90
jmp 0x18bf3
jns 0x18bf3
negl %r15d
cmpl $0x2, %r15d
movl $0x1, %ebp
cmovgel %r15d, %ebp
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19018
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
decl %ebp
jne 0x18bcc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1908b
movq %rdi, %rbx
movq %rsi, %rdi
movl %eax, %esi
callq 0x39bf8
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 0xb98a
leaq 0xd0(%rbx), %rdi
movq 0xd0(%rbx), %rsi
addq %r15, %rsi
callq 0x190ea
addq 0xb8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x190ea
decl 0xb4(%rbx)
jmp 0x190e1
movq 0x36f56(%rip), %rbx     # 0x4ffe8
leaq 0x257be(%rip), %rsi     # 0x3e857
movl $0x26, %edx
movq %rbx, %rdi
callq 0x64a0
leaq 0x257d1(%rip), %rsi     # 0x3e87e
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_O3/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, %r15
movq (%rsi), %r12
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x1984e
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x1989f
movq %rbx, %rax
orq %r14, %rax
js 0x1991b
testq %r14, %r14
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x19882
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rbx
cmpq %r14, %rax
jl 0x1993a
movq %rbx, %rsi
imulq %r14, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x186e2
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
cmpq %r14, %rcx
jne 0x198fc
cmpq %rbx, %rax
jne 0x198fc
movq (%r15), %rax
imulq %r14, %rbx
movq %rbx, %rcx
shrq $0x3f, %rcx
addq %rbx, %rcx
andq $-0x2, %rcx
cmpq $0x2, %rbx
jl 0x198d8
xorl %edx, %edx
movaps (%r12,%rdx,8), %xmm0
movaps %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x198c6
cmpq %rbx, %rcx
jge 0x198f0
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x198dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x24e44(%rip), %rdi     # 0x3e747
leaq 0x29046(%rip), %rsi     # 0x42950
leaq 0x2507d(%rip), %rcx     # 0x3e98e
movl $0x2eb, %edx            # imm = 0x2EB
callq 0x62b0
leaq 0x24abd(%rip), %rdi     # 0x3e3df
leaq 0x28fd1(%rip), %rsi     # 0x428fa
leaq 0x24c3e(%rip), %rcx     # 0x3e56e
movl $0x11d, %edx            # imm = 0x11D
callq 0x62b0
movl $0x8, %edi
callq 0x61d0
movq 0x3661d(%rip), %rcx     # 0x4ff68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x36647(%rip), %rsi     # 0x4ffa0
movq 0x365f0(%rip), %rdx     # 0x4ff50
movq %rax, %rdi
callq 0x66c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movq %r13, (%rsi)
movq %rax, 0x8(%rsi)
leaq 0x20(%rsp), %rbp
movq %r12, (%rbp)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
movl $0x1, %ecx
movq %rbp, %rdi
callq 0x1b38a
movq (%rbp), %rax
movq -0x10(%rbp), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%rbp)
imulq -0x8(%rbp), %rax
movq %rax, 0x10(%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 0x1aafa
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdi
movq 0x10(%rdi), %rdx
cmpq %rdx, 0x8(%rbx)
je 0x1e60b
testq %rdx, %rdx
js 0x1e61e
movl $0x1, %ecx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1863a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e63e
leaq 0x1fdba(%rip), %rdi     # 0x3e3df
leaq 0x242ce(%rip), %rsi     # 0x428fa
leaq 0x2009b(%rip), %rcx     # 0x3e6ce
movl $0x11d, %edx            # imm = 0x11D
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e842
movq %rdi, %rbx
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x1e7d9
xorl %r14d, %r14d
jmp 0x1e816
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15           # imm = 0x4000
ja 0x1e800
movq %rsp, %r14
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r14
movq %r14, %rsp
movq %r14, %rcx
jmp 0x1e816
callq 0x6520
movq %rax, %r14
testb $0xf, %r14b
jne 0x1e870
movq %r14, %rcx
testq %r14, %r14
je 0x1e842
movq 0x10(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1e8ac
cmpq $0x4001, %r15           # imm = 0x4001
jb 0x1e837
movq %r14, %rdi
callq 0x64d0
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x61d0
movq 0x31715(%rip), %rcx     # 0x4ff68
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x3173f(%rip), %rsi     # 0x4ffa0
movq 0x316e8(%rip), %rdx     # 0x4ff50
movq %rax, %rdi
callq 0x66c0
leaq 0x1f742(%rip), %rdi     # 0x3dfb9
leaq 0x240a9(%rip), %rsi     # 0x42927
leaq 0x1f7ef(%rip), %rcx     # 0x3e074
movl $0xb8, %edx
callq 0x62b0
movq %rax, %rbx
cmpq $0x4001, %r15           # imm = 0x4001
jb 0x1e8a3
movq %r14, %rdi
callq 0x64d0
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdx
movq 0x18(%rdi), %rcx
cmpq $0x3, %rsi
jae 0x20027
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
retq
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rdx), %xmm0
movupd (%rcx), %xmm1
mulpd %xmm0, %xmm1
cmpq $0x4, %rax
jl 0x200b8
andq $-0x4, %r8
movupd 0x10(%rdx), %xmm2
movupd 0x10(%rcx), %xmm0
mulpd %xmm2, %xmm0
cmpq $0x8, %rax
jb 0x20093
movl $0x4, %edi
movupd (%rdx,%rdi,8), %xmm2
movupd 0x10(%rdx,%rdi,8), %xmm3
movupd (%rcx,%rdi,8), %xmm4
mulpd %xmm2, %xmm4
addpd %xmm4, %xmm1
movupd 0x10(%rcx,%rdi,8), %xmm2
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm0
addq $0x4, %rdi
cmpq %r8, %rdi
jl 0x20064
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %r8, %rsi
jle 0x200b8
movupd (%rdx,%r8,8), %xmm0
movupd (%rcx,%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 0x200df
movsd (%rdx,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x200c9
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30157(%rip), %rdx     # 0x50548
leaq 0x30148(%rip), %r14     # 0x50540
leaq 0x224ee(%rip), %rcx     # 0x428ed
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1d0f0(%rip), %rsi     # 0x3d511
movq %r14, %rdi
callq 0x20621
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20724
movq %r14, %rdi
movl $0x64, %esi
callq 0x207f6
leaq 0x8(%rsp), %rdi
callq 0x209d4
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209d4
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d363(%rip), %r15     # 0x4ff98
leaq 0x11c59(%rip), %rsi     # 0x44895
movl $0x8, %edx
movq %r15, %rdi
callq 0x64a0
movl 0x80(%r14), %esi
movq %r15, %rdi
callq 0x66e0
movq %rax, %r12
leaq 0x11c3c(%rip), %rsi     # 0x4489e
movl $0x7, %edx
movq %rax, %rdi
callq 0x64a0
xorl %edx, %edx
cmpl $0x1, 0x80(%r14)
leaq 0x126ef(%rip), %rax     # 0x4536f
leaq 0xaa22(%rip), %rsi      # 0x3d6a9
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 0x11bde(%rip), %rsi     # 0x448a6
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 0x39270
movl 0x80(%r14), %ebp
movq %r14, %rdi
callq 0x38ab2
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %ecx
callq 0x32e5c
movq %r14, %rdi
callq 0x38b40
movq %rbx, %rdi
movl %eax, %esi
callq 0x3335a
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32d6e
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32d89
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32da4
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 0x209d4
jmp 0x32dc7
movq %rax, %r14
movq %rsp, %rdi
callq 0x20e64
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x342e6
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq %r15, %rax
subq %r12, %rax
je 0x33c5d
sarq $0x3, %rax
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
leaq 0x1(%rdx), %rcx
andq $-0x2, %rcx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x9906(%rip), %xmm1     # 0x3d4c0
xorl %edx, %edx
movdqa 0x990c(%rip), %xmm2     # 0x3d4d0
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xec4c(%rip), %xmm4     # 0x42820
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x33c0a
movq %rdx, (%r12,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x33c22
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%r12,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rcx
jne 0x33bd4
cmpq %r12, %r15
je 0x33c5d
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x34373
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3443e
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 0x33c83
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6460
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x354ad
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 0xf686(%rip), %rsi      # 0x44a23
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 0xf660(%rip), %rsi      # 0x44a57
movl $0x2, %edx
movq %r14, %rdi
callq 0x64a0
movq 0xc8(%rbx), %rsi
movq %rsp, %rdi
callq 0x124d6
movq (%rsp), %r15
testq %r15, %r15
je 0x35434
movq %r15, %rdi
callq 0x61a0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x64a0
jmp 0x3544d
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 0x35491
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
leaq 0x20(%rsp), %rdi
callq 0x6060
movq %rbx, %rdi
callq 0x354f2
leaq 0x20(%rsp), %rdi
callq 0x60c0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
jmp 0x354dc
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x354df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6460
jmp 0x354df
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x356c8
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 0xf51f(%rip), %rsi      # 0x44a5a
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 0x356b4
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 0x3559f
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 0x356db
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::print(std::ostream&) const
void Sampler<ModelType>::print(std::ostream& out) const
{
	out<<save_to_disk<<' ';
	out<<num_threads<<' ';
	out<<compression<<' ';

	out<<options<<' ';

	for(const auto& p: particles)
		p.print(out);

	for(const auto& l: log_likelihoods)
		l.print(out);

	for(const auto& l: level_assignments)
		out<<l<<' ';

	for(const auto& l: levels)
		l.print(out);

	out<<count_saves<<' ';
	out<<count_mcmc_steps<<' ';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %esi
movq %rbx, %rdi
callq 0x6670
movb $0x20, %bpl
leaq 0x2(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0x3(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movsd 0x30(%r14), %xmm0
movq %rbx, %rdi
callq 0x6630
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
leaq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x398cf
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq 0xc8(%r14), %r15
movq 0xd0(%r14), %r12
cmpq %r12, %r15
je 0x35a9c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11ee2
addq $0x510, %r15            # imm = 0x510
jmp 0x35a83
movq 0xe0(%r14), %r15
movq 0xe8(%r14), %r12
cmpq %r12, %r15
je 0x35ac0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x39096
addq $0x10, %r15
jmp 0x35aaa
movq 0xf8(%r14), %r12
movq 0x100(%r14), %r13
cmpq %r13, %r12
je 0x35b02
leaq 0x1(%rsp), %r15
movl (%r12), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, 0x1(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x64a0
addq $0x4, %r12
cmpq %r13, %r12
jne 0x35ad8
movq 0x630(%r14), %r15
movq 0x638(%r14), %r12
cmpq %r12, %r15
je 0x35b26
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38eae
addq $0x38, %r15
jmp 0x35b10
movl 0x690(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, %bpl
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq 0x698(%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::mcmc_thread(unsigned int)
void Sampler<ModelType>::mcmc_thread(unsigned int thread)
{
	// Reference to the RNG for this thread
	RNG& rng = rngs[thread];

	// Reference to this thread's copy of levels
	std::vector<Level>& _levels = copies_of_levels[thread];

	// First particle belonging to this thread
	const int start_index = thread*options.num_particles;

	// Do some MCMC
	int which;
	for(unsigned int i=0; i<options.thread_steps; ++i)
	{
		which = start_index + rng.rand_int(options.num_particles);

		if(rng.rand() <= 0.5)
		{
			update_particle(thread, which);
			update_level_assignment(thread, which);
		}
		else
		{
			update_level_assignment(thread, which);
			update_particle(thread, which);
		}
		if(!enough_levels(_levels) &&
				_levels.back().get_log_likelihood() < log_likelihoods[which])
			above[thread].push_back(log_likelihoods[which]);
	}
}

// Assembly:
cmpl $0x0, 0x44(%rdi)
je 0x35de7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
imulq $0x9f8, %rax, %r15      # imm = 0x9F8
addq 0x678(%rdi), %r15
leaq (%rax,%rax,2), %rax
movq %rax, 0x10(%rsp)
leaq (,%rax,8), %rax
addq 0x648(%rdi), %rax
movq %rax, 0x8(%rsp)
movl 0x38(%rdi), %eax
imull %esi, %eax
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
movl 0x38(%r14), %esi
movq %r15, %rdi
callq 0x39bf8
movl %eax, %ebp
addl 0x4(%rsp), %ebp
movq %r15, %rdi
callq 0x39a4e
movsd 0x746f(%rip), %xmm1     # 0x3d198
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
ucomisd %xmm0, %xmm1
jae 0x35d49
callq 0x36434
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x36258
jmp 0x35d5a
callq 0x36258
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x36434
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x36646
testb %al, %al
jne 0x35dcc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $-0x38, %rdi
movslq %ebp, %r13
shlq $0x4, %r13
movq 0xe0(%r14), %rsi
addq %r13, %rsi
callq 0x3906e
testb %al, %al
je 0x35dcc
movq 0x6a0(%r14), %rax
addq 0xe0(%r14), %r13
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x35dc4
movupd (%r13), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x35dcc
movq %r13, %rdx
callq 0x37498
incl %r12d
cmpl 0x44(%r14), %r12d
jb 0x35d07
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::enough_levels(std::vector<DNest4::Level, std::allocator<DNest4::Level>> const&) const
bool Sampler<ModelType>::enough_levels(const std::vector<Level>& l) const
{
    if(options.max_num_levels == 0)
    {
        // Check level spacing (in terms of log likelihood)
        // over last n levels
        int num_levels_to_check = static_cast<int>(30*sqrt(0.02*l.size()));
        if(num_levels_to_check < 30)
            return false;

        int k = l.size() - 1;
        double tot = 0.0;
        double max = -1E300;
        for(int i=0; i<num_levels_to_check; ++i)
        {
            double diff = l[k].get_log_likelihood().get_value()
                             - l[k-1].get_log_likelihood().get_value();
            tot += diff;
            if(diff > max)
                max = diff;
            --k;
        }
        if(tot / num_levels_to_check < 0.75 && max < 1.0)
            return true;
        else
            return false;
    }

    // Just compare with the value from OPTIONS
    return (l.size() >= options.max_num_levels);   
}

// Assembly:
movl 0x48(%rdi), %eax
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rcx
testq %rax, %rax
je 0x36672
cmpq %rax, %rcx
setae %al
jmp 0x36745
pushq %rbx
movq %rsi, %rbx
movq %rcx, %xmm1
punpckldq 0x698d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6995(%rip), %xmm1     # 0x3d020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xc1a1(%rip), %xmm0     # 0x42840
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x366af
sqrtsd %xmm0, %xmm0
jmp 0x366b4
callq 0x63b0
mulsd 0xc18c(%rip), %xmm0     # 0x42848
cvttsd2si %xmm0, %eax
cmpl $0x1e, %eax
jge 0x366c9
xorl %eax, %eax
jmp 0x36744
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xb6db6db7, %edx, %edx # imm = 0xB6DB6DB7
decl %edx
xorpd %xmm0, %xmm0
movsd 0x6aed(%rip), %xmm1     # 0x3d1d8
movl %eax, %esi
movapd %xmm1, %xmm2
movslq %edx, %rdx
imulq $0x38, %rdx, %rdi
movsd (%rcx,%rdi), %xmm1
decl %edx
movslq %edx, %rdi
imulq $0x38, %rdi, %rdi
subsd (%rcx,%rdi), %xmm1
addsd %xmm1, %xmm0
maxsd %xmm2, %xmm1
decl %esi
jne 0x366ed
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm0
movsd 0x6906(%rip), %xmm2     # 0x3d030
cmpltpd %xmm2, %xmm1
movsd 0x6fb9(%rip), %xmm2     # 0x3d6f0
cmpltpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
popq %rbx
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::log_push(unsigned int) const
double Sampler<ModelType>::log_push(unsigned int which_level) const
{
	// Reference to this thread's copy of levels
	assert(which_level < levels.size());
	if(enough_levels(levels))
		return 0.0;

	int i = which_level - (static_cast<int>(levels.size()) - 1);
	return static_cast<double>(i)/options.lambda;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq 0x638(%rdi), %rcx
subq 0x630(%rdi), %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x37478
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x630(%rdi), %rsi
callq 0x36646
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x37470
movq 0x638(%rbx), %rax
subq 0x630(%rbx), %rax
shrq $0x3, %rax
imull $0x49249249, %eax, %eax # imm = 0x49249249
addl %r14d, %eax
incl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x50(%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd632(%rip), %rdi      # 0x44ab1
leaq 0xd45f(%rip), %rsi      # 0x448e5
leaq 0xd640(%rip), %rcx      # 0x44acd
movl $0x1be, %edx            # imm = 0x1BE
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/Barrier.cpp
// Function: DNest4::Barrier::wait()
void Barrier::wait()
{
	unsigned int gen = generation;
	std::unique_lock<std::mutex> lock{the_mutex};
	if((--count) == 0)
	{
		generation++;
		count = threshold;
		cond.notify_all();
	}
	else
		cond.wait(lock, [this, gen] { return gen != generation; });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x60(%rdi), %ebp
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x38388
movb $0x1, 0x8(%r14)
decl 0x5c(%rbx)
je 0x38347
cmpl %ebp, 0x60(%rbx)
jne 0x3835c
leaq 0x28(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6110
cmpl %ebp, 0x60(%rbx)
je 0x38335
jmp 0x3835c
incl 0x60(%rbx)
movl 0x58(%rbx), %eax
movl %eax, 0x5c(%rbx)
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x66a0
leaq 0x8(%rsp), %rdi
callq 0x38372
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/CommandLineOptions.cpp
// Function: DNest4::CommandLineOptions::print_help() const
void CommandLineOptions::print_help() const
{
	std::cout<<"DNest4 Command Line Options: "<<std::endl;
	std::cout<<"-h: display this message"<<std::endl;
	std::cout<<"-o <filename>: load DNest4 options from the specified file. Default=OPTIONS"<<std::endl;
	std::cout<<"-s <seed>: seed the random number generator with the specified value. If unspecified, the system time is used."<<std::endl;
	std::cout<<"-d <filename>: Load data from the specified file, if required."<<std::endl;
	std::cout<<"-c <value>: Specify a compression value (between levels) other than e."<<std::endl;
	std::cout<<"-t <num_threads>: run on the specified number of threads. Default=1."<<std::endl;
	std::cout<<"-f <filename>: a custom configuration file for adding problem specific options if required."<<std::endl;
	exit(0);
}

// Assembly:
pushq %rbx
movq 0x175a6(%rip), %rbx     # 0x4ff98
leaq 0xc355(%rip), %rsi      # 0x44d4e
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc35c(%rip), %rsi      # 0x44d6c
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc35e(%rip), %rsi      # 0x44d85
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc393(%rip), %rsi      # 0x44dd1
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc3eb(%rip), %rsi      # 0x44e40
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc413(%rip), %rsi      # 0x44e7f
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc443(%rip), %rsi      # 0x44ec6
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc471(%rip), %rsi      # 0x44f0b
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
xorl %edi, %edi
callq 0x64e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/CommandLineOptions.cpp
// Function: DNest4::CommandLineOptions::get_compression_double() const
double CommandLineOptions::get_compression_double() const
{
	double val;
	std::stringstream s(compression);
	s>>val;
	return val;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
leaq 0x60(%rdi), %rsi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movl $0x18, %edx
callq 0x6620
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x62c0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x17438(%rip), %rsi     # 0x4ff28
leaq 0x18(%rsp), %rdi
callq 0x6360
leaq 0x98(%rsp), %rdi
callq 0x6130
movsd 0x8(%rsp), %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
movq 0x17408(%rip), %rsi     # 0x4ff28
leaq 0x18(%rsp), %rdi
callq 0x6360
leaq 0x98(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/CommandLineOptions.cpp
// Function: DNest4::CommandLineOptions::get_seed_uint() const
unsigned int CommandLineOptions::get_seed_uint() const
{
	if(seed.compare("time") == 0)
		return static_cast<unsigned int>(time(0));

	unsigned int i;
	std::stringstream s(seed);
	s>>i;
	return i;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
addq $0x20, %rbx
leaq 0xc14c(%rip), %rsi      # 0x44ca4
movq %rbx, %rdi
callq 0x6100
testl %eax, %eax
je 0x38baa
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x6620
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x6700
movl 0xc(%rsp), %ebx
movq 0x17397(%rip), %rsi     # 0x4ff28
leaq 0x10(%rsp), %rdi
callq 0x6360
leaq 0x90(%rsp), %rdi
callq 0x6130
jmp 0x38bb4
xorl %edi, %edi
callq 0x6410
movq %rax, %rbx
movl %ebx, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x1735d(%rip), %rsi     # 0x4ff28
leaq 0x10(%rsp), %rdi
callq 0x6360
leaq 0x90(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6710