LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3be83
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 0x3800a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11f28
addq $0x510, %r15            # imm = 0x510
jmp 0x37ff1
movq 0xe0(%r14), %r15
movq 0xe8(%r14), %r12
cmpq %r12, %r15
je 0x3802e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b644
addq $0x10, %r15
jmp 0x38018
movq 0xf8(%r14), %r12
movq 0x100(%r14), %r13
cmpq %r13, %r12
je 0x38070
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 0x38046
movq 0x630(%r14), %r15
movq 0x638(%r14), %r12
cmpq %r12, %r15
je 0x38094
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3b454
addq $0x38, %r15
jmp 0x3807e
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_O1/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 0x38351
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 0x3c1d6
movl %eax, %ebp
addl 0x4(%rsp), %ebp
movq %r15, %rdi
callq 0x3c02c
movsd 0x6f05(%rip), %xmm1     # 0x3f198
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
ucomisd %xmm0, %xmm1
jae 0x382b3
callq 0x3899a
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x387b2
jmp 0x382c4
callq 0x387b2
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x3899a
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x38bac
testb %al, %al
jne 0x38336
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 0x3b61c
testb %al, %al
je 0x38336
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 0x3832e
movupd (%r13), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x38336
movq %r13, %rdx
callq 0x399fe
incl %r12d
cmpl 0x44(%r14), %r12d
jb 0x38271
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/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 0x38bd8
cmpq %rax, %rcx
setae %al
jmp 0x38cab
pushq %rbx
movq %rsi, %rbx
movq %rcx, %xmm1
punpckldq 0x6427(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x642f(%rip), %xmm1     # 0x3f020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0xc6db(%rip), %xmm0     # 0x452e0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x38c15
sqrtsd %xmm0, %xmm0
jmp 0x38c1a
callq 0x63b0
mulsd 0xc6c6(%rip), %xmm0     # 0x452e8
cvttsd2si %xmm0, %eax
cmpl $0x1e, %eax
jge 0x38c2f
xorl %eax, %eax
jmp 0x38caa
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 0x6587(%rip), %xmm1     # 0x3f1d8
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 0x38c53
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm0
movsd 0x63a0(%rip), %xmm2     # 0x3f030
cmpltpd %xmm2, %xmm1
movsd 0x6a2b(%rip), %xmm2     # 0x3f6c8
cmpltpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
popq %rbx
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x399de
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x630(%rdi), %rsi
callq 0x38bac
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x399d6
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 0xdbfc(%rip), %rdi      # 0x475e1
leaq 0xda29(%rip), %rsi      # 0x47415
leaq 0xdc0a(%rip), %rcx      # 0x475fd
movl $0x1be, %edx            # imm = 0x1BE
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a928
movb $0x1, 0x8(%r14)
decl 0x5c(%rbx)
je 0x3a8e7
cmpl %ebp, 0x60(%rbx)
jne 0x3a8fc
leaq 0x28(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6110
cmpl %ebp, 0x60(%rbx)
je 0x3a8d5
jmp 0x3a8fc
incl 0x60(%rbx)
movl 0x58(%rbx), %eax
movl %eax, 0x5c(%rbx)
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x66a0
leaq 0x8(%rsp), %rdi
callq 0x3a912
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18006(%rip), %rbx     # 0x52f98
leaq 0xc8e5(%rip), %rsi      # 0x4787e
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc8ec(%rip), %rsi      # 0x4789c
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc8ee(%rip), %rsi      # 0x478b5
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc923(%rip), %rsi      # 0x47901
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc97b(%rip), %rsi      # 0x47970
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc9a3(%rip), %rsi      # 0x479af
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xc9d3(%rip), %rsi      # 0x479f6
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
leaq 0xca01(%rip), %rsi      # 0x47a3b
movq %rbx, %rdi
callq 0x6440
movq %rax, %rdi
callq 0x61c0
xorl %edi, %edi
callq 0x64e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17e98(%rip), %rsi     # 0x52f28
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 0x17e68(%rip), %rsi     # 0x52f28
leaq 0x18(%rsp), %rdi
callq 0x6360
leaq 0x98(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc6dc(%rip), %rsi      # 0x477d4
movq %rbx, %rdi
callq 0x6100
testl %eax, %eax
je 0x3b14a
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 0x17df7(%rip), %rsi     # 0x52f28
leaq 0x10(%rsp), %rdi
callq 0x6360
leaq 0x90(%rsp), %rdi
callq 0x6130
jmp 0x3b154
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 0x17dbd(%rip), %rsi     # 0x52f28
leaq 0x10(%rsp), %rdi
callq 0x6360
leaq 0x90(%rsp), %rdi
callq 0x6130
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b698
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x62c0
leaq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x6500
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6500
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b5c9
movsd 0x3a98(%rip), %xmm2     # 0x3f030
ucomisd %xmm1, %xmm2
jbe 0x3b5c9
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0x3b5bf
movq 0x3c19(%rip), %xmm0     # 0x3f1d8
movq %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
retq
pushq %rax
leaq 0xc53f(%rip), %rdi      # 0x47b10
leaq 0xc55b(%rip), %rsi      # 0x47b33
leaq 0xc567(%rip), %rcx      # 0x47b46
movl $0x13, %edx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b642
ucomisd %xmm1, %xmm0
jne 0x3b640
jp 0x3b640
movsd 0x8(%rsi), %xmm0
ucomisd 0x8(%rdi), %xmm0
ja 0x3b642
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x62f0
movb $0x20, %bpl
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0x8(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0x9(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movsd 0x18(%r14), %xmm0
movq %rbx, %rdi
callq 0x6630
leaq 0xa(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movsd 0x20(%r14), %xmm0
movq %rbx, %rdi
callq 0x6630
leaq 0xb(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x62f0
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x64a0
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x64a0
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
movq 0x70(%r14), %rsi
movq 0x78(%r14), %rdx
movq %rbx, %rdi
callq 0x64a0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x64a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6700
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
callq 0x6700
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x6700
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x6700
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x6700
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 0x6700
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x6510
leaq 0x50(%r14), %rsi
movq %rbx, %rdi
callq 0x6510
addq $0x70, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c69b
movl %esi, %ebx
testl %edi, %edi
js 0x3c68c
movl %edi, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
jmp 0x3c699
notl %edi
movl %ebx, %esi
callq 0x3c677
notl %eax
addl %ebx, %eax
popq %rbx
retq
leaq 0xb722(%rip), %rdi      # 0x47dc4
leaq 0xb6ee(%rip), %rsi      # 0x47d97
leaq 0xb71a(%rip), %rcx      # 0x47dca
movl $0x13, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c73f
movq %rdi, %rbx
movsd (%rdi), %xmm1
movl %esi, %r14d
movl $0x1, %eax
movapd %xmm1, %xmm0
movsd (%rbx,%rax,8), %xmm1
maxsd %xmm0, %xmm1
incq %rax
cmpq %rax, %r14
jne 0x3c6d7
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rbx,%r15,8), %xmm0
subsd 0x8(%rsp), %xmm0
callq 0x6730
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r15
cmpq %r15, %r14
jne 0x3c6f9
callq 0x63c0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb69e(%rip), %rdi      # 0x47de4
leaq 0xb64a(%rip), %rsi      # 0x47d97
leaq 0xb696(%rip), %rcx      # 0x47dea
movl $0x1c, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x8(%rdi), %rax
movq %rax, %r14
subq %rcx, %r14
sete %sil
shrq $0x3, %r14
movq %rcx, %rdx
addq $0x8, %rdx
cmpq %rax, %rdx
sete %dil
orb %sil, %dil
je 0x3c797
movq %rcx, %rsi
jmp 0x3c7b3
movsd (%rdx), %xmm0
ucomisd (%rcx), %xmm0
movq %rdx, %rsi
ja 0x3c7a7
movq %rcx, %rsi
addq $0x8, %rdx
movq %rsi, %rcx
cmpq %rax, %rdx
jne 0x3c797
movsd (%rsi), %xmm0
testl %r14d, %r14d
movsd %xmm0, (%rsp)
jle 0x3c7fc
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, 0x8(%rsp)
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
subsd (%rsp), %xmm0
callq 0x6730
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r15
cmpq %r15, %r14
jne 0x3c7cf
jmp 0x3c800
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
addsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c88b
movapd %xmm0, %xmm2
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm0
subsd %xmm2, %xmm1
movsd %xmm1, (%rsp)
callq 0x6730
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x6730
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0xb580(%rip), %rdi      # 0x47e12
leaq 0xb4fe(%rip), %rsi      # 0x47d97
leaq 0xb578(%rip), %rcx      # 0x47e18
movl $0x41, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edi, %edi
jle 0x3cb2d
movl %edi, %eax
incq %rax
xorpd %xmm1, %xmm1
mulsd %xmm0, %xmm1
addsd -0x10(%rsi,%rax,8), %xmm1
decq %rax
cmpq $0x1, %rax
jg 0x3cb18
jmp 0x3cb31
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c02c
movq 0x8(%rbx), %rsi
movsd 0x263e(%rip), %xmm1     # 0x3f198
subq (%rbx), %rsi
ucomisd %xmm0, %xmm1
jae 0x3cbe0
sarq $0x3, %rsi
movq %rsi, %xmm0
punpckldq 0x249c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x24a4(%rip), %xmm0     # 0x3f020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x3c02c
movapd %xmm0, %xmm1
movapd (%rsp), %xmm0
callq 0x66f0
cvttsd2si %xmm0, %r15d
testl %r15d, %r15d
jle 0x3cbda
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x3c1d6
movl %eax, %ebp
movq %r14, %rdi
callq 0x3c054
movslq %ebp, %rax
movq (%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
decl %r15d
jne 0x3cbad
xorpd %xmm0, %xmm0
jmp 0x3cc39
shrq $0x3, %rsi
movq %r14, %rdi
callq 0x3c1d6
movslq %eax, %r15
movq (%rbx), %rax
movsd (%rax,%r15,8), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x2594(%rip), %xmm0     # 0x3f198
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
callq 0x3c0ec
movq (%rbx), %rax
addsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rax,%r15,8)
mulsd %xmm0, %xmm0
mulsd 0x2404(%rip), %xmm0     # 0x3f038
addsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
leaq 0x15bae(%rip), %rax     # 0x52998
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
leaq 0x15b50(%rip), %rax     # 0x52958
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rdi)
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jae 0x3cecc
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
ucomisd %xmm3, %xmm2
jae 0x3ceea
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x3cc44
movups 0x8(%r14), %xmm0
movups %xmm0, (%r15)
movsd 0x8(%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x63e0
divsd 0x2838(%rip), %xmm0     # 0x3f6b8
addsd 0x2310(%rip), %xmm0     # 0x3f198
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x63e0
divsd 0x280d(%rip), %xmm0     # 0x3f6b8
addsd 0x22e5(%rip), %xmm0     # 0x3f198
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xb120(%rip), %rsi      # 0x48000
movq %rax, %rdi
callq 0x6280
jmp 0x3cf06
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xb139(%rip), %rsi      # 0x48037
movq %rax, %rdi
callq 0x6280
movq 0x16033(%rip), %rsi     # 0x52f40
movq 0x1604c(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3cf1e
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d01b
ucomisd 0x2064(%rip), %xmm1     # 0x3f030
ja 0x3d01b
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movsd 0x18(%rdi), %xmm0
subsd 0x30(%rdi), %xmm0
divsd 0x38(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x63e0
divsd 0x26c2(%rip), %xmm0     # 0x3f6b8
addsd 0x219a(%rip), %xmm0     # 0x3f198
movsd (%rsp), %xmm1
mulsd 0x40(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ccd6
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x2011(%rip), %rsi      # 0x3f040
movq %rax, %rdi
callq 0x6280
movq 0x15f02(%rip), %rsi     # 0x52f40
movq 0x15f1b(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c0ec
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x1e06(%rip), %xmm1     # 0x3f030
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x3c5fb
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_O1/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 %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x1561c(%rip), %rax     # 0x52a48
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
leaq 0x155c3(%rip), %rax     # 0x52a08
movq %rax, 0x20(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm0, %xmm3
jae 0x3d4ee
movapd %xmm1, 0x10(%rsp)
movapd %xmm2, (%rsp)
ucomisd %xmm2, %xmm1
jae 0x3d50c
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3d250
movsd 0x8(%r14), %xmm1
movsd %xmm1, 0x28(%rbx)
movapd (%rsp), %xmm0
xorpd 0x229e(%rip), %xmm0     # 0x3f740
divsd %xmm1, %xmm0
callq 0x6730
movsd 0x1b7d(%rip), %xmm1     # 0x3f030
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movapd 0x10(%rsp), %xmm0
xorpd 0x2276(%rip), %xmm0     # 0x3f740
divsd 0x28(%rbx), %xmm0
callq 0x6730
addsd 0x2224(%rip), %xmm0     # 0x3f700
addsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xabbb(%rip), %rsi      # 0x480bd
movq %rax, %rdi
callq 0x6280
jmp 0x3d528
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xabd9(%rip), %rsi      # 0x480f9
movq %rax, %rdi
callq 0x6280
movq 0x15a11(%rip), %rsi     # 0x52f40
movq 0x15a2a(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3d540
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d692
ucomisd 0x19f0(%rip), %xmm1     # 0x3f030
ja 0x3d692
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movsd 0x10(%rdi), %xmm0
xorpd 0x20ea(%rip), %xmm0     # 0x3f740
divsd 0x28(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x6730
movsd 0x19c3(%rip), %xmm1     # 0x3f030
movsd (%rsp), %xmm2
mulsd 0x30(%rbx), %xmm2
subsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movapd %xmm2, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d340
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x199a(%rip), %rsi      # 0x3f040
movq %rax, %rdi
callq 0x6280
movq 0x1588b(%rip), %rsi     # 0x52f40
movq 0x158a4(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::Gaussian::cdf_inverse(double) const
double Gaussian::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].");
    return center + width*normal_inverse_cdf(x);
    //return center + width * sqrt(2) * boost::math::erf_inv(2*x - 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3d914
ucomisd 0x174d(%rip), %xmm0     # 0x3f030
ja 0x3d914
movsd 0x8(%rdi), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x10(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x3c8ca
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x1718(%rip), %rsi      # 0x3f040
movq %rax, %rdi
callq 0x6280
movq 0x15609(%rip), %rsi     # 0x52f40
movq 0x15622(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::TruncatedGaussian::TruncatedGaussian(double, double, double, double)
TruncatedGaussian::TruncatedGaussian(double center, double width, double lower, double upper)
:center(center)
,width(width)
,lower(lower)
,upper(upper)
{
    if(width <= 0.0)
        throw std::domain_error("TruncatedGaussian distribution must have positive width.");
    if(lower >= upper)
        throw std::domain_error("TruncatedGaussian: lower bound should be less than upper bound.");
    // the original, untruncated, Gaussian distribution
    unG = Gaussian(center, width);
    c = unG.cdf(upper) - unG.cdf(lower);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x1516e(%rip), %rax     # 0x52af8
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
movsd %xmm2, 0x18(%rdi)
movsd %xmm3, 0x20(%rdi)
leaq 0x15110(%rip), %rax     # 0x52ab8
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x38(%rdi)
movabsq $0x3fed67f1c864beb4, %rax # imm = 0x3FED67F1C864BEB4
movq %rax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
xorpd %xmm4, %xmm4
ucomisd %xmm1, %xmm4
jae 0x3da62
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, (%rsp)
ucomisd %xmm3, %xmm2
jae 0x3da80
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3d83c
movq 0x18(%r14), %rax
movq %rax, 0x10(%r15)
movups 0x8(%r14), %xmm0
movups %xmm0, (%r15)
movsd (%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x3c8aa
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x30(%rbx), %xmm0
divsd 0x38(%rbx), %xmm0
callq 0x3c8aa
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x50(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa713(%rip), %rsi      # 0x48189
movq %rax, %rdi
callq 0x6280
jmp 0x3da9c
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa72e(%rip), %rsi      # 0x481c2
movq %rax, %rdi
callq 0x6280
movq 0x1549d(%rip), %rsi     # 0x52f40
movq 0x154b6(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3dab4
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/Gaussian.cpp
// Function: DNest4::TruncatedGaussian::cdf_inverse(double) const
double TruncatedGaussian::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 = unG.cdf(lower) + x * c;
    return unG.cdf_inverse(xx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x3db81
ucomisd 0x14ee(%rip), %xmm1     # 0x3f030
ja 0x3db81
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movsd 0x18(%rdi), %xmm0
subsd 0x30(%rdi), %xmm0
divsd 0x38(%rdi), %xmm0
movsd %xmm1, (%rsp)
callq 0x3c8aa
movsd (%rsp), %xmm1
mulsd 0x50(%rbx), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d8ca
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x14ab(%rip), %rsi      # 0x3f040
movq %rax, %rdi
callq 0x6280
movq 0x1539c(%rip), %rsi     # 0x52f40
movq 0x153b5(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/Laplace.cpp
// Function: DNest4::Laplace::setpars(double, double)
void Laplace::setpars(double c, double w)
{
    if(w <= 0.0)
        throw std::domain_error("Laplace distribution must have positive width.");
    center = c;
    width = w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jae 0x3dddc
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa480(%rip), %rsi      # 0x48270
movq %rax, %rdi
callq 0x6280
movq 0x15141(%rip), %rsi     # 0x52f40
movq 0x1515a(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::LogUniform::LogUniform(double, double)
LogUniform::LogUniform(double _lower, double _upper)
:lower(_lower)
,upper(_upper)
{
    if(lower <= 0.0)
        throw std::domain_error("LogUniform distribution must have positive lower limit.");
    if (upper <= lower)
        throw std::domain_error("LogUniform distribution must have lower < upper limits");

    d = log(upper / lower);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x14b7d(%rip), %rax     # 0x52bc0
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3e07d
ucomisd %xmm1, %xmm0
jae 0x3e09b
movq %rdi, %rbx
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x63c0
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa229(%rip), %rsi      # 0x482ba
movq %rax, %rdi
callq 0x6280
jmp 0x3e0b7
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa243(%rip), %rsi      # 0x482f2
movq %rax, %rdi
callq 0x6280
movq 0x14e82(%rip), %rsi     # 0x52f40
movq 0x14e9b(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3e0cf
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::LogUniform::cdf(double) const
double LogUniform::cdf(double x) const
{
    if(x < lower)
        return 0.0;
    if(x > upper)
        return 1.0;
    return (log(x) - log(lower)) / d;
}

// Assembly:
movsd 0x8(%rdi), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm1
ja 0x3e133
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd 0x10(%rdi), %xmm0
jbe 0x3e10a
movsd 0xf28(%rip), %xmm2      # 0x3f030
jmp 0x3e12e
callq 0x63c0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rbx), %xmm0
callq 0x63c0
movsd 0x8(%rsp), %xmm2
subsd %xmm0, %xmm2
divsd 0x18(%rbx), %xmm2
addq $0x10, %rsp
popq %rbx
movapd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/Distributions/LogUniform.cpp
// Function: DNest4::ModifiedLogUniform::ModifiedLogUniform(double, double)
ModifiedLogUniform::ModifiedLogUniform(double _knee, double _upper)
:knee(_knee)
,upper(_upper)
{
    if(knee <= 0.0)
        throw std::domain_error("ModifiedLogUniform distribution must have positive knee.");
    if (upper <= knee)
        throw std::domain_error("ModifiedLogUniform distribution must have knee < upper limit");

    d = 1.0 / log(1.0 + upper / knee);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x149e5(%rip), %rax     # 0x52c00
movq %rax, (%rdi)
movsd %xmm0, 0x8(%rdi)
movsd %xmm1, 0x10(%rdi)
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jae 0x3e269
ucomisd %xmm1, %xmm0
jae 0x3e287
movq %rdi, %rbx
divsd %xmm0, %xmm1
addsd 0xde9(%rip), %xmm1      # 0x3f030
movapd %xmm1, %xmm0
callq 0x63c0
movsd 0xdd8(%rip), %xmm1      # 0x3f030
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa0ac(%rip), %rsi      # 0x48329
movq %rax, %rdi
callq 0x6280
jmp 0x3e2a3
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0xa0c7(%rip), %rsi      # 0x48362
movq %rax, %rdi
callq 0x6280
movq 0x14c96(%rip), %rsi     # 0x52f40
movq 0x14caf(%rip), %rdx     # 0x52f60
movq %rbx, %rdi
callq 0x66c0
jmp 0x3e2bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/ConditionalPriors/ConditionalPrior.cpp
// Function: DNest4::ConditionalPrior::perturb1(DNest4::RNG&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double ConditionalPrior::perturb1(RNG& rng, const vector< vector<double> >& components,
				vector< vector<double> >& u_components)
{
	double logH = 0.;

	// 1/(old density)
	for(size_t i=0; i<components.size(); i++)
		logH -= log_pdf(components[i]);

	logH += perturb_hyperparameters(rng);

	// (new density)
	for(size_t i=0; i<components.size(); i++)
	{
		logH += log_pdf(components[i]);
		u_components[i] = components[i];
		to_uniform(u_components[i]);

        for(size_t j=0; j<components[i].size(); ++j)
            if(u_components[i][j] <= 0.0 || u_components[i][j] >= 1.0)
                logH = -1E300;
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq (%rdx), %rsi
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
cmpq %rsi, 0x8(%rdx)
je 0x3e6f3
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %rbp
cmpq %rax, %r12
jb 0x3e6b9
jmp 0x3e6fc
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq (%r15), %rax
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq *(%rax)
addsd (%rsp), %xmm0
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x3e801
xorl %r12d, %r12d
movapd %xmm0, (%rsp)
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %rbp
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x20(%rax)
addsd (%rsp), %xmm0
movapd %xmm0, (%rsp)
movq (%r14), %rsi
addq %rbp, %rsi
movq (%rbx), %rdi
addq %rbp, %rdi
callq 0x736c
movq (%rbx), %rsi
addq %rbp, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq (%r14), %rcx
movq 0x8(%rcx,%rbp), %rax
subq (%rcx,%rbp), %rax
je 0x3e7de
sarq $0x3, %rax
movq (%rbx), %rcx
leaq (%r12,%r12,2), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edx, %edx
movsd 0x89c(%rip), %xmm1      # 0x3f030
movsd 0xa3c(%rip), %xmm2      # 0x3f1d8
xorpd %xmm3, %xmm3
movapd (%rsp), %xmm5
movsd (%rcx,%rdx,8), %xmm0
movapd %xmm1, %xmm4
cmpnlesd %xmm0, %xmm4
andpd %xmm4, %xmm5
andnpd %xmm2, %xmm4
orpd %xmm5, %xmm4
cmpnlesd %xmm3, %xmm0
andpd %xmm0, %xmm4
andnpd %xmm2, %xmm0
orpd %xmm4, %xmm0
incq %rdx
movapd %xmm0, %xmm5
cmpq %rdx, %rax
jne 0x3e7a5
jmp 0x3e7e3
movapd (%rsp), %xmm0
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %r12
jb 0x3e71e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/DNest4/code/RJObject/ConditionalPriors/ConditionalPrior.cpp
// Function: DNest4::ConditionalPrior::perturb2(DNest4::RNG&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
double ConditionalPrior::perturb2(RNG& rng, vector< vector<double> >& components,
				const vector< vector<double> >& u_components)
{
	double logH = 0.;

	logH += perturb_hyperparameters(rng);

	// Find new positions
	for(size_t i=0; i<components.size(); i++)
	{
		components[i] = u_components[i];
		from_uniform(components[i]);
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, (%rsp)
movq (%r14), %rdi
cmpq %rdi, 0x8(%r14)
je 0x3e881
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebp, %ebp
movq (%rbx), %rsi
addq %r12, %rsi
addq %r12, %rdi
callq 0x736c
movq (%r14), %rsi
addq %r12, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
incq %rbp
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %r12
cmpq %rax, %rbp
jb 0x3e846
xorpd %xmm1, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq