LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x4, %rsi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc, %rsi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rsi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x18, %rsi
callq 0x6440
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0x6440
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x6070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rsi
callq 0x6610
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x50, %rsi
callq 0x6610
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x70, %rsi
callq 0x6610
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xb3446
jmp 0xb3465
leaq 0x18abf(%rip), %rdi     # 0xcbf0c
leaq 0x18a8b(%rip), %rsi     # 0xcbedf
movl $0x13, %edx
leaq 0x18ab2(%rip), %rcx     # 0xcbf12
callq 0x6340
cmpl $0x0, -0x8(%rbp)
jl 0xb3488
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %ecx
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb34ab
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %edi, %edi
subl -0x8(%rbp), %edi
subl $0x1, %edi
movl -0xc(%rbp), %esi
callq 0xb3430
movl %eax, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xb34d7
jmp 0xb34f6
leaq 0x18a4e(%rip), %rdi     # 0xcbf2c
leaq 0x189fa(%rip), %rsi     # 0xcbedf
movl $0x1c, %edx
leaq 0x18a41(%rip), %rcx     # 0xcbf32
callq 0x6340
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb3545
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0xb3538
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xb353a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb350a
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb3588
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x18(%rbp), %xmm0
callq 0x6870
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb3554
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x6430
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c90
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7bf0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x16810
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xa620
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb365c
movq -0x8(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0xa6a0
movsd (%rax), %xmm0
subsd -0x18(%rbp), %xmm0
callq 0x6870
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb3624
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x6430
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xb36f0
jmp 0xb370f
leaq 0x18863(%rip), %rdi     # 0xcbf5a
leaq 0x187e1(%rip), %rsi     # 0xcbedf
movl $0x41, %edx
leaq 0x18856(%rip), %rcx     # 0xcbf60
callq 0x6340
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x6870
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x6870
movaps %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
callq 0x6430
addsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jg 0xb3af7
movsd -0x28(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb3ac1
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb26f0
movaps %xmm0, %xmm1
movsd 0x366c(%rip), %xmm0     # 0xb7198
ucomisd %xmm1, %xmm0
jb 0xb3bf2
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c90
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0xb28c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc6a0
movsd (%rax), %xmm0
movsd 0x35e2(%rip), %xmm1     # 0xb7150
callq 0x6820
movsd -0x18(%rbp), %xmm1
movsd 0x3618(%rip), %xmm2     # 0xb7198
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb27b0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc6a0
movsd -0x30(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc6a0
movsd (%rax), %xmm0
movsd 0x3582(%rip), %xmm1     # 0xb7150
callq 0x6820
movsd -0x18(%rbp), %xmm1
movsd 0x3458(%rip), %xmm2     # 0xb7038
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xb3ca3
movq -0x8(%rbp), %rdi
callq 0x7c90
movq %rax, %xmm0
movaps 0x3409(%rip), %xmm1     # 0xb7010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x340d(%rip), %xmm1     # 0xb7020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb26f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
callq 0x6820
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xb3ca1
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7c90
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0xb28c0
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2720
movsd %xmm0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xc6a0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb3c4b
jmp 0xb3ca3
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x77a0
movq -0x58(%rbp), %rdi
leaq 0x659f8(%rip), %rax     # 0x119970
addq $0x10, %rax
movq %rax, (%rdi)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rdi
xorps %xmm0, %xmm0
movsd 0x307a(%rip), %xmm1     # 0xb7030
callq 0xb3cb0
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xb4018
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x17fd9(%rip), %rsi     # 0xcbfb9
callq 0x6310
jmp 0xb3fe7
movq -0x60(%rbp), %rdi
movq 0x65f2e(%rip), %rsi     # 0x119f20
movq 0x65f5f(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0xb40dc
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0xb4074
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x17fb1(%rip), %rsi     # 0xcbff0
callq 0x6310
jmp 0xb4046
movq -0x68(%rbp), %rdi
movq 0x65ecf(%rip), %rsi     # 0x119f20
movq 0x65f00(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0xb40dc
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq -0x50(%rbp), %rdi
callq 0xb3cb0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
leaq -0x50(%rbp), %rsi
callq 0xb4300
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movsd -0x28(%rbp), %xmm0
callq 0xb3d70
movq -0x58(%rbp), %rdi
movsd %xmm0, -0x70(%rbp)
addq $0x28, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xb3d70
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0xb41b6
movsd -0x10(%rbp), %xmm0
movsd 0x2e80(%rip), %xmm1     # 0xb7030
ucomisd %xmm1, %xmm0
jbe 0xb4206
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x2e6f(%rip), %rsi      # 0xb7040
callq 0x6310
jmp 0xb41d8
movq -0x38(%rbp), %rdi
movq 0x65d3d(%rip), %rsi     # 0x119f20
movq 0x65d6e(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x63b0
jmp 0xb424d
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movsd 0x18(%rax), %xmm0
callq 0xb3d70
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
movsd 0x40(%rdi), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x28, %rdi
movsd -0x28(%rbp), %xmm0
callq 0xb3dc0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rdi
callq 0xb27b0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x2ada(%rip), %xmm1     # 0xb7030
callq 0xb33e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x77a0
movq -0x48(%rbp), %rdi
leaq 0x6516d(%rip), %rax     # 0x119a20
addq $0x10, %rax
movq %rax, (%rdi)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x20, %rdi
movsd 0x274c(%rip), %xmm0     # 0xb7030
callq 0xb4580
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0xb4946
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x17768(%rip), %rsi     # 0xcc076
callq 0x6310
jmp 0xb4915
movq -0x50(%rbp), %rdi
movq 0x65600(%rip), %rsi     # 0x119f20
movq 0x65631(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x63b0
jmp 0xb4a05
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0xb49a2
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x17745(%rip), %rsi     # 0xcc0b2
callq 0x6310
jmp 0xb4974
movq -0x58(%rbp), %rdi
movq 0x655a1(%rip), %rsi     # 0x119f20
movq 0x655d2(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x63b0
jmp 0xb4a05
movsd -0x10(%rbp), %xmm0
leaq -0x40(%rbp), %rdi
callq 0xb4580
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq -0x40(%rbp), %rsi
callq 0xb4cb0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xb46c0
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
addq $0x20, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xb46c0
movq -0x48(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6830
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0xb4b66
movsd -0x10(%rbp), %xmm0
movsd 0x24d0(%rip), %xmm1     # 0xb7030
ucomisd %xmm1, %xmm0
jbe 0xb4bb6
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x24bf(%rip), %rsi      # 0xb7040
callq 0x6310
jmp 0xb4b88
movq -0x38(%rbp), %rdi
movq 0x6538d(%rip), %rsi     # 0x119f20
movq 0x653be(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x63b0
jmp 0xb4bfd
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movsd 0x10(%rax), %xmm0
callq 0xb46c0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
movsd 0x30(%rdi), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x20, %rdi
movsd -0x28(%rbp), %xmm0
callq 0xb4710
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0xb4f26
movsd -0x10(%rbp), %xmm0
movsd 0x2110(%rip), %xmm1     # 0xb7030
ucomisd %xmm1, %xmm0
jbe 0xb4f76
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x20ff(%rip), %rsi      # 0xb7040
callq 0x6310
jmp 0xb4f48
movq -0x30(%rbp), %rdi
movq 0x64fcd(%rip), %rsi     # 0x119f20
movq 0x64ffe(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x63b0
jmp 0xb4fb3
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0xb37e0
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x77a0
movq -0x60(%rbp), %rdi
leaq 0x64a75(%rip), %rax     # 0x119ad0
addq $0x10, %rax
movq %rax, (%rdi)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x20(%rdi)
addq $0x28, %rdi
xorps %xmm0, %xmm0
movsd 0x1f97(%rip), %xmm1     # 0xb7030
callq 0xb4df0
movsd 0x20b2(%rip), %xmm0     # 0xb7158
callq 0x6410
callq 0x6430
movq -0x60(%rbp), %rax
movsd %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xb5116
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
leaq 0x17064(%rip), %rsi     # 0xcc142
callq 0x6310
jmp 0xb50e5
movq -0x68(%rbp), %rdi
movq 0x64e30(%rip), %rsi     # 0x119f20
movq 0x64e61(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0xb51dd
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0xb5172
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x1703e(%rip), %rsi     # 0xcc17b
callq 0x6310
jmp 0xb5144
movq -0x70(%rbp), %rdi
movq 0x64dd1(%rip), %rsi     # 0x119f20
movq 0x64e02(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x63b0
jmp 0xb51dd
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq -0x58(%rbp), %rdi
callq 0xb4df0
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
leaq -0x58(%rbp), %rsi
callq 0xab20
movq -0x60(%rbp), %rdi
addq $0x28, %rdi
movsd -0x28(%rbp), %xmm0
callq 0xb4ec0
movq -0x60(%rbp), %rdi
movsd %xmm0, -0x78(%rbp)
addq $0x28, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xb4ec0
movq -0x60(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0xb52b6
movsd -0x10(%rbp), %xmm0
movsd 0x1d80(%rip), %xmm1     # 0xb7030
ucomisd %xmm1, %xmm0
jbe 0xb5306
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x1d6f(%rip), %rsi      # 0xb7040
callq 0x6310
jmp 0xb52d8
movq -0x38(%rbp), %rdi
movq 0x64c3d(%rip), %rsi     # 0x119f20
movq 0x64c6e(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x63b0
jmp 0xb534d
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movsd 0x18(%rax), %xmm0
callq 0xb4ec0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
movsd 0x50(%rdi), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x28, %rdi
movsd -0x28(%rbp), %xmm0
callq 0xb4ef0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xb5678
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x16bbb(%rip), %rsi     # 0xcc1fe
callq 0x6310
jmp 0xb564a
movq -0x38(%rbp), %rdi
movq 0x648cb(%rip), %rsi     # 0x119f20
movq 0x648fc(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x63b0
jmp 0xb5696
movq -0x30(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6830
nop
// File: j-faria[P]kima/DNest4/code/Distributions/Laplace.cpp
// Function: DNest4::Laplace::sign(double)
int Laplace::sign(double x)
{
	if(x == 0.0)
		return 0;
	if(x > 0.0)
		return 1;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb5772
jp 0xb5772
movl $0x0, -0x4(%rbp)
jmp 0xb5790
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xb5789
movl $0x1, -0x4(%rbp)
jmp 0xb5790
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x77a0
movq -0x30(%rbp), %rax
leaq 0x6418a(%rip), %rcx     # 0x119b98
addq $0x10, %rcx
movq %rcx, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jb 0xb5a86
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x167fa(%rip), %rsi     # 0xcc248
callq 0x6310
jmp 0xb5a55
movq -0x38(%rbp), %rdi
movq 0x644c0(%rip), %rsi     # 0x119f20
movq 0x644f1(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x63b0
jmp 0xb5b0c
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xb5aea
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x167cb(%rip), %rsi     # 0xcc280
callq 0x6310
jmp 0xb5abc
movq -0x40(%rbp), %rdi
movq 0x64459(%rip), %rsi     # 0x119f20
movq 0x6448a(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x63b0
jmp 0xb5b0c
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
divsd 0x8(%rax), %xmm0
callq 0x6430
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb5b53
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb5ba9
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
ucomisd 0x10(%rax), %xmm0
jbe 0xb5b72
movsd 0x14c5(%rip), %xmm0     # 0xb7030
movsd %xmm0, -0x8(%rbp)
jmp 0xb5ba9
movsd -0x18(%rbp), %xmm0
callq 0x6430
movq -0x20(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd 0x8(%rax), %xmm0
callq 0x6430
movq -0x20(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
subsd %xmm1, %xmm0
divsd 0x18(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x77a0
movq -0x30(%rbp), %rax
leaq 0x63e6a(%rip), %rcx     # 0x119bd8
addq $0x10, %rcx
movq %rcx, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jb 0xb5de6
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x16509(%rip), %rsi     # 0xcc2b7
callq 0x6310
jmp 0xb5db5
movq -0x38(%rbp), %rdi
movq 0x64160(%rip), %rsi     # 0x119f20
movq 0x64191(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x63b0
jmp 0xb5e87
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0xb5e4a
movl $0x10, %edi
callq 0x6250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x164db(%rip), %rsi     # 0xcc2f0
callq 0x6310
jmp 0xb5e1c
movq -0x40(%rbp), %rdi
movq 0x640f9(%rip), %rsi     # 0x119f20
movq 0x6412a(%rip), %rdx     # 0x119f58
callq 0x67e0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x63b0
jmp 0xb5e87
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm1
divsd 0x8(%rax), %xmm1
movsd 0x11d0(%rip), %xmm0     # 0xb7030
addsd %xmm1, %xmm0
callq 0x6430
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x11b8(%rip), %xmm0     # 0xb7030
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6830
// File: j-faria[P]kima/DNest4/code/Distributions/Uniform.cpp
// Function: DNest4::Uniform::cdf(double) const
double Uniform::cdf(double x) const
{
    if (x<lower)
        return 0.;
    else if (x>=upper)
        return 1.;
    else
        return (x-lower)/(upper-lower);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x18(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb61ef
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xb622f
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
ucomisd 0x10(%rax), %xmm0
jb 0xb620e
movsd 0xe29(%rip), %xmm0      # 0xb7030
movsd %xmm0, -0x8(%rbp)
jmp 0xb622f
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
subsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
subsd 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15d80
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xb6702
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x27af0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15d30
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x7950
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x15d30
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb6693
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/inline_shorter.cc
// Function: main
int main()
{
	string s1("successes"), s2("failure");
	cout << shorterString(s1, s2) << endl;

	// call the size member of the string returned by shorterString
	cout << shorterString(s1, s2).size() << endl;

	// equivalent code as generated by the call to inline version
	// of shorterString
	cout << (s1.size() < s2.size() ? s1 : s2) << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x10d0
movq -0x70(%rbp), %rdx
leaq 0xdba(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x10a0
jmp 0x1255
leaq -0x29(%rbp), %rdi
callq 0x1090
leaq -0x61(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10d0
movq -0x78(%rbp), %rdx
leaq 0xd98(%rip), %rsi       # 0x200e
leaq -0x60(%rbp), %rdi
callq 0x10a0
jmp 0x1281
leaq -0x61(%rbp), %rdi
callq 0x1090
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1410
movq %rax, -0x80(%rbp)
jmp 0x129d
movq -0x80(%rbp), %rsi
movq 0x2d30(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, -0x88(%rbp)
jmp 0x12b6
movq -0x88(%rbp), %rdi
movq 0x2d04(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x12cb
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1410
movq %rax, -0x90(%rbp)
jmp 0x12e1
movq -0x90(%rbp), %rdi
callq 0x1050
movq %rax, %rsi
movq 0x2ce1(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, -0x98(%rbp)
jmp 0x1305
movq -0x98(%rbp), %rdi
movq 0x2cb5(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x131a
leaq -0x28(%rbp), %rdi
callq 0x1050
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1050
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x134f
leaq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x135c
leaq -0x60(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x135c
movq -0xa8(%rbp), %rsi
movq 0x2c6e(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, -0xb0(%rbp)
jmp 0x1378
movq -0xb0(%rbp), %rdi
movq 0x2c42(%rip), %rsi      # 0x3fc8
callq 0x1080
jmp 0x138d
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1090
jmp 0x13fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x1090
jmp 0x13f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1040
leaq -0x28(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rdi
callq 0x10c0
nopw (%rax,%rax)
// File: eryxcc[P]lois/tests/autotest.cpp
// Function: showTimeElapsed()
void showTimeElapsed() {
  long long curtime = getVa();
  
  if(curtime - lasttime < 100000) 
    cout << "time elapsed: " << (curtime-lasttime) << " \u03bcs" << endl;

  else
    printf("time elapsed: %.6f s\n", (curtime-lasttime)/1000000.0);

  lasttime = curtime;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x9040
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
subq 0x9c2ac(%rip), %rax     # 0xa5338
cmpq $0x186a0, %rax          # imm = 0x186A0
jge 0x90da
movq 0x9bf3d(%rip), %rdi     # 0xa4fd8
leaq 0x68fee(%rip), %rsi     # 0x72090
callq 0x82b0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
subq 0x9c283(%rip), %rsi     # 0xa5338
callq 0x8180
movq %rax, %rdi
leaq 0x68fdb(%rip), %rsi     # 0x7209f
callq 0x82b0
movq %rax, %rdi
movq 0x9bedd(%rip), %rsi     # 0xa4fb0
callq 0x8300
jmp 0x9104
movq -0x8(%rbp), %rax
subq 0x9c253(%rip), %rax     # 0xa5338
cvtsi2sd %rax, %xmm0
movsd 0x68f16(%rip), %xmm1    # 0x72008
divsd %xmm1, %xmm0
leaq 0x68fa7(%rip), %rdi     # 0x720a4
movb $0x1, %al
callq 0x8050
movq -0x8(%rbp), %rax
movq %rax, 0x9c229(%rip)     # 0xa5338
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eryxcc[P]lois/tests/autotest.cpp
// Function: testQueue()
void testQueue() {
  lsetof<int> N;
  N += 0;
  for(int n: N) if(n < 10) N += (n+1);
  cout << N << endl;
  testSat(ALWAYS, cardinality(N) == 11);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq -0x28(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x135e0
movq -0xf8(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x13620
jmp 0xfbf4
leaq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x136c0
jmp 0xfc0b
movq -0x48(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x136f0
jmp 0xfc1d
jmp 0xfc1f
leaq -0x78(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x13310
movb %al, -0xf9(%rbp)
jmp 0xfc37
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0xfc96
jmp 0xfc43
leaq -0xa8(%rbp), %rdi
callq 0x13420
leaq -0x78(%rbp), %rdi
callq 0x13420
jmp 0xfd02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfdd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfcf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x13420
jmp 0xfcf4
leaq -0x78(%rbp), %rdi
callq 0x133c0
movq %rax, -0x108(%rbp)
jmp 0xfca8
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xac(%rbp)
cmpl $0xa, -0xac(%rbp)
jge 0xfce2
movl -0xac(%rbp), %eax
incl %eax
movl %eax, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x13620
jmp 0xfce0
jmp 0xfce2
jmp 0xfce4
leaq -0x78(%rbp), %rdi
callq 0x133e0
jmp 0xfcef
jmp 0xfc1f
leaq -0x78(%rbp), %rdi
callq 0x13420
jmp 0xfdd7
movq 0x952cf(%rip), %rdi     # 0xa4fd8
leaq -0x28(%rbp), %rsi
callq 0x13720
movq %rax, -0x110(%rbp)
jmp 0xfd1b
movq -0x110(%rbp), %rdi
movq 0x95287(%rip), %rsi     # 0xa4fb0
callq 0x8300
jmp 0xfd30
leaq -0xe8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13750
jmp 0xfd42
movl $0xb, -0xec(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0xec(%rbp), %rdx
callq 0x11dd0
jmp 0xfd68
movl $0x1, %edi
leaq -0xc0(%rbp), %rsi
callq 0x9120
jmp 0xfd7b
leaq -0xc0(%rbp), %rdi
callq 0x11060
leaq -0xe8(%rbp), %rdi
callq 0x124e0
leaq -0x28(%rbp), %rdi
callq 0x13d60
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfdcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x11060
leaq -0xe8(%rbp), %rdi
callq 0x124e0
leaq -0x28(%rbp), %rdi
callq 0x13d60
movq -0x38(%rbp), %rdi
callq 0x84d0
nopl (%rax)
// File: eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term>::lsetof(lois::lsetof<lois::term> const&)
lsetof<T>(const lsetof<T> &x) : ain(currentcontext) {
    if(in_substitution) {
      ain = x.ain;
      elts = x.elts;
      return;
      }
    if(debuglois) std::cout << ido << "copying " << x << " ain = " << emptycontext << std::endl;
    autoindenter i2;
    (*this) |= x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x942ae(%rip), %rsi     # 0xa57f0
callq 0x173b0
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2d1d0
leaq 0x946f9(%rip), %rax     # 0xa5c58
testb $0x1, (%rax)
je 0x1159e
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ade0
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x2d1f0
jmp 0x11588
jmp 0x1168f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x116ad
leaq 0x9466b(%rip), %rax     # 0xa5c10
testb $0x1, (%rax)
je 0x1166c
leaq 0x93d33(%rip), %rax     # 0xa52e8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq 0x93a11(%rip), %rdi     # 0xa4fd8
callq 0x6afb0
movq %rax, -0x58(%rbp)
jmp 0x115d2
movq -0x58(%rbp), %rdi
leaq 0x60d77(%rip), %rsi     # 0x72354
callq 0x82b0
movq %rax, -0x60(%rbp)
jmp 0x115e8
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11da0
movq %rax, -0x68(%rbp)
jmp 0x115fb
movq -0x68(%rbp), %rdi
leaq 0x60d57(%rip), %rsi     # 0x7235d
callq 0x82b0
movq %rax, -0x70(%rbp)
jmp 0x11611
leaq 0x941c8(%rip), %rsi     # 0xa57e0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x173b0
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1ae80
movq %rax, -0x78(%rbp)
jmp 0x11638
movq -0x78(%rbp), %rdi
movq 0x9396d(%rip), %rsi     # 0xa4fb0
callq 0x8300
jmp 0x1164a
leaq -0x38(%rbp), %rdi
callq 0x14b20
jmp 0x1166c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x14b20
jmp 0x116ad
leaq -0x39(%rbp), %rdi
callq 0x1af20
jmp 0x11677
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d440
jmp 0x11686
leaq -0x39(%rbp), %rdi
callq 0x1b720
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1b720
movq -0x48(%rbp), %rdi
callq 0x16f00
movq -0x50(%rbp), %rdi
callq 0x14b20
movq -0x18(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: eryxcc[P]lois/tests/../include/lois.h
// Function: lois::EIteratorOf<lois::term>::operator++()
void EIteratorOf<T>::operator ++ () { 
  disconnectIterator();
  // if(index >= 0) 
  index++;
  connectIterator();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x32e30
movq -0x10(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
callq 0x31770
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: eryxcc[P]lois/tests/../include/lois.h
// Function: lois::lsetof<lois::term> lois::newSet<lois::term>(lois::term, lois::term)
lsetof<T> newSet(T x, T y) {
  lsetof<T> res; 
  res.insert(x, currentcontext); 
  res.insert(y, currentcontext); 
  return res;   
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xc0(%rbp)
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x119e0
movq -0xc0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11800
leaq 0x93233(%rip), %rsi     # 0xa57f0
movq %rsi, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x173b0
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x173b0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
callq 0x2e3a0
jmp 0x1260e
leaq -0x50(%rbp), %rdi
callq 0x14b20
leaq -0x40(%rbp), %rdi
callq 0x14b20
leaq -0x30(%rbp), %rdi
callq 0x11360
movq -0xd0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x11800
leaq 0x931a9(%rip), %rsi     # 0xa57f0
movq %rsi, -0xf0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x173b0
movq -0xf0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x173b0
movq -0xb0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movq -0xd8(%rbp), %rcx
callq 0x2e3a0
jmp 0x1269b
leaq -0x90(%rbp), %rdi
callq 0x14b20
leaq -0x80(%rbp), %rdi
callq 0x14b20
leaq -0x70(%rbp), %rdi
callq 0x11360
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x12726
jmp 0x1271a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x14b20
leaq -0x40(%rbp), %rdi
callq 0x14b20
leaq -0x30(%rbp), %rdi
callq 0x11360
jmp 0x12736
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x14b20
leaq -0x80(%rbp), %rdi
callq 0x14b20
leaq -0x70(%rbp), %rdi
callq 0x11360
jmp 0x12736
movq -0xb0(%rbp), %rdi
callq 0x11960
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x11960
movq -0x58(%rbp), %rdi
callq 0x84d0
nopl (%rax,%rax)
// File: eryxcc[P]lois/tests/../include/loisextra.h
// Function: std::ostream& lois::operator<<<lois::term>(std::ostream&, lois::lvector<lois::term> const&)
std::ostream& operator << (std::ostream& os, const lvector<T>& p) { 
    bool first = true;
    os << "[";    
    for(auto& t: p) { if(!first) os << ","; first = false; os << t; }
    os << "]";
    return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5394e(%rip), %rsi     # 0x739fd
callq 0x82b0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20580
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x205b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x205e0
testb $0x1, %al
jne 0x200e9
jmp 0x20128
leaq -0x28(%rbp), %rdi
callq 0x20620
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2010c
movq -0x8(%rbp), %rdi
leaq 0x5224b(%rip), %rsi     # 0x72352
callq 0x82b0
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11140
leaq -0x28(%rbp), %rdi
callq 0x20640
jmp 0x200d6
movq -0x8(%rbp), %rdi
leaq 0x541b4(%rip), %rsi     # 0x742e7
callq 0x82b0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)