LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/distributions/Empirical.cpp
// Function: DNest4::Empirical::cdf_inverse(double) const
double Empirical::cdf_inverse(double p) const
{
    if(p < 0.0 || p > 1.0)
        throw std::domain_error("Input to cdf_inverse must be in [0, 1].");
    
    double poi = -0.5*(1 - p) + p*(data.size()-0.5);

    size_t left = max(int64_t(floor(poi)), int64_t(0));
    size_t right = min(int64_t(ceil(poi)), int64_t(data.size() - 1));

    double datLeft = data.at(left);
    double datRight = data.at(right);

    double t = poi - left;
    double quantile = (1 - t)*datLeft + t*datRight;

    return quantile;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x72f0
ucomisd 0x35e15(%rip), %xmm0    # 0x3d030
ja 0x72f0
movsd 0x35e07(%rip), %xmm3    # 0x3d030
subsd %xmm0, %xmm3
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rbx
subq %r15, %rbx
sarq $0x3, %rbx
movq %rbx, %xmm1
punpckldq 0x35dc7(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x35dcf(%rip), %xmm1    # 0x3d020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
movsd 0x35dd3(%rip), %xmm1    # 0x3d038
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movapd %xmm3, %xmm0
movsd %xmm3, 0x8(%rsp)
callq 0x6680
cvttsd2si %xmm0, %rax
xorl %r14d, %r14d
testq %rax, %rax
cmovgq %rax, %r14
movsd 0x8(%rsp), %xmm0
callq 0x6090
cvttsd2si %xmm0, %rsi
leaq -0x1(%rbx), %rax
cmpq %rsi, %rax
cmovlq %rax, %rsi
cmpq %r14, %rbx
jbe 0x7322
cmpq %rsi, %rbx
jbe 0x732e
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x35d5e(%rip), %xmm0    # 0x3d030
subsd %xmm1, %xmm0
mulsd (%r15,%rsi,8), %xmm1
mulsd (%r15,%r14,8), %xmm0
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x61d0
movq %rax, %rbx
leaq 0x35d3c(%rip), %rsi     # 0x3d040
movq %rax, %rdi
callq 0x6280
movq 0x48c2d(%rip), %rsi     # 0x4ff40
movq 0x48c46(%rip), %rdx     # 0x4ff60
movq %rbx, %rdi
callq 0x66c0
leaq 0x35d86(%rip), %rdi     # 0x3d0af
movq %r14, %rsi
jmp 0x7335
leaq 0x35d7a(%rip), %rdi     # 0x3d0af
movq %rbx, %rdx
xorl %eax, %eax
callq 0x65d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x6340
movq %r14, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/distributions/Gaussian_from_Tc.cpp
// Function: DNest4::Gaussian_from_Tc::Gaussian_from_Tc(double, double, double, double)
Gaussian_from_Tc::Gaussian_from_Tc(double Tc, double errTc, double P, double errP)
    {
        double t0 = Data::get_instance().M0_epoch;

        // propagate uncertainty on Tc and P to phi
        double A, B, AoB, sA, sB;
        A = t0 - Tc;
        B = (2 * M_PI * P);
        AoB = A / B;
        sA = errTc;
        sB = (2 * M_PI * errP);

        // build the Gaussian distribution for phi
        m = AoB;
        s = fabs(AoB) * sqrt(pow(sA/A, 2) + pow(sB/B, 2));
        d = Gaussian(m, s);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movaps %xmm3, 0x20(%rsp)
movaps %xmm2, 0x10(%rsp)
movaps %xmm1, 0x30(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x479a6(%rip), %rax     # 0x4f440
movq %rax, (%rdi)
addq $0x18, %rdi
movsd 0x35587(%rip), %xmm1    # 0x3d030
xorps %xmm0, %xmm0
callq 0x3b27c
leaq 0x48948(%rip), %rax     # 0x50400
movsd 0x100(%rax), %xmm1
subsd 0x8(%rsp), %xmm1
movsd 0x35682(%rip), %xmm2    # 0x3d150
movapd 0x10(%rsp), %xmm3
mulsd %xmm2, %xmm3
movapd %xmm1, %xmm0
divsd %xmm3, %xmm0
movapd %xmm3, %xmm4
movapd 0x20(%rsp), %xmm3
mulsd %xmm2, %xmm3
movsd %xmm0, 0x8(%rbx)
movapd 0x35665(%rip), %xmm2    # 0x3d160
andpd %xmm0, %xmm2
unpcklpd 0x30(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0]
unpcklpd %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0]
divpd %xmm4, %xmm3
mulpd %xmm3, %xmm3
movapd %xmm3, %xmm1
unpckhpd %xmm3, %xmm1            # xmm1 = xmm1[1],xmm3[1]
addsd %xmm3, %xmm1
sqrtsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rbx)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x3b27c
movq 0x18(%r14), %rax
movq %rax, 0x30(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/distributions/mixGaussianLogUniform.cpp
// Function: DNest4::mixGaussianLogUniform::cdf_inverse(double) const
double mixGaussianLogUniform::cdf_inverse(double p) const
{
    // not implemented
    // throw std::runtime_error("cdf_inverse not implemented for `mixGaussianLogUniform`");

    // estimate cdf_inverse with bisection
    double tol = 2e-12, a = lower, b = upper;
    double c = a;

    while ((b - a) >= tol)
    {
        c = (a + b) / 2;
        if (cdf(c) - p == 0.0)
            break;
        else if ((cdf(c) - p) * (cdf(a) - p) < 0)
            b = c;
        else
            a = c;
    }

    return c;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movsd 0x18(%rdi), %xmm2
movsd 0x20(%rdi), %xmm4
movapd %xmm4, %xmm1
subsd %xmm2, %xmm1
ucomisd 0x35479(%rip), %xmm1    # 0x3d1a0
jae 0x7d32
movapd %xmm2, %xmm3
jmp 0x7e09
movq %rdi, %rbx
movsd %xmm0, 0x8(%rsp)
movapd %xmm2, 0x30(%rsp)
movapd %xmm2, %xmm0
movsd %xmm4, 0x20(%rsp)
addsd %xmm4, %xmm0
mulsd 0x35441(%rip), %xmm0    # 0x3d198
movq (%rbx), %rax
movq %rbx, %rdi
movapd %xmm0, 0x10(%rsp)
callq *0x10(%rax)
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jne 0x7d80
jnp 0x7e03
movq (%rbx), %rax
movq %rbx, %rdi
movapd 0x10(%rsp), %xmm0
callq *0x10(%rax)
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
movapd 0x30(%rsp), %xmm0
callq *0x10(%rax)
xorpd %xmm2, %xmm2
subsd 0x8(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
ucomisd %xmm0, %xmm2
movapd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
ja 0x7dd0
movsd 0x20(%rsp), %xmm1
cmpltsd %xmm2, %xmm0
movapd 0x30(%rsp), %xmm2
andpd %xmm0, %xmm2
andnpd %xmm3, %xmm0
orpd %xmm0, %xmm2
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
ucomisd 0x353a9(%rip), %xmm0    # 0x3d1a0
movapd %xmm1, %xmm4
jae 0x7d3b
jmp 0x7e09
movapd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm0
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/distributions/mixGaussianLogUniform.cpp
// Function: DNest4::mixGaussianLogUniform::perturb(double&, DNest4::RNG&) const
double mixGaussianLogUniform::perturb(double& x, RNG& rng) const
{
    x = cdf(x);
    x += rng.randh();
    wrap(x, 0.0, 1.0);
    if (rng.rand_int(2) == 0)
        x = G.cdf_inverse(x);
    else
        x = LU.cdf_inverse(x);
    return 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, (%rbx)
movq %r15, %rdi
callq 0x39b0e
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x3518c(%rip), %xmm1    # 0x3d030
xorpd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x3a047
movq %r15, %rdi
movl $0x2, %esi
callq 0x39bf8
movsd (%rbx), %xmm0
testl %eax, %eax
je 0x7ed3
addq $0x48, %r14
movq %r14, %rdi
callq 0x3bb6c
jmp 0x7edf
addq $0x28, %r14
movq %r14, %rdi
callq 0x3b30a
movsd %xmm0, (%rbx)
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVConditionalPrior.cpp
// Function: RVConditionalPrior::from_prior(DNest4::RNG&)
void RVConditionalPrior::from_prior(RNG& rng)
{
    if(hyperpriors)
    {
        center = log_muP_prior->generate(rng);
        width = wP_prior->generate(rng);
        muK = exp(log_muK_prior->generate(rng));
    }
}

// Assembly:
leaq 0x3a3db(%rip), %rax     # 0x428de
cmpb $0x1, (%rax)
jne 0x8554
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
callq 0x3ac1c
movsd %xmm0, 0x8(%rbx)
movq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x3ac1c
movsd %xmm0, 0x10(%rbx)
movq 0x90(%rbx), %rdi
movq %r14, %rsi
callq 0x3ac1c
callq 0x6730
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVConditionalPrior.cpp
// Function: RVConditionalPrior::perturb_hyperparameters(DNest4::RNG&)
double RVConditionalPrior::perturb_hyperparameters(RNG& rng)
{
    double logH = 0.;

    if(hyperpriors)
    {
        int which = rng.rand_int(3);

        if(which == 0)
            log_muP_prior->perturb(center, rng);
        else if(which == 1)
            wP_prior->perturb(width, rng);
        else
        {
            muK = log(muK);
            log_muK_prior->perturb(muK, rng);
            muK = exp(muK);
        }
    }

    return logH;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x3a37c(%rip), %rax     # 0x428de
cmpb $0x1, (%rax)
jne 0x85d9
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x3, %esi
callq 0x39bf8
cmpl $0x1, %eax
je 0x858d
testl %eax, %eax
jne 0x85a5
movq 0x70(%rbx), %rdi
addq $0x8, %rbx
jmp 0x8598
movq 0x80(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3ac36
jmp 0x85d9
leaq 0x18(%rbx), %r15
movsd 0x18(%rbx), %xmm0
callq 0x63c0
movsd %xmm0, 0x18(%rbx)
movq 0x90(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3ac36
movsd 0x18(%rbx), %xmm0
callq 0x6730
movsd %xmm0, 0x18(%rbx)
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVConditionalPrior.cpp
// Function: RVConditionalPrior::log_pdf(std::vector<double, std::allocator<double>> const&) const
double RVConditionalPrior::log_pdf(const std::vector<double>& vec) const
{
    if(hyperpriors)
    {
        if(vec[2] < 0. || vec[2] > 2.*M_PI ||
           vec[3] < 0. || vec[3] >= 1.0 ||
           vec[4] < 0. || vec[4] > 2.*M_PI)
             return -1E300;

        Pprior->setpars(center, width);
        Kprior->setpars(muK);
    }
    else
    {
        if(vec[0] < 1. || vec[0] > 1E4 ||
           vec[1] < 0. ||
           vec[2] < 0. || vec[2] > 2.*M_PI ||
           vec[3] < 0. || vec[3] >= 1.0 ||
           vec[4] < 0. || vec[4] > 2.*M_PI)
             return -1E300;
    }

    return Pprior->log_pdf(vec[0]) + 
           Kprior->log_pdf(vec[1]) + 
           phiprior->log_pdf(vec[2]) + 
           eprior->log_pdf(vec[3]) + 
           wprior->log_pdf(vec[4]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3a2eb(%rip), %rcx     # 0x428de
movq (%rsi), %rax
cmpb $0x1, (%rcx)
jne 0x8712
movsd 0x10(%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
movsd 0x34bc4(%rip), %xmm0    # 0x3d1d8
ja 0x8741
ucomisd 0x34b2e(%rip), %xmm1    # 0x3d150
ja 0x8741
movsd 0x18(%rax), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
ja 0x8741
ucomisd 0x349ed(%rip), %xmm1    # 0x3d030
jae 0x8741
movsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm2
ja 0x8741
ucomisd 0x34af0(%rip), %xmm1    # 0x3d150
ja 0x8741
movq 0x20(%r14), %rdi
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%r14), %rdi
movsd 0x18(%r14), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq (%rbx), %rax
movsd (%rax), %xmm1
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movapd %xmm1, %xmm0
callq *0x20(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%r14), %rdi
movq (%rbx), %rax
movsd 0x8(%rax), %xmm0
movq (%rdi), %rax
callq *0x20(%rax)
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%r14), %rdi
movq (%rbx), %rax
movsd 0x10(%rax), %xmm0
movq (%rdi), %rax
callq *0x20(%rax)
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%r14), %rdi
movq (%rbx), %rax
movsd 0x18(%rax), %xmm0
movq (%rdi), %rax
callq *0x20(%rax)
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x60(%r14), %rdi
movq (%rbx), %rax
movsd 0x20(%rax), %xmm0
movq (%rdi), %rax
callq *0x20(%rax)
addsd (%rsp), %xmm0
jmp 0x8741
movsd (%rax), %xmm1
movsd 0x34912(%rip), %xmm0    # 0x3d030
ucomisd %xmm1, %xmm0
movsd 0x34aae(%rip), %xmm0    # 0x3d1d8
ja 0x8741
ucomisd 0x34aac(%rip), %xmm1    # 0x3d1e0
ja 0x8741
xorpd %xmm2, %xmm2
ucomisd 0x8(%rax), %xmm2
jbe 0x8749
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x10(%rax), %xmm3
ucomisd %xmm3, %xmm2
ja 0x8741
ucomisd 0x349f4(%rip), %xmm3    # 0x3d150
ja 0x8741
movsd 0x18(%rax), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x8741
ucomisd 0x348bb(%rip), %xmm2    # 0x3d030
jae 0x8741
movsd 0x20(%rax), %xmm2
ucomisd %xmm2, %xmm3
ja 0x8741
ucomisd 0x349c6(%rip), %xmm2    # 0x3d150
jbe 0x8692
jmp 0x8741
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVConditionalPrior.cpp
// Function: RVConditionalPrior::from_uniform(std::vector<double, std::allocator<double>>&) const
void RVConditionalPrior::from_uniform(std::vector<double>& vec) const
{
    if(hyperpriors)
    {
        Pprior->setpars(center, width);
        Kprior->setpars(muK);
    }

    vec[0] = Pprior->cdf_inverse(vec[0]);
    vec[1] = Kprior->cdf_inverse(vec[1]);
    vec[2] = phiprior->cdf_inverse(vec[2]);
    vec[3] = eprior->cdf_inverse(vec[3]);
    vec[4] = wprior->cdf_inverse(vec[4]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3a13b(%rip), %rax     # 0x428de
cmpb $0x1, (%rax)
jne 0x87cd
movq 0x20(%r14), %rdi
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%r14), %rdi
movsd 0x18(%r14), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%r14), %rdi
movq (%rbx), %rax
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movsd %xmm0, (%rax)
movq 0x30(%r14), %rdi
movsd 0x8(%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x50(%r14), %rdi
movsd 0x10(%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x10(%rax)
movq 0x40(%r14), %rdi
movsd 0x18(%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x18(%rax)
movq 0x60(%r14), %rdi
movsd 0x20(%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVConditionalPrior.cpp
// Function: RVConditionalPrior::to_uniform(std::vector<double, std::allocator<double>>&) const
void RVConditionalPrior::to_uniform(std::vector<double>& vec) const
{
    if(hyperpriors)
    {
        Pprior->setpars(center, width);
        Kprior->setpars(muK);
    }

    vec[0] = Pprior->cdf(vec[0]);
    vec[1] = Kprior->cdf(vec[1]);
    vec[2] = phiprior->cdf(vec[2]);
    vec[3] = eprior->cdf(vec[3]);
    vec[4] = wprior->cdf(vec[4]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3a083(%rip), %rax     # 0x428de
cmpb $0x1, (%rax)
jne 0x8885
movq 0x20(%r14), %rdi
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%r14), %rdi
movsd 0x18(%r14), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%r14), %rdi
movq (%rbx), %rax
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movsd %xmm0, (%rax)
movq 0x30(%r14), %rdi
movsd 0x8(%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x8(%rax)
movq 0x50(%r14), %rdi
movsd 0x10(%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x10(%rax)
movq 0x40(%r14), %rdi
movsd 0x18(%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x18(%rax)
movq 0x60(%r14), %rdi
movsd 0x20(%rax), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
movsd %xmm0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/Data.cpp
// Function: operator>>(std::istream&, std::vector<double, std::allocator<double>>&)
istream& operator >> ( istream& ins, record_t& record )
  // Let's overload the stream input operator to read a list of CSV fields (which a CSV record).
  //-----------------------------------------------------------------------------
  {
  // make sure that the returned record contains only the stuff we read now
  record.clear();

  // read the entire line into a string (a CSV record is terminated by a newline)
  string line;
  getline( ins, line );

  // now we'll use a stringstream to separate the fields out of the line
  stringstream ss( line );

  // convert each field to a double and 
  // add the newly-converted field to the end of the record
  double f;
  while (ss >> f)
    record.push_back(f);

  // Now we have read a single line, converted into a list of fields, converted the fields
  // from strings to doubles, and stored the results in the argument record, so
  // we just return the argument stream as required for this kind of input overload function.
  return ins;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x915e
movq %rax, 0x8(%r14)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6780
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x6620
leaq 0x28(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x62c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x91f7
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x91ea
movsd (%rsp), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x91b4
movq %r14, %rdi
movq %r12, %rdx
callq 0xc042
jmp 0x91b4
movq 0x46d2a(%rip), %rsi     # 0x4ff28
leaq 0x28(%rsp), %rdi
callq 0x6360
leaq 0xa8(%rsp), %rdi
callq 0x6130
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x922c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6460
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9242
movq %rax, %rbx
jmp 0x9268
movq %rax, %rbx
movq 0x46cd7(%rip), %rsi     # 0x4ff28
leaq 0x28(%rsp), %rdi
callq 0x6360
leaq 0xa8(%rsp), %rdi
callq 0x6130
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x927f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/Data.cpp
// Function: operator>>(std::istream&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
istream& operator >> ( istream& ins, data_t& data )
// Overload the stream input operator to read a list of CSV records. We only 
// need to worry about reading records, and not fields.
{
  // make sure that the returned data only contains the CSV data we read here
  // data.clear();

  // for every record we can read from the file, append it to our resulting data
  // except if it's in the header
  record_t record;
  while (ins >> record)
    {
      data.push_back(record);
    }

  // return the argument stream
  return ins;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x913b
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x92ce
movq %r14, %rdi
movq %r15, %rsi
callq 0xb98a
jmp 0x92a8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x92e4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x930a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/Data.cpp
// Function: Data::get_max_RV_span() const
double Data::get_max_RV_span() const
{
  // for multiple instruments, calculate individual RV spans and return largest
  if (datamulti) {
    double span = 0.0;
    for(size_t j=0; j<number_instruments; j++)
    {
      vector<double> obsy;
      for (size_t i=0; i<y.size(); ++i) 
      {
        if (obsi[i] == j + 1) 
        {
          obsy.push_back(y[i]);
        }
      }
      const auto min = std::min_element(obsy.begin(), obsy.end());
      const auto max = std::max_element(obsy.begin(), obsy.end());
      double this_obs_span = *max - *min;
      if (this_obs_span > span)
        span = this_obs_span;
    }
    return span;
  }

  // for one instrument only, this is easy
  else {
    return get_RV_span();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xf4(%rdi)
jne 0xb35d
cmpl $0x0, 0xf8(%rbx)
je 0xb372
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movq %rsp, %r14
movsd %xmm1, 0x28(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
incq %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x48(%rbx), %rdx
movslq (%rdx,%r13,4), %rdx
cmpq %rdx, %r15
jne 0xb295
leaq (%rax,%r12), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0xb285
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0xb295
movq %r14, %rdi
callq 0xc042
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
addq $0x8, %r12
cmpq %rdx, %r13
jb 0xb255
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
cmpq %rax, %rdi
sete %dl
leaq 0x8(%rdi), %rcx
cmpq %rax, %rcx
sete %sil
orb %dl, %sil
movq %rdi, %rdx
movq %rdi, %rsi
jne 0xb31b
movsd (%rdi), %xmm0
movapd %xmm0, %xmm1
movq %rcx, %rsi
movq %rdi, %rdx
movsd (%rsi), %xmm2
ucomisd %xmm2, %xmm1
cmovaq %rsi, %rdx
minsd %xmm1, %xmm2
addq $0x8, %rsi
movapd %xmm2, %xmm1
cmpq %rax, %rsi
jne 0xb2de
movq %rdi, %rsi
movsd (%rcx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rcx, %rsi
maxsd %xmm0, %xmm1
addq $0x8, %rcx
movapd %xmm1, %xmm0
cmpq %rax, %rcx
jne 0xb2fe
movsd (%rsi), %xmm0
subsd (%rdx), %xmm0
testq %rdi, %rdi
je 0xb341
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm0, 0x20(%rsp)
callq 0x6460
movsd 0x20(%rsp), %xmm0
maxsd 0x28(%rsp), %xmm0
movslq 0xf8(%rbx), %rax
movapd %xmm0, %xmm1
cmpq %rax, %r15
jb 0xb22c
jmp 0xb376
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb180
xorpd %xmm0, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb39d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/Data.cpp
// Function: Data::get_adjusted_RV_var() const
double Data::get_adjusted_RV_var() const
{
    int ni;
    double sum, mean;
    std::vector<double> rva(t.size());

    for(size_t j=0; j<number_instruments; j++)
    {
      ni = 0;
      sum = 0.;
      for (size_t i=0; i<t.size(); i++)
        if(obsi[i] == j+1) {sum += y[i]; ni++;}
      mean = sum / ni;
      // cout << "sum: " << sum << endl;
      // cout << "mean: " << mean << endl;
      for (size_t i=0; i<t.size(); i++)
        if(obsi[i] == j+1) rva[i] = y[i] - mean;
    }

    mean = std::accumulate(rva.begin(), rva.end(), 0.0) / rva.size();
    double accum = 0.0;
    std::for_each (rva.begin(), rva.end(), [&](const double d) {
        accum += (d - mean) * (d - mean);
    });
    return accum / (y.size()-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
subq (%rdi), %rsi
sarq $0x3, %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xbc58
movslq 0xf8(%rbx), %rax
testq %rax, %rax
je 0xb47b
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movq 0x48(%rbx), %rdi
cmpq $0x1, %rsi
adcq $0x0, %rsi
xorl %r9d, %r9d
cmpq %rcx, %rdx
je 0xb470
leaq 0x1(%r9), %r8
movq 0x18(%rbx), %r11
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
xorl %r14d, %r14d
movslq (%rdi,%r14,4), %r15
cmpq %r15, %r8
jne 0xb425
addsd (%r11,%r14,8), %xmm0
incl %r10d
incq %r14
cmpq %r14, %rsi
jne 0xb413
cmpq %rcx, %rdx
je 0xb470
xorps %xmm1, %xmm1
cvtsi2sd %r10d, %xmm1
divsd %xmm1, %xmm0
movq 0x18(%rbx), %r9
movq 0x18(%rsp), %r10
xorl %r11d, %r11d
movslq (%rdi,%r11,4), %r14
cmpq %r14, %r8
jne 0xb463
movsd (%r9,%r11,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r10,%r11,8)
incq %r11
cmpq %r11, %rsi
jne 0xb44a
movq %r8, %r9
jmp 0xb476
incq %r9
movq %r9, %r8
cmpq %rax, %r8
jne 0xb3fc
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xb4ef
xorpd %xmm3, %xmm3
movq %rdi, %rcx
addsd (%rcx), %xmm3
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0xb491
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
movq %rcx, %xmm1
punpckldq 0x31b5b(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31b63(%rip), %xmm1    # 0x3d020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm3
xorpd %xmm0, %xmm0
movq %rdi, %rcx
movsd (%rcx), %xmm1
subsd %xmm3, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0xb4d4
jmp 0xb4f3
xorpd %xmm0, %xmm0
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
testq %rdi, %rdi
je 0xb519
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm0, 0x10(%rsp)
callq 0x6460
movsd 0x10(%rsp), %xmm0
subq %r14, %rbx
sarq $0x3, %rbx
decq %rbx
movq %rbx, %xmm2
punpckldq 0x31ae0(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x31ae8(%rip), %xmm2    # 0x3d020
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: RVmodel::add_known_object()
void RVmodel::add_known_object()
{
    auto data = Data::get_instance();
    auto t = data.get_t();
    double f, v, ti, Tp;
    for(int j=0; j<n_known_object; j++)
    {
        for(size_t i=0; i<t.size(); i++)
        {
            ti = t[i];
            Tp = data.M0_epoch-(KO_P[j]*KO_phi[j])/(2.*M_PI);
            f = kepler::true_anomaly(ti, KO_P[j], KO_e[j], Tp);
            v = KO_K[j] * (cos(f+KO_w[j]) + KO_e[j]*cos(KO_w[j]));
            mu[i] += v;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0x405d0(%rip), %rsi     # 0x50400
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x15552
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xc290
leaq 0x32a97(%rip), %rax     # 0x428e8
movslq (%rax), %r14
movq 0x20(%rsp), %rdi
testq %r14, %r14
jle 0xff7a
movq 0x28(%rsp), %rax
xorl %r15d, %r15d
movsd 0x2d876(%rip), %xmm2    # 0x3d6e8
cmpq %rdi, %rax
je 0xff6b
xorl %r12d, %r12d
xorl %r13d, %r13d
movsd (%rdi,%r13,8), %xmm0
movq 0x308(%rbx), %rax
movq 0x338(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movq 0x350(%rbx), %rax
movsd (%rax,%r15,8), %xmm3
mulsd %xmm1, %xmm3
divsd %xmm2, %xmm3
addsd 0x138(%rsp), %xmm3
movsd (%rcx,%r15,8), %xmm2
callq 0xffbc
movq 0x320(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, 0x10(%rsp)
addsd (%rcx,%r15,8), %xmm0
callq 0x6790
movsd %xmm0, 0x8(%rsp)
movq 0x338(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rsp)
movsd (%rcx,%r15,8), %xmm0
callq 0x6790
movsd 0x2d7cd(%rip), %xmm2    # 0x3d6e8
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x380(%rbx), %rax
fldt (%rax,%r12)
faddl 0x18(%rsp)
fstpt (%rax,%r12)
incq %r13
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
addq $0x10, %r12
cmpq %rcx, %r13
jb 0xfe81
jmp 0xff6e
movq %rdi, %rax
incq %r15
cmpq %r14, %r15
jne 0xfe72
testq %rdi, %rdi
je 0xff8c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
leaq 0x38(%rsp), %rdi
callq 0xb8d2
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xb8d2
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: kepler::true_anomaly(double, double, double, double)
double true_anomaly(double t, double period, double ecc, double t_peri)
    {
        double n = 2.*M_PI/period;  // mean motion
        double M = n*(t - t_peri);  // mean anomaly

        // Solve Kepler's equation
        double E = kepler(M, ecc);

        // Calculate true anomaly
        double cosE = cos(E);
        double f = acos( (cosE - ecc)/( 1 - ecc*cosE ) );
        // acos gives the principal values ie [0:PI]
        // when E goes above PI we need another condition
        if(E > M_PI)
            f = 2*M_PI - f;

        return f;

    }

// Assembly:
subq $0x18, %rsp
movaps %xmm2, %xmm4
movsd %xmm2, 0x8(%rsp)
movsd 0x2d17f(%rip), %xmm2    # 0x3d150
divsd %xmm1, %xmm2
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
movaps %xmm4, %xmm1
callq 0x15258
movsd %xmm0, 0x10(%rsp)
callq 0x6790
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm2
movsd 0x2d026(%rip), %xmm0    # 0x3d030
subsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x6420
movsd 0x2d12d(%rip), %xmm3    # 0x3d150
subsd %xmm0, %xmm3
movsd 0x2d6b1(%rip), %xmm1    # 0x3d6e0
cmpltsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm2
andnpd %xmm0, %xmm2
andpd %xmm3, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: RVmodel::remove_known_object()
void RVmodel::remove_known_object()
{
    auto data = Data::get_instance();
    auto t = data.get_t();
    double f, v, ti, Tp;
    // cout << "in remove_known_obj: " << KO_P[1] << endl;
    for(int j=0; j<n_known_object; j++)
    {
        for(size_t i=0; i<t.size(); i++)
        {
            ti = t[i];
            Tp = data.M0_epoch-(KO_P[j]*KO_phi[j])/(2.*M_PI);
            f = kepler::true_anomaly(ti, KO_P[j], KO_e[j], Tp);
            v = KO_K[j] * (cos(f+KO_w[j]) + KO_e[j]*cos(KO_w[j]));
            mu[i] -= v;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0x40396(%rip), %rsi     # 0x50400
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x15552
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xc290
leaq 0x3285d(%rip), %rax     # 0x428e8
movslq (%rax), %r14
movq 0x20(%rsp), %rdi
testq %r14, %r14
jle 0x101b4
movq 0x28(%rsp), %rax
xorl %r15d, %r15d
movsd 0x2d63c(%rip), %xmm2    # 0x3d6e8
cmpq %rdi, %rax
je 0x101a5
xorl %r12d, %r12d
xorl %r13d, %r13d
movsd (%rdi,%r13,8), %xmm0
movq 0x308(%rbx), %rax
movq 0x338(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movq 0x350(%rbx), %rax
movsd (%rax,%r15,8), %xmm3
mulsd %xmm1, %xmm3
divsd %xmm2, %xmm3
addsd 0x138(%rsp), %xmm3
movsd (%rcx,%r15,8), %xmm2
callq 0xffbc
movq 0x320(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, 0x10(%rsp)
addsd (%rcx,%r15,8), %xmm0
callq 0x6790
movsd %xmm0, 0x8(%rsp)
movq 0x338(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm0
movsd %xmm0, (%rsp)
movsd (%rcx,%r15,8), %xmm0
callq 0x6790
movsd 0x2d593(%rip), %xmm2    # 0x3d6e8
mulsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x380(%rbx), %rax
fldt (%rax,%r12)
fsubl 0x18(%rsp)
fstpt (%rax,%r12)
incq %r13
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
addq $0x10, %r12
cmpq %rcx, %r13
jb 0x100bb
jmp 0x101a8
movq %rdi, %rax
incq %r15
cmpq %r14, %r15
jne 0x100ac
testq %rdi, %rdi
je 0x101c6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6460
leaq 0x38(%rsp), %rdi
callq 0xb8d2
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xb8d2
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::kepler(double, double)
double kepler(double M, double ecc)
    {
        double tol;
        if (ecc < 0.8) tol = 1e-14;
        else tol = 1e-13;

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

    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movsd %xmm0, 0x20(%rsp)
movsd 0x28a13(%rip), %xmm2    # 0x3d718
xorl %eax, %eax
movsd %xmm1, 0x18(%rsp)
ucomisd %xmm1, %xmm2
seta %al
leaq 0x28a65(%rip), %rcx     # 0x3d780
movsd (%rcx,%rax,8), %xmm1
movsd %xmm1, 0x28(%rsp)
movsd 0x28422(%rip), %xmm1    # 0x3d150
callq 0x6530
movsd %xmm0, 0x10(%rsp)
callq 0x6790
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x60b0
movsd 0x282d9(%rip), %xmm1    # 0x3d030
movsd 0x28(%rsp), %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm2, %xmm1
movsd 0x20(%rsp), %xmm1
jbe 0x14eae
movsd 0x289a7(%rip), %xmm4    # 0x3d720
movsd 0x8(%rsp), %xmm5
mulsd %xmm5, %xmm4
movsd 0x18(%rsp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm1, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm4
mulsd 0x28293(%rip), %xmm2    # 0x3d038
addsd %xmm1, %xmm4
addsd %xmm3, %xmm2
mulsd %xmm5, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd 0x10(%rsp), %xmm4
movl $0x64, %ebx
movapd %xmm4, %xmm1
movsd %xmm4, 0x8(%rsp)
movsd %xmm1, 0x20(%rsp)
movapd %xmm4, %xmm0
callq 0x6790
movsd %xmm0, 0x38(%rsp)
movsd 0x18(%rsp), %xmm2
mulsd %xmm0, %xmm2
addsd 0x28933(%rip), %xmm2    # 0x3d728
movsd %xmm2, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x60b0
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm7
mulsd %xmm7, %xmm1
movapd %xmm1, %xmm2
subsd %xmm4, %xmm2
addsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm3
movsd 0x28364(%rip), %xmm5    # 0x3d198
mulsd %xmm5, %xmm3
mulsd %xmm1, %xmm3
movsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm3
addsd %xmm1, %xmm3
movapd %xmm1, %xmm6
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd 0x38(%rsp), %xmm3
mulsd 0x288a4(%rip), %xmm3    # 0x3d708
mulsd %xmm1, %xmm3
mulsd %xmm5, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm7, %xmm0
mulsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm6, %xmm0
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
decl %ebx
je 0x14eae
movapd %xmm1, %xmm0
subsd %xmm4, %xmm0
andpd 0x282c2(%rip), %xmm0    # 0x3d160
ucomisd 0x28(%rsp), %xmm0
movapd %xmm1, %xmm4
ja 0x14dc8
movapd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::keplerstart3(double, double)
double keplerstart3(double e, double M)
    {
        double t34 = e*e;
        double t35 = e*t34;
        double t33 = cos(M);
        return M + (-0.5*t35 + e + (t34 + 1.5*t33*t35)*t33)*sin(M);
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm1, 0x10(%rsp)
movapd %xmm0, %xmm2
movsd %xmm0, 0x20(%rsp)
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
mulsd %xmm2, %xmm0
movsd %xmm0, 0x18(%rsp)
movapd %xmm1, %xmm0
callq 0x6790
movsd 0x28147(%rip), %xmm2    # 0x3d038
movsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm2
addsd 0x20(%rsp), %xmm2
movsd 0x28817(%rip), %xmm1    # 0x3d720
mulsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
addsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x60b0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::eps3(double, double, double)
double eps3(double e, double M, double x)
    {
        double t1 = cos(x);
        double t2 = -1 + e*t1;
        double t3 = sin(x);
        double t4 = e*t3;
        double t5 = -x + t4 + M;
        double t6 = t5/(0.5*t5*t4/t2+t2);

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

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

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

// Assembly:
pushq %rbx
subq $0x40, %rsp
movsd 0x28706(%rip), %xmm4    # 0x3d718
xorl %eax, %eax
movsd %xmm2, 0x18(%rsp)
ucomisd %xmm2, %xmm4
seta %al
leaq 0x28758(%rip), %rcx     # 0x3d780
movsd (%rcx,%rax,8), %xmm2
movsd %xmm2, 0x28(%rsp)
movsd 0x28115(%rip), %xmm2    # 0x3d150
movapd %xmm2, %xmm4
divsd %xmm1, %xmm4
subsd %xmm3, %xmm0
mulsd %xmm4, %xmm0
movsd %xmm0, 0x20(%rsp)
movapd %xmm2, %xmm1
callq 0x6530
movsd %xmm0, 0x10(%rsp)
callq 0x6790
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x60b0
movsd 0x27fb2(%rip), %xmm1    # 0x3d030
movsd 0x28(%rsp), %xmm2
addsd %xmm2, %xmm1
ucomisd %xmm2, %xmm1
movsd 0x20(%rsp), %xmm1
jbe 0x151d5
movsd 0x28680(%rip), %xmm4    # 0x3d720
movsd 0x8(%rsp), %xmm5
mulsd %xmm5, %xmm4
movsd 0x18(%rsp), %xmm3
movapd %xmm3, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm1, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm4
mulsd 0x27f6c(%rip), %xmm2    # 0x3d038
addsd %xmm1, %xmm4
addsd %xmm3, %xmm2
mulsd %xmm5, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd 0x10(%rsp), %xmm4
movl $0x64, %ebx
movapd %xmm4, %xmm1
movsd %xmm4, 0x8(%rsp)
movsd %xmm1, 0x20(%rsp)
movapd %xmm4, %xmm0
callq 0x6790
movsd %xmm0, 0x38(%rsp)
movsd 0x18(%rsp), %xmm2
mulsd %xmm0, %xmm2
addsd 0x2860c(%rip), %xmm2    # 0x3d728
movsd %xmm2, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x60b0
movsd 0x8(%rsp), %xmm4
movapd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm7
mulsd %xmm7, %xmm1
movapd %xmm1, %xmm2
subsd %xmm4, %xmm2
addsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm3
movsd 0x2803d(%rip), %xmm5    # 0x3d198
mulsd %xmm5, %xmm3
mulsd %xmm1, %xmm3
movsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm3
addsd %xmm1, %xmm3
movapd %xmm1, %xmm6
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movsd 0x38(%rsp), %xmm3
mulsd 0x2857d(%rip), %xmm3    # 0x3d708
mulsd %xmm1, %xmm3
mulsd %xmm5, %xmm0
addsd %xmm3, %xmm0
mulsd %xmm7, %xmm0
mulsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm6, %xmm0
divsd %xmm0, %xmm2
subsd %xmm2, %xmm1
decl %ebx
je 0x151d5
movapd %xmm1, %xmm0
subsd %xmm4, %xmm0
andpd 0x27f9b(%rip), %xmm0    # 0x3d160
ucomisd 0x28(%rsp), %xmm0
movapd %xmm1, %xmm4
ja 0x150ef
movapd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/src/RVmodel.cpp
// Function: murison::true_anomaly(double, double, double, double)
double true_anomaly(double t, double period, double ecc, double t_peri)
{
    double E = ecc_anomaly(t, period, ecc, t_peri);
    // double E = solve_kepler(t, period, ecc, t_peri);
    double cosE = cos(E);
    double f = acos( (cosE - ecc)/( 1 - ecc*cosE ) );
    // acos gives the principal values ie [0:PI]
    // when E goes above PI we need another condition
    if(E > M_PI)
      f = 2*M_PI - f;

    return f;
}

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

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

	int num = max_num_components;

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

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

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

    components_changed_flag = true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0xe8, %rdi
xorl %esi, %esi
callq 0xbb4c
leaq 0x100(%rbx), %rdi
xorl %esi, %esi
callq 0xbb4c
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x84fc
movl 0x8(%rbx), %r15d
cmpb $0x0, 0xc(%rbx)
jne 0x157c0
movl (%rbx), %eax
testl %eax, %eax
je 0x157af
cmpl $0x1, %eax
jne 0x157c0
movl 0x8(%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x39bf8
movl %eax, %r15d
movq %r14, %rdi
callq 0x39a4e
leal 0x1(%r15), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x2788d(%rip), %xmm2    # 0x3d030
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x15778
jmp 0x157c0
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x39bf8
movl %eax, %r15d
leaq 0xb8(%rbx), %rdi
xorl %esi, %esi
callq 0xbb4c
leaq 0xd0(%rbx), %rdi
xorl %esi, %esi
callq 0xbb4c
movl $0x0, 0xb4(%rbx)
testl %r15d, %r15d
jle 0x157fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x183e6
decl %r15d
jne 0x157eb
movb $0x1, 0xb0(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::consolidate_diff()
void RJObject<ConditionalPrior>::consolidate_diff()
{
	if(ConditionalPrior::weight_parameter == -1)
	{
		std::cerr<<"# WARNING: consolidate_diff() failed."<<std::endl;
		return;
	}

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

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

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x1, %rax
jne 0x15960
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
cmpq 0x8(%rax), %rcx
jge 0x159b1
xorl %eax, %eax
jmp 0x15962
jge 0x159d0
cmpq $0x1, 0x18(%rdi)
jne 0x15992
movsd (%rsi), %xmm0
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x10(%rdi)
imulq 0x8(%rcx), %rax
shlq $0x3, %rax
addq (%rcx), %rax
movsd %xmm0, (%rax,%rdx,8)
movq %rdi, %rax
popq %rcx
retq
leaq 0x2898c(%rip), %rdi     # 0x3e325
leaq 0x287a5(%rip), %rsi     # 0x3e145
leaq 0x2888c(%rip), %rcx     # 0x3e233
movl $0x49, %edx
callq 0x62b0
leaq 0x2882c(%rip), %rdi     # 0x3e1e4
leaq 0x28786(%rip), %rsi     # 0x3e145
leaq 0x2886d(%rip), %rcx     # 0x3e233
movl $0x45, %edx
callq 0x62b0
leaq 0x288f7(%rip), %rdi     # 0x3e2ce
leaq 0x28767(%rip), %rsi     # 0x3e145
leaq 0x2884e(%rip), %rcx     # 0x3e233
movl $0x48, %edx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::perturb(DNest4::RNG&, bool)
double RJObject<ConditionalPrior>::perturb(RNG& rng, bool hyperparameters)
{
	if(max_num_components == 0)
		return 0.;

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

	double logH = 0.;

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

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

	return logH;
}

// Assembly:
xorpd %xmm1, %xmm1
cmpl $0x0, 0x8(%rdi)
je 0x15ddc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xe8(%rdi), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xbb4c
leaq 0x100(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xbb4c
movb $0x1, 0xb0(%rbx)
cmpb $0x1, 0xc(%rbx)
jne 0x15cf3
movq %r14, %rdi
movl $0x2, %esi
callq 0x39bf8
incl %eax
jmp 0x15d00
movq %r14, %rdi
movl $0x3, %esi
callq 0x39bf8
testb %bpl, %bpl
jne 0x15d0a
cmpl $0x1, %eax
je 0x15cdc
testl %eax, %eax
je 0x15d2d
cmpl $0x1, %eax
je 0x15d45
cmpl $0x2, %eax
xorpd %xmm1, %xmm1
jne 0x15dce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18d9c
jmp 0x15d38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18ae6
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0x15dce
movq %r14, %rdi
callq 0x39a4e
movsd 0x27443(%rip), %xmm1    # 0x3d198
ucomisd %xmm0, %xmm1
jae 0x15da5
leaq 0xb8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x18bfe
leaq 0x10(%rbx), %rdi
addq $0xd0, %rbx
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x3c242
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x18bfe
movsd (%rsp), %xmm1
jmp 0x15dce
leaq 0x10(%rbx), %rdi
leaq 0xb8(%rbx), %rdx
leaq 0xd0(%rbx), %rcx
movq %r14, %rsi
callq 0x3c0b0
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movb $0x0, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
nop