LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/CoreEvaluators.h
// Function: double vector[2] Eigen::internal::binary_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const> const>, Eigen::internal::IndexBased, Eigen::internal::IndexBased, double, double>::packet<0, double vector[2]>(long, long) const
EIGEN_STRONG_INLINE
  PacketType packet(Index row, Index col) const
  {
    if (IsRowMajor)
      return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
    else
      return ploadt<PacketType, LoadMode>(m_d.data + row + col * m_d.outerStride());
  }

// Assembly:
movq (%rdi), %rax
movupd (%rax,%rsi,8), %xmm1
shlq $0x3, %rsi
addq 0x8(%rdi), %rsi
imulq 0x18(%rdi), %rdx
movupd (%rsi,%rdx,8), %xmm2
movupd 0x20(%rdi), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
addpd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
pushq $0x4
popq %r8
movq %rcx, %rax
cqto
idivq %r8
movq %rax, %rsi
pushq $0x2
popq %r9
movq %rcx, %rax
cqto
idivq %r9
leaq 0x1(%rcx), %r9
movq (%rdi), %rdx
movq 0x18(%rdi), %rdi
cmpq $0x3, %r9
jae 0x2098f
movsd (%rdx), %xmm0
mulsd (%rdi), %xmm0
pushq $0x1
popq %rax
cmpq %rcx, %rax
jge 0x20a2a
movsd (%rdx,%rax,8), %xmm1
mulsd (%rdi,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x20973
addq %rax, %rax
movupd (%rdx), %xmm0
movupd (%rdi), %xmm1
mulpd %xmm0, %xmm1
cmpq $0x4, %rcx
jl 0x20a06
shlq $0x2, %rsi
movupd 0x10(%rdx), %xmm2
movupd 0x10(%rdi), %xmm0
mulpd %xmm2, %xmm0
cmpq %rsi, %r8
jge 0x209eb
movupd (%rdx,%r8,8), %xmm2
movupd 0x10(%rdx,%r8,8), %xmm3
movupd (%rdi,%r8,8), %xmm4
mulpd %xmm2, %xmm4
movupd 0x10(%rdi,%r8,8), %xmm2
mulpd %xmm3, %xmm2
addpd %xmm4, %xmm1
addpd %xmm2, %xmm0
addq $0x4, %r8
jmp 0x209b6
addpd %xmm0, %xmm1
cmpq %rsi, %rax
jle 0x20a06
movupd (%rdx,%rsi,8), %xmm0
movupd (%rdi,%rsi,8), %xmm2
mulpd %xmm0, %xmm2
addpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq %rcx, %rax
jge 0x20a2a
movsd (%rdx,%rax,8), %xmm1
mulsd (%rdi,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x20a12
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x43908(%rip), %r14     # 0x646c0
leaq 0x2625e(%rip), %rsi     # 0x4701d
movq %r14, %rdi
callq 0x6770
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x1b708(%rip), %rsi     # 0x3c4e1
movq %r14, %rdi
callq 0x2100d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x210b6
pushq $0x64
popq %rsi
movq %r14, %rdi
callq 0x21102
leaq 0x8(%rsp), %rdi
callq 0x212c8
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212c8
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/ProductEvaluators.h
// Function: Eigen::internal::product_evaluator<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>, 6, Eigen::DenseShape, Eigen::DenseShape, double, double>::product_evaluator(Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0> const&)
explicit product_evaluator(const XprType& xpr)
    : m_result(xpr.rows(), xpr.cols())
  {
    ::new (static_cast<Base*>(this)) Base(m_result);
    
// FIXME shall we handle nested_eval here?,
// if so, then we must take care at removing the call to nested_eval in the specializations (e.g., in permutation_matrix_product, transposition_matrix_product, etc.)
//     typedef typename internal::nested_eval<Lhs,Rhs::ColsAtCompileTime>::type LhsNested;
//     typedef typename internal::nested_eval<Rhs,Lhs::RowsAtCompileTime>::type RhsNested;
//     typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
//     typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
//     
//     const LhsNested lhs(xpr.lhs());
//     const RhsNested rhs(xpr.rhs());
//   
//     generic_product_impl<LhsNestedCleaned, RhsNestedCleaned>::evalTo(m_result, lhs, rhs);

    generic_product_impl<Lhs, Rhs, LhsShape, RhsShape, ProductTag>::evalTo(m_result, xpr.lhs(), xpr.rhs());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, (%rdi)
leaq 0x8(%rdi), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2cc7c
movq %r15, (%r14)
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2cc46
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, 5, 5, 0, 5, 5>>, Eigen::internal::evaluator<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 5, 5, 0, 5, 5>>>, Eigen::internal::assign_op<double, double>, 0>, 3, 2>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, 5, 5, 0, 5, 5>>, Eigen::internal::evaluator<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 5, 5, 0, 5, 5>>>, Eigen::internal::assign_op<double, double>, 0>&)
void run(Kernel &kernel)
  {
    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
    typedef typename Kernel::PacketType PacketType;
    
    enum { size = DstXprType::SizeAtCompileTime,
           packetSize =unpacket_traits<PacketType>::size,
           alignedSize = (size/packetSize)*packetSize };

    copy_using_evaluator_innervec_CompleteUnrolling<Kernel, 0, alignedSize>::run(kernel);
    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize, size>::run(kernel);
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2e160
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rax), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0xc0(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30e49(%rip), %r15     # 0x63f98
leaq 0x185fc(%rip), %rsi     # 0x4b752
movq %r15, %rdi
callq 0x6430
movl 0x80(%r14), %esi
movq %rax, %rdi
callq 0x66b0
leaq 0x185e7(%rip), %rsi     # 0x4b75b
movq %rax, %rdi
callq 0x6430
cmpl $0x1, 0x80(%r14)
leaq 0x19074(%rip), %rcx     # 0x4c1ff
leaq 0x94bd(%rip), %rsi      # 0x3c64f
cmoveq %rcx, %rsi
movq %rax, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x185b6(%rip), %rsi     # 0x4b763
movq %r15, %rdi
callq 0x6430
leaq 0x60(%r14), %rsi
movq %r15, %rdi
callq 0x63f0
movq %rax, %rdi
callq 0x61c0
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x385d0
movl 0x80(%r14), %ebp
movq %r14, %rdi
callq 0x37f7c
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3327a
movq %r14, %rdi
callq 0x37fe0
movq %rbx, %rdi
movl %eax, %esi
callq 0x335e0
leaq 0x8(%rsp), %rdi
callq 0x2152e
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x212c8
jmp 0x33234
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2152e
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
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 0x34514
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq %rdi, %rax
sarq $0x3, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x33b43
movq %rcx, (%rdi,%rcx,8)
incq %rcx
jmp 0x33b35
movq %r14, %rdx
callq 0x3463b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x34592
movq %r14, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
cmpb $0x1, (%rdi)
jne 0x35392
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6490
leaq 0x88(%rbx), %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x6540
leaq 0x38(%rsp), %r14
leaq 0x165d7(%rip), %rsi     # 0x4b8e0
movq %r14, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x28(%rsp), %rdi
callq 0x6050
leaq 0x68(%rbx), %rsi
leaq 0x28(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x6540
leaq 0x165d9(%rip), %rsi     # 0x4b914
movq %r14, %rdi
callq 0x6430
movq %rax, %r14
movq 0xc8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1083a
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x8(%rsp), %rdi
callq 0x6798
leaq 0x28(%rsp), %rdi
callq 0x6050
movq %rbx, %rdi
callq 0x353c4
leaq 0x28(%rsp), %rdi
callq 0x60c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
jmp 0x353ae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6798
jmp 0x353b1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
cmpb $0x1, (%rdi)
jne 0x354fe
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6490
leaq 0xa8(%r14), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x6540
leaq 0x18(%rsp), %rbx
leaq 0x1650f(%rip), %rsi     # 0x4b917
movq %rbx, %rdi
callq 0x6430
movq %rbx, %rdi
callq 0x61c0
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x20(%rsp,%rax)
movq 0x630(%r14), %r15
movq 0x638(%r14), %r14
pushq $0x20
popq %rbp
cmpq %r14, %r15
je 0x354ea
movsd 0x10(%r15), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movsd (%r15), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movsd 0x8(%r15), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x28(%r15), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x30(%r15), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x18(%r15), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
callq 0x61c0
addq $0x38, %r15
jmp 0x3543b
leaq 0x8(%rsp), %rdi
callq 0x6050
leaq 0x8(%rsp), %rdi
callq 0x60c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3550e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %esi
movq %rbx, %rdi
callq 0x6650
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movsd 0x30(%r14), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
leaq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x38ac3
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movq 0xc8(%r14), %r15
movq 0xd0(%r14), %r12
cmpq %r12, %r15
je 0x3584f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1038a
addq $0x510, %r15            # imm = 0x510
jmp 0x35836
movq 0xe0(%r14), %r15
movq 0xe8(%r14), %r12
cmpq %r12, %r15
je 0x35873
movq %r15, %rdi
movq %rbx, %rsi
callq 0x38464
addq $0x10, %r15
jmp 0x3585d
movq 0xf8(%r14), %r15
movq 0x100(%r14), %r12
pushq $0x20
popq %rbp
cmpq %r12, %r15
je 0x358a4
movl (%r15), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
addq $0x4, %r15
jmp 0x35884
movq 0x630(%r14), %r15
movq 0x638(%r14), %r12
cmpq %r12, %r15
je 0x358c8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x382be
addq $0x38, %r15
jmp 0x358b2
movl 0x690(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movq 0x698(%r14), %rsi
movq %rbx, %rdi
callq 0x62e0
movq %rax, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6480
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
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
imulq $0x18, %rax, %rax
movq 0x648(%rdi), %rcx
movq %rax, 0x10(%rsp)
addq %rax, %rcx
movq %rcx, 0x8(%rsp)
movl 0x38(%rdi), %eax
imull %esi, %eax
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
cmpl 0x44(%r14), %r12d
jae 0x35b00
movl 0x38(%r14), %esi
movq %r15, %rdi
callq 0x38cc4
movl %eax, %ebp
addl 0x4(%rsp), %ebp
movq %r15, %rdi
callq 0x38b70
movsd 0x6724(%rip), %xmm1     # 0x3c198
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
ucomisd %xmm0, %xmm1
jae 0x35a94
callq 0x3608a
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x35ece
jmp 0x35aa5
callq 0x35ece
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x3608a
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x36288
testb %al, %al
jne 0x35af8
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 0x3843c
testb %al, %al
je 0x35af8
movq 0x6a0(%r14), %rdi
addq 0x10(%rsp), %rdi
addq 0xe0(%r14), %r13
movq %r13, %rsi
callq 0x35b10
incl %r12d
jmp 0x35a48
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl 0x48(%rdi), %ecx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x38
popq %r14
cqto
idivq %r14
testq %rcx, %rcx
je 0x362af
cmpq %rcx, %rax
setae %al
jmp 0x3637e
movq %rsi, %rbx
movq %rax, %xmm1
punpckldq 0x5d51(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5d59(%rip), %xmm1     # 0x3c020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x10c95(%rip), %xmm0    # 0x46f70
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x362eb
sqrtsd %xmm0, %xmm0
jmp 0x362f0
callq 0x63a0
mulsd 0x10c80(%rip), %xmm0    # 0x46f78
cvttsd2si %xmm0, %ecx
cmpl $0x1e, %ecx
jge 0x36305
xorl %eax, %eax
jmp 0x3637e
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r14
addl $-0x2, %eax
movsd 0x5eb9(%rip), %xmm1     # 0x3c1d8
xorpd %xmm0, %xmm0
movl %ecx, %edx
subl $0x1, %edx
jb 0x36354
leal 0x1(%rax), %edi
movslq %edi, %rdi
imulq $0x38, %rdi, %rdi
movsd (%rsi,%rdi), %xmm2
cltq
imulq $0x38, %rax, %rdi
subsd (%rsi,%rdi), %xmm2
addsd %xmm2, %xmm0
maxsd %xmm1, %xmm2
decl %eax
movapd %xmm2, %xmm1
jmp 0x36325
cvtsi2sd %ecx, %xmm2
divsd %xmm2, %xmm0
movsd 0x5ccc(%rip), %xmm2     # 0x3c030
cmpltpd %xmm2, %xmm1
movsd 0x6327(%rip), %xmm2     # 0x3c698
cmpltpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movl %esi, %ecx
movq 0x638(%rdi), %rax
subq 0x630(%rdi), %rax
pushq $0x38
popq %rsi
cqto
idivq %rsi
cmpq %rcx, %rax
jbe 0x36c07
movq %rdi, %rbx
leaq 0x630(%rdi), %rsi
callq 0x36288
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x36bff
movq 0x638(%rbx), %rax
subq 0x630(%rbx), %rax
pushq $-0x38
popq %rcx
cqto
idivq %rcx
addl %r14d, %eax
incl %eax
cvtsi2sd %eax, %xmm0
divsd 0x50(%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14d60(%rip), %rdi     # 0x4b96e
leaq 0x14b8d(%rip), %rsi     # 0x4b7a2
leaq 0x14d6e(%rip), %rcx     # 0x4b98a
movl $0x1be, %edx            # imm = 0x1BE
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/trends/../../DNest4/code/SamplerImpl.h
// Function: DNest4::Sampler<RVmodel>::save_particle()
void Sampler<ModelType>::save_particle()
{
	++count_saves;
    count_mcmc_steps_since_save = 0;

	if(!save_to_disk)
		return;

	if(count_saves % thin_print == 0)
		std::cout<<"# Saving particle to disk. N = "<<count_saves<<"."<<std::endl;

	// Output file
	std::fstream fout;

	int which = rngs[0].rand_int(particles.size());
	fout.open(options.sample_file, std::ios::out|std::ios::app);
	particles[which].print(fout);
	fout<<std::endl;
	fout.close();

	fout.open(options.sample_info_file, std::ios::out|std::ios::app);
	fout<<std::setprecision(12);

	fout<<level_assignments[which]<<' ';
	fout<<log_likelihoods[which].get_value()<<' ';
	fout<<log_likelihoods[which].get_tiebreaker()<<' ';
	fout<<which<<std::endl;
	fout.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl 0x690(%rdi), %eax
incl %eax
movl %eax, 0x690(%rdi)
andl $0x0, 0x694(%rdi)
cmpb $0x1, (%rdi)
jne 0x37189
movq %rdi, %rbx
xorl %edx, %edx
divl 0x4(%rdi)
testl %edx, %edx
jne 0x37067
movq 0x2cf62(%rip), %rdi     # 0x63f98
leaq 0x14a1d(%rip), %rsi     # 0x4ba5a
callq 0x6430
movl 0x690(%rbx), %esi
movq %rax, %rdi
callq 0x62f0
leaq 0x151a8(%rip), %rsi     # 0x4c1ff
movq %rax, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x8(%rsp), %rdi
callq 0x6490
movq 0x678(%rbx), %rdi
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
movl $0x510, %ecx            # imm = 0x510
cqto
idivq %rcx
movl %eax, %esi
callq 0x38cc4
movl %eax, %ebp
leaq 0x68(%rbx), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x11
popq %rdx
callq 0x6540
movslq %ebp, %r15
imulq $0x510, %r15, %rdi      # imm = 0x510
addq 0xc8(%rbx), %rdi
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x1038a
movq %r14, %rdi
callq 0x61c0
leaq 0x8(%rsp), %rdi
callq 0x6050
leaq 0x88(%rbx), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x11
popq %rdx
callq 0x6540
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movq $0xc, 0x20(%rsp,%rax)
movq 0xf8(%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0x62f0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x6480
movq 0xe0(%rbx), %rax
shlq $0x4, %r15
movsd (%rax,%r15), %xmm0
movq %r14, %rdi
callq 0x6610
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x6480
movq 0xe0(%rbx), %rax
movsd 0x8(%rax,%r15), %xmm0
movq %r14, %rdi
callq 0x6610
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x6480
movq %r14, %rdi
movl %ebp, %esi
callq 0x66b0
movq %rax, %rdi
callq 0x61c0
leaq 0x8(%rsp), %rdi
callq 0x6050
leaq 0x8(%rsp), %rdi
callq 0x60c0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
movq %rbx, %rsi
callq 0x37aa6
decl 0x5c(%rbx)
je 0x37a7b
leaq 0x28(%rbx), %r14
leaq 0x8(%rsp), %r15
cmpl %ebp, 0x60(%rbx)
jne 0x37a90
movq %r14, %rdi
movq %r15, %rsi
callq 0x6120
jmp 0x37a69
incl 0x60(%rbx)
movl 0x58(%rbx), %eax
movl %eax, 0x5c(%rbx)
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x6670
leaq 0x8(%rsp), %rdi
callq 0x37abc
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c0dc(%rip), %rbx     # 0x63f98
leaq 0x13d47(%rip), %rsi     # 0x4bc0a
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13d4e(%rip), %rsi     # 0x4bc28
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13d50(%rip), %rsi     # 0x4bc41
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13d85(%rip), %rsi     # 0x4bc8d
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13ddd(%rip), %rsi     # 0x4bcfc
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13e05(%rip), %rsi     # 0x4bd3b
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13e35(%rip), %rsi     # 0x4bd82
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
leaq 0x13e63(%rip), %rsi     # 0x4bdc7
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
xorl %edi, %edi
callq 0x64b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13b68(%rip), %rsi     # 0x4bb60
movq %rbx, %rdi
callq 0x6110
testl %eax, %eax
je 0x38034
leaq 0x10(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6600
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x66d0
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %rdi
callq 0x6360
jmp 0x3803e
xorl %edi, %edi
callq 0x6410
movq %rax, %rbx
movl %ebx, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6360
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Level.cpp
// Function: DNest4::Level::read(std::istream&)
void Level::read(istream& in)
{
	log_likelihood.read(in);
	in>>log_X;
	in>>visits;
	in>>exceeds;
	in>>accepts;
	in>>tries;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x384a0
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x62c0
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x64d0
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x64d0
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x64d0
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64d0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::LikelihoodType(double, double)
LikelihoodType::LikelihoodType(double value, double tiebreaker)
{
	assert(tiebreaker > 0. && tiebreaker < 1.);
    if(std::isinf(value) || std::isnan(value))
        value = -1E300;
    this->value = value;
    this->tiebreaker = tiebreaker;
}

// Assembly:
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jbe 0x383eb
movsd 0x3c76(%rip), %xmm2     # 0x3c030
ucomisd %xmm1, %xmm2
jbe 0x383eb
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x383e1
movq 0x3df7(%rip), %xmm0     # 0x3c1d8
movq %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
retq
pushq %rax
leaq 0x13aad(%rip), %rdi     # 0x4bea0
leaq 0x13ac9(%rip), %rsi     # 0x4bec3
leaq 0x13ad5(%rip), %rcx     # 0x4bed6
pushq $0x13
popq %rdx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/LikelihoodType.cpp
// Function: DNest4::LikelihoodType::operator<(DNest4::LikelihoodType const&) const
bool LikelihoodType::operator < (const LikelihoodType& other) const
{
	if(value < other.value)
		return true;
	if((value == other.value) &&
		(tiebreaker < other.tiebreaker))
		return true;
	return false;
}

// Assembly:
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
movb $0x1, %al
ucomisd %xmm0, %xmm1
ja 0x38462
ucomisd %xmm1, %xmm0
jne 0x38460
jp 0x38460
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdi), %xmm0
ja 0x38462
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Options.cpp
// Function: DNest4::Options::print(std::ostream&) const
void Options::print(std::ostream& out) const
{
	out<<num_particles<<' ';
	out<<new_level_interval<<' ';
	out<<save_interval<<' ';
	out<<thread_steps<<' ';
	out<<max_num_levels<<' ';
	out<<lambda<<' ';
	out<<beta<<' ';
	out<<max_num_saves<<' ';

	out<<sample_file<<' ';
	out<<sample_info_file<<' ';
	out<<levels_file<<' ';
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x62f0
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movsd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movsd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x63f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x63f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
addq $0x70, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63f0
movq %rax, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x6480
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Options.cpp
// Function: DNest4::Options::read(std::istream&)
void Options::read(std::istream& in)
{
	in>>num_particles;
	in>>new_level_interval;
	in>>save_interval;
	in>>thread_steps;
	in>>max_num_levels;
	in>>lambda;
	in>>beta;
	in>>max_num_saves;

	in>>sample_file;
	in>>sample_info_file;
	in>>levels_file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x66d0
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x66d0
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x66d0
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x66d0
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x66d0
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x62c0
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x62c0
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x66d0
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x64e0
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x64e0
addq $0x70, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64e0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::mod(int, int)
int mod(int y, int x)
{
    assert(x > 0);
    if(y >= 0)
        return y - (y/x)*x;
    else
        return (x-1) - DNest4::mod(-y-1, x);
}

// Assembly:
pushq %rbx
testl %esi, %esi
jle 0x39198
movl %esi, %ebx
testl %edi, %edi
js 0x39189
movl %edi, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
jmp 0x39196
notl %edi
movl %ebx, %esi
callq 0x39174
notl %eax
addl %ebx, %eax
popq %rbx
retq
leaq 0x12fb5(%rip), %rdi     # 0x4c154
leaq 0x12f81(%rip), %rsi     # 0x4c127
leaq 0x12fad(%rip), %rcx     # 0x4c15a
pushq $0x13
popq %rdx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logsumexp(double*, int)
double logsumexp(double* logv, int n)
{
    assert(n > 1);
    double max = logv[0];
    for(int i=1; i<n; i++)
        if(logv[i] > max)
            max = logv[i];
    double answer = 0;
    // log(sum(exp(logf))   = log(sum(exp(logf - max(logf) + max(logf)))
    //          = max(logf) + log(sum(exp(logf - max(logf)))
    for(int i=0; i<n; i++)
        answer += exp(logv[i] - max);
    answer = max + log(answer);
    return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %esi
jle 0x39240
movq %rdi, %rbx
movsd (%rdi), %xmm1
movl %esi, %r14d
pushq $0x1
popq %rax
cmpq %rax, %r14
je 0x391e7
movsd (%rbx,%rax,8), %xmm0
maxsd %xmm1, %xmm0
incq %rax
movapd %xmm0, %xmm1
jmp 0x391d0
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
cmpq %r15, %r14
je 0x3922b
movsd %xmm0, (%rsp)
movsd (%rbx,%r15,8), %xmm0
subsd %xmm1, %xmm0
callq 0x6700
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, (%rsp)
movsd (%rsp), %xmm0
incq %r15
jmp 0x391f4
callq 0x63b0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12f2d(%rip), %rdi     # 0x4c174
leaq 0x12ed9(%rip), %rsi     # 0x4c127
leaq 0x12f25(%rip), %rcx     # 0x4c17a
pushq $0x1c
popq %rdx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logsumexp(std::vector<double, std::allocator<double>> const&)
double logsumexp(const std::vector<double>& logv)
{
    int n = static_cast<int>(logv.size());
    //if(n<=1)
    //  cout<<"Warning in logsumexp"<<endl;
    double max = *max_element(logv.begin(), logv.end());
    double answer = 0;
    // log(sum(exp(logf))   = log(sum(exp(logf - max(logf) + max(logf)))
    //          = max(logf) + log(sum(exp(logf - max(logf)))
    for(int i=0; i<n; i++)
        answer += exp(logv[i] - max);
    answer = max + log(answer);
    return answer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %rsi, %r14
subq %rdi, %r14
shrq $0x3, %r14
callq 0xb5cb
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
xorpd %xmm0, %xmm0
cmpq %r15, %r14
je 0x392cd
movq (%rbx), %rax
movsd %xmm0, (%rsp)
movsd (%rax,%r15,8), %xmm0
subsd 0x8(%rsp), %xmm0
callq 0x6700
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r15
jmp 0x39297
callq 0x63b0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::logdiffexp(double, double)
double logdiffexp(double a, double b)
{
    assert(a > b);
    double biggest = a;
    a -= biggest;
    b -= biggest;
    return log(exp(a) - exp(b)) + biggest;
}

// Assembly:
subq $0x18, %rsp
ucomisd %xmm1, %xmm0
jbe 0x39353
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm0
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
callq 0x6700
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x6700
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x63b0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0x12e48(%rip), %rdi     # 0x4c1a2
leaq 0x12dc6(%rip), %rsi     # 0x4c127
leaq 0x12e40(%rip), %rcx     # 0x4c1a8
pushq $0x41
popq %rdx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::r8poly_value(int, double*, double)
double r8poly_value(int n, double a[], double x)
{
    int i;
    double value = 0.0;
    for (i=n-1; 0<=i; i--)
        value = value * x + a[i];
    return value;
}

// Assembly:
movl %edi, %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x39597
mulsd %xmm0, %xmm1
addsd -0x8(%rsi,%rax,8), %xmm1
decq %rax
jmp 0x39584
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Utils.cpp
// Function: DNest4::perturb_ns(std::vector<double, std::allocator<double>>&, DNest4::RNG&)
double perturb_ns(std::vector<double>& ns, RNG& rng)
{
    double logH = 0.0;

    if(rng.rand() <= 0.5)
    {
        // Perturb a single n
        int k = rng.rand_int(ns.size());
        logH -= -0.5*pow(ns[k], 2);
        ns[k] += rng.randh();
        logH += -0.5*pow(ns[k], 2);
    }
    else
    {
        // Resample several ns
        int reps = static_cast<int>(pow(ns.size(), rng.rand()));
        for(int i=0; i<reps; ++i)
        {
            int k = rng.rand_int(ns.size());
            ns[k] = rng.randn();
        }
    }
    return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x38b70
movq 0x8(%rbx), %rsi
movsd 0x2bd8(%rip), %xmm1     # 0x3c198
subq (%rbx), %rsi
ucomisd %xmm0, %xmm1
jae 0x3964e
sarq $0x3, %rsi
movq %rsi, %xmm0
punpckldq 0x2a32(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2a3a(%rip), %xmm0     # 0x3c020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x38b70
movapd %xmm0, %xmm1
movapd (%rsp), %xmm0
callq 0x66c0
cvttsd2si %xmm0, %eax
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
subl $0x1, %r15d
jb 0x396a9
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x38cc4
movl %eax, %ebp
movq %r14, %rdi
callq 0x38b80
movslq %ebp, %rax
movq (%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
jmp 0x3961a
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x38cc4
movslq %eax, %r15
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x2b26(%rip), %xmm0     # 0x3c198
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x38bee
movq (%rbx), %rax
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r15,8)
mulsd %xmm0, %xmm0
mulsd 0x2996(%rip), %xmm0     # 0x3c038
addsd (%rsp), %xmm0
jmp 0x396ad
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Distributions/Cauchy.cpp
// Function: DNest4::TruncatedCauchy::TruncatedCauchy(double, double, double, double)
TruncatedCauchy::TruncatedCauchy(double center, double width,
                                 double lower, double upper)
:center(center), width(width)
,lower(lower), upper(upper)
{
    if(width <= 0.0)
        throw std::domain_error("TruncatedCauchy distribution must have positive width.");
    if(lower >= upper)
        throw std::domain_error("TruncatedCauchy: lower bound should be less than upper bound.");
    // the original, untruncated, Cauchy distribution
    unC = Cauchy(center, width);
    c = unC.cdf(upper) - unC.cdf(lower);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x2a13c(%rip), %rax     # 0x63998
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
leaq 0x2a0de(%rip), %rax     # 0x63958
movq %rax, 0x28(%rdi)
xorpd %xmm4, %xmm4
movhpd 0x27a6(%rip), %xmm4     # xmm4 = xmm4[0],mem[0]
movupd %xmm4, 0x30(%rdi)
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jae 0x39906
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, (%rsp)
ucomisd %xmm3, %xmm2
jae 0x39922
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x30(%rdi), %r12
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x396b8
movups 0x8(%r15), %xmm0
movups %xmm0, (%r12)
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x39726
movsd %xmm0, (%rsp)
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x39726
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x128e9(%rip), %rsi     # 0x4c201
movq %rax, %rdi
callq 0x6280
jmp 0x3993c
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x12904(%rip), %rsi     # 0x4c238
movq %rax, %rdi
callq 0x6280
movq 0x2a5f5(%rip), %rsi     # 0x63f38
movq 0x2a616(%rip), %rdx     # 0x63f60
movq %rbx, %rdi
callq 0x6690
jmp 0x39954
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Distributions/Cauchy.cpp
// Function: DNest4::TruncatedCauchy::cdf_inverse(double) const
double TruncatedCauchy::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    double xx = unC.cdf(lower) + x * c;
    return unC.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x39a10
ucomisd 0x2658(%rip), %xmm1     # 0x3c030
ja 0x39a10
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movsd 0x18(%rdi), %xmm0
movq %r14, %rdi
movsd %xmm1, (%rsp)
callq 0x39726
movsd (%rsp), %xmm1
mulsd 0x40(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39748
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x261e(%rip), %rsi      # 0x3c040
movq %rax, %rdi
callq 0x6280
movq 0x2a507(%rip), %rsi     # 0x63f38
movq 0x2a528(%rip), %rdx     # 0x63f60
movq %rbx, %rdi
callq 0x6690
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Distributions/ContinuousDistribution.cpp
// Function: DNest4::ContinuousDistribution::perturb(double&, DNest4::RNG&) const
double ContinuousDistribution::perturb(double& x, RNG& rng) const
{
    x = cdf(x);
    x += rng.randh();
    wrap(x, 0.0, 1.0);
    x = cdf_inverse(x);

    return 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movsd (%rsi), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, (%rbx)
movq %r14, %rdi
callq 0x38bee
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x2446(%rip), %xmm1     # 0x3c030
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x39141
movsd (%rbx), %xmm0
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movsd %xmm0, (%rbx)
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Distributions/Exponential.cpp
// Function: DNest4::TruncatedExponential::TruncatedExponential(double, double, double)
TruncatedExponential::TruncatedExponential(double scale, double lower, double upper)
:scale(scale)
,lower(lower), upper(upper)
{
    if(scale <= 0.0)
        throw std::domain_error("TruncatedExponential distribution must have positive scale.");
    if(lower >= upper)
        throw std::domain_error("TruncatedExponential: lower bound should be less than upper bound.");
    // the original, untruncated, Exponential distribution
    unE = Exponential(scale);
    c = unE.cdf(upper) - unE.cdf(lower);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x29c60(%rip), %rax     # 0x63a48
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
leaq 0x29c07(%rip), %rax     # 0x63a08
movq %rax, 0x20(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x39e85
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
ucomisd %xmm2, %xmm1
jae 0x39ea1
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x39c10
movsd 0x8(%r15), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x39cd6
movsd %xmm0, (%rsp)
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x39cd6
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x12427(%rip), %rsi     # 0x4c2be
movq %rax, %rdi
callq 0x6280
jmp 0x39ebb
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x12447(%rip), %rsi     # 0x4c2fa
movq %rax, %rdi
callq 0x6280
movq 0x2a076(%rip), %rsi     # 0x63f38
movq 0x2a097(%rip), %rdx     # 0x63f60
movq %rbx, %rdi
callq 0x6690
jmp 0x39ed3
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/Distributions/Exponential.cpp
// Function: DNest4::TruncatedExponential::cdf_inverse(double) const
double TruncatedExponential::cdf_inverse(double x) const
{
    if(x < 0.0 || x > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    double xx = unE.cdf(lower) + x * c;
    return unE.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x39fec
ucomisd 0x207c(%rip), %xmm1     # 0x3c030
ja 0x39fec
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movsd 0x10(%rdi), %xmm0
movq %r14, %rdi
movsd %xmm1, (%rsp)
callq 0x39cd6
movsd (%rsp), %xmm1
mulsd 0x30(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x39cfc
pushq $0x10
popq %rdi
callq 0x61d0
movq %rax, %rbx
leaq 0x2042(%rip), %rsi      # 0x3c040
movq %rax, %rdi
callq 0x6280
movq 0x29f2b(%rip), %rsi     # 0x63f38
movq 0x29f4c(%rip), %rdx     # 0x63f60
movq %rbx, %rdi
callq 0x6690
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x66e0
nop