LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %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, -0x80(%rbp)
callq 0x77a0
movq -0x80(%rbp), %rdi
leaq 0x10eac5(%rip), %rax    # 0x1193d0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
xorps %xmm0, %xmm0
movsd 0xac70f(%rip), %xmm1    # 0xb7030
callq 0xb4df0
callq 0xab10
movq %rax, %rcx
movq -0x80(%rbp), %rax
movsd 0x100(%rcx), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0xac802(%rip), %xmm0    # 0xb7158
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0xac7d7(%rip), %xmm0    # 0xb7158
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x48(%rbp), %xmm0
movaps 0xac7bf(%rip), %xmm1    # 0xb7160
pand %xmm1, %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x50(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
movsd 0xac791(%rip), %xmm1    # 0xb7150
callq 0x6820
movsd %xmm0, -0x90(%rbp)
movsd -0x58(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
movsd 0xac772(%rip), %xmm1    # 0xb7150
callq 0x6820
movaps %xmm0, %xmm1
movsd -0x90(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x6410
movq -0x80(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
leaq -0x78(%rbp), %rdi
callq 0xb4df0
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
leaq -0x78(%rbp), %rsi
callq 0xab20
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd 0xac40f(%rip), %xmm0    # 0xb71a0
movsd %xmm0, -0x18(%rbp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0xae61
movq -0x38(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0xac371(%rip), %xmm1    # 0xb7150
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
subsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xae05
jp 0xae05
jmp 0xae61
movq -0x38(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x38(%rbp), %rdi
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x40(%rbp), %xmm1
subsd -0x10(%rbp), %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xae50
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0xae5a
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xae5c
jmp 0xadb4
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %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 0xac0ea(%rip), %xmm1    # 0xb7030
callq 0xb33e0
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0xb28c0
cmpl $0x0, %eax
jne 0xaf7d
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0xb4ef0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xaf9a
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0xb5bc0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xba2c3(%rip), %rax     # 0xc59a2
testb $0x1, (%rax)
je 0xb74d
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0xc680
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb44c0
movq -0x18(%rbp), %rdi
movsd %xmm0, 0x8(%rdi)
addq $0x80, %rdi
callq 0xc680
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb44c0
movq -0x18(%rbp), %rdi
movsd %xmm0, 0x10(%rdi)
addq $0x90, %rdi
callq 0xc680
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xb44c0
callq 0x6870
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0xba21b(%rip), %rax     # 0xc59a2
testb $0x1, (%rax)
je 0xb848
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xb28c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xb7ca
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
callq 0xc680
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
callq 0xb4500
jmp 0xb846
cmpl $0x1, -0x1c(%rbp)
jne 0xb7f6
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
callq 0xc680
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rsi
movq -0x10(%rbp), %rdx
callq 0xb4500
jmp 0xb844
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x6430
movq -0x28(%rbp), %rdi
movsd %xmm0, 0x18(%rdi)
addq $0x90, %rdi
callq 0xc680
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
movq -0x10(%rbp), %rdx
callq 0xb4500
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x6870
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0xb846
jmp 0xb848
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xb9da3(%rip), %rax     # 0xc59a2
testb $0x1, (%rax)
je 0xbc46
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xc680
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc680
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xc680
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc6a0
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc6a0
movsd -0x60(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x30, %rdi
callq 0xc680
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xc6a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xc6a0
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x50, %rdi
callq 0xc680
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xc6a0
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xc6a0
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x40, %rdi
callq 0xc680
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xc6a0
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0xc6a0
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x60, %rdi
callq 0xc680
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xc6a0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xc6a0
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x156c0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x66b0
movq -0x1d8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x60c0
jmp 0x110ee
movl $0x10, %edi
movl $0x8, %esi
callq 0x156e0
movl %eax, -0x1dc(%rbp)
jmp 0x11105
movl -0x1dc(%rbp), %edx
leaq -0x1c8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6760
jmp 0x1111d
jmp 0x1111f
leaq -0x1c8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x6440
movq %rax, -0x1e8(%rbp)
jmp 0x1113b
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6600
movb %al, -0x1e9(%rbp)
jmp 0x11159
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x11165
jmp 0x111a1
movq -0x10(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x15700
jmp 0x11177
jmp 0x1111f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x111d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x63d0
jmp 0x111d1
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x63d0
leaq -0x30(%rbp), %rdi
callq 0x6948
movq -0x1f8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x6948
movq -0x38(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x77c0
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x110b0
movq %rax, -0x40(%rbp)
jmp 0x1121c
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6600
movb %al, -0x41(%rbp)
jmp 0x11234
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1123d
jmp 0x11265
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15770
jmp 0x1124c
jmp 0x11209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78f0
jmp 0x11280
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x78f0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: j-faria[P]kima/src/Data.cpp
// Function: Data::get_RV_var() const
double Data::get_RV_var() const
{
    double sum = std::accumulate(std::begin(y), std::end(y), 0.0);
    double mean =  sum / y.size();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x98(%rbp)
callq 0x16690
movq -0x98(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x166c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x16630
movq -0x98(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
callq 0x7c90
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movq %rax, %xmm1
movaps 0xa3740(%rip), %xmm2    # 0xb7010
movaps %xmm2, -0x90(%rbp)
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xa373d(%rip), %xmm2    # 0xb7020
movaps %xmm2, -0x80(%rbp)
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x16690
movq -0x98(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x166c0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x139a0
movq -0x98(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x7c90
movaps -0x90(%rbp), %xmm3
movaps -0x80(%rbp), %xmm2
movsd -0x68(%rbp), %xmm0
decq %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
testb $0x1, 0xf4(%rax)
je 0x14040
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x90(%rbp), %rcx
movq -0x20(%rbp), %rax
movslq 0xf8(%rcx), %rcx
cmpq %rcx, %rax
jae 0x14034
leaq -0x38(%rbp), %rdi
callq 0x77c0
movq $0x0, -0x40(%rbp)
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x98(%rbp)
addq $0x18, %rdi
callq 0x7c90
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x13f42
movq -0x90(%rbp), %rdi
addq $0x48, %rdi
movq -0x40(%rbp), %rsi
callq 0x166f0
movslq (%rax), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jne 0x13f2f
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
movq -0x40(%rbp), %rsi
callq 0xa6a0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x15700
jmp 0x13f13
jmp 0x13f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x78f0
jmp 0x1405f
jmp 0x13f31
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x13ea3
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x7890
movq -0xa8(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x78c0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x16710
movq %rax, -0xa0(%rbp)
jmp 0x13f7c
movq -0xa0(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x7890
movq -0xb8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x78c0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x16750
movq %rax, -0xb0(%rbp)
jmp 0x13fc1
movq -0xb0(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x8970
movsd (%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8970
movsd -0xc0(%rbp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x88(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x1401a
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x78f0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13e77
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x14051
movq -0x90(%rbp), %rdi
callq 0x13da0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6830
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd 0x96a04(%rip), %xmm0    # 0xb7158
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x26790
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x68e0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0x96860(%rip), %xmm2    # 0xb7030
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x64d0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x96ed1(%rip), %xmm1    # 0xb76c0
ucomisd %xmm1, %xmm0
jbe 0x20807
movsd 0x9695b(%rip), %xmm0    # 0xb7158
subsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x9142e(%rip), %xmm0    # 0xb76d8
ucomisd -0x10(%rbp), %xmm0
jbe 0x262c0
movsd 0x9142f(%rip), %xmm0    # 0xb76e8
movsd %xmm0, -0x18(%rbp)
jmp 0x262cd
movsd 0x91418(%rip), %xmm0    # 0xb76e0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x90e7e(%rip), %xmm1    # 0xb7158
callq 0x6660
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x263a0
movsd %xmm0, -0x28(%rbp)
movsd 0x90d30(%rip), %xmm0    # 0xb7030
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x26387
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
callq 0x26460
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x2b830
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x64, -0x3c(%rbp)
jne 0x26385
jmp 0x26387
jmp 0x2631b
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x68e0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
movsd 0x90c3d(%rip), %xmm2    # 0xb7038
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm2
movsd 0x912e0(%rip), %xmm0    # 0xb76f0
mulsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x60e0
movsd -0x38(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x30(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x68e0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x911fc(%rip), %xmm1    # 0xb7698
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x60e0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd -0x38(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd 0x90c9d(%rip), %xmm1    # 0xb7198
mulsd -0x40(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
divsd -0x28(%rbp), %xmm1
addsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
xorps %xmm2, %xmm2
mulsd -0x20(%rbp), %xmm2
mulsd -0x48(%rbp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
movsd 0x90c4a(%rip), %xmm3    # 0xb7198
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd -0x8(%rbp), %xmm1
movsd -0x48(%rbp), %xmm3
movsd -0x28(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd 0x91134(%rip), %xmm0    # 0xb76d8
ucomisd -0x18(%rbp), %xmm0
jbe 0x265ba
movsd 0x91135(%rip), %xmm0    # 0xb76e8
movsd %xmm0, -0x28(%rbp)
jmp 0x265c7
movsd 0x9111e(%rip), %xmm0    # 0xb76e0
movsd %xmm0, -0x28(%rbp)
movsd 0x90b89(%rip), %xmm0    # 0xb7158
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x90b5a(%rip), %xmm1    # 0xb7158
callq 0x6660
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x263a0
movsd %xmm0, -0x48(%rbp)
movsd 0x90a0c(%rip), %xmm0    # 0xb7030
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x266ab
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
callq 0x26460
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
subsd -0x48(%rbp), %xmm0
callq 0x2b830
movsd %xmm0, -0x50(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
cmpl $0x64, -0x5c(%rbp)
jne 0x266a9
jmp 0x266ab
jmp 0x2663f
movsd -0x58(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
callq 0x26580
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x68e0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
movsd 0x908f0(%rip), %xmm2    # 0xb7030
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x64d0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x90f61(%rip), %xmm1    # 0xb76c0
ucomisd %xmm1, %xmm0
jbe 0x26777
movsd 0x909eb(%rip), %xmm0    # 0xb7158
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/src/RVmodel.cpp
// Function: kepler::kepler(double, double)
double kepler(double M, double ecc)
    {
        const double two_pi = 2 * M_PI;

        // Wrap M into the range [0, 2*pi]
        M = npy_mod(M, two_pi);

        //
        bool high = M > M_PI;
        if (high)
            M = two_pi - M;

        // Get the starter
        double ome = 1.0 - ecc;
        double E = get_markley_starter(M, ecc, ome);

        // Refine this estimate using a high order Newton step
        E = refine_estimate(M, ecc, ome, E);

        if (high)
            E = two_pi - E;

        return E;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x909ae(%rip), %xmm0    # 0xb7158
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x9099c(%rip), %xmm1    # 0xb7158
callq 0x2b850
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x90eed(%rip), %xmm1    # 0xb76c0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x267f7
movsd 0x9096b(%rip), %xmm0    # 0xb7158
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd 0x90831(%rip), %xmm0    # 0xb7030
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
callq 0x2b900
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
callq 0x2bac0
movsd %xmm0, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0x26858
movsd 0x9090a(%rip), %xmm0    # 0xb7158
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xe8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15ca0
movq -0x20(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
xorl %eax, %eax
movl %eax, %esi
callq 0x15ca0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xb6c0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x14(%rbp)
testb $0x1, 0xc(%rax)
jne 0x26fda
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x26f8e
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0xb28c0
movl %eax, -0x14(%rbp)
jmp 0x26fd8
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x26fd6
jmp 0x26f99
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0xb28c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb26f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm2
movsd 0x90066(%rip), %xmm1    # 0xb7030
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jae 0x26f99
jmp 0x26fd6
jmp 0x26fd8
jmp 0x26fda
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15ca0
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15ca0
movq -0x20(%rbp), %rax
movl $0x0, 0xb4(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x27037
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ebb0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27017
movq -0x20(%rbp), %rax
movb $0x1, 0xb0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x15d80
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x270ff
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rsi
callq 0x15d30
movq %rax, %rdi
movl $0x1, %esi
callq 0xc6a0
movq -0x18(%rbp), %rdi
movsd 0x905db(%rip), %xmm0    # 0xb7698
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq %rdi, %rax
addq $0xe8, %rax
movq %rax, -0x28(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq -0x10(%rbp), %rsi
callq 0x15d30
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x15770
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2706c
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x15c80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x2f8f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x27478
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x1, 0x18(%rax)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x2f8d0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jge 0x2744c
movb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x2744c
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x27455
jmp 0x27457
jmp 0x27476
leaq 0x90e66(%rip), %rdi     # 0xb82c4
leaq 0x90d89(%rip), %rsi     # 0xb81ee
movl $0x45, %edx
leaq 0x90ea2(%rip), %rcx     # 0xb8313
callq 0x6340
jmp 0x27478
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x2f8f0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jge 0x274a4
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x274a4
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x274ad
jmp 0x274af
jmp 0x274ce
leaq 0x90f37(%rip), %rdi     # 0xb83ed
leaq 0x90d31(%rip), %rsi     # 0xb81ee
movl $0x48, %edx
leaq 0x90e4a(%rip), %rcx     # 0xb8313
callq 0x6340
movq -0x20(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jne 0x274db
jmp 0x274fa
leaq 0x90f62(%rip), %rdi     # 0xb8444
leaq 0x90d05(%rip), %rsi     # 0xb81ee
movl $0x49, %edx
leaq 0x90e1e(%rip), %rcx     # 0xb8313
callq 0x6340
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, -0x48(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
callq 0x2f760
movsd -0x48(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd %xmm0, (%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::print(std::ostream&) const
void RJObject<ConditionalPrior>::print(std::ostream& out) const
{
	out<<num_dimensions<<' '<<max_num_components<<' ';
	conditional_prior.print(out); out<<' ';
	out<<num_components<<' ';

	// Write out components
	for(int j=0; j<num_dimensions; j++)
	{
		for(int i=0; i<num_components; i++)
			out<<components[i][j]<<' ';

		// Pad with zeros (turned-off components)
		for(int i=num_components; i<max_num_components; i++)
			out<<0.<<' ';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x6810
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x6810
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0xbfa0
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x6590
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xb4(%rax), %esi
callq 0x6810
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x2b2a3
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0xb4(%rcx), %eax
jge 0x2b256
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0xb8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x27af0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0xa6a0
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x68f0
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b1fa
movq -0x28(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2b293
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x68f0
movq %rax, %rdi
movl $0x20, %esi
callq 0x6590
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2b263
jmp 0x2b295
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b1e3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/src/RVmodel.cpp
// Function: kepler::npy_mod(double, double)
inline double npy_mod(double a, double b)
    {
        double mod = fmod(a, b);

        if (!b)
        {
            // If b == 0, return result of fmod. For IEEE is nan
            return mod;
        }

        // adjust fmod result to conform to Python convention of remainder
        if (mod)
        {
            if ((b < 0) != (mod < 0))
            {
            mod += b;
            }
        }
        else
        {
            // if mod is zero ensure correct sign
            mod = copysign(0, b);
        }

        return mod;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x6660
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2b892
jp 0x2b892
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2b8f5
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2b8a4
jp 0x2b8a4
jmp 0x2b8da
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x2b8d8
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x2b8eb
movsd -0x18(%rbp), %xmm0
xorl %edi, %edi
callq 0x2c410
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: j-faria[P]kima/src/RVmodel.cpp
// Function: kepler::get_markley_starter(double, double, double)
inline double get_markley_starter(double M, double ecc, double ome)
    {
        // M must be in the range [0, pi)
        const double FACTOR1 = 3 * M_PI / (M_PI - 6 / M_PI);
        const double FACTOR2 = 1.6 / (M_PI - 6 / M_PI);

        double M2 = M * M;
        double alpha = FACTOR1 + FACTOR2 * (M_PI - M) / (1 + ecc);
        double d = 3 * ome + alpha * ecc;
        double alphad = alpha * d;
        double r = (3 * alphad * (d - ome) + M2) * M;
        double q = 2 * alphad * ome - M2;
        double q2 = q * q;
        double w = pow(std::abs(r) + sqrt(q2 * q + r * r), 2.0 / 3);
        return (2 * r * w / (w * w + w * q + q2) + M) / d;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd 0x8bde9(%rip), %xmm0    # 0xb7708
movsd %xmm0, -0x20(%rbp)
movsd 0x8bde4(%rip), %xmm0    # 0xb7710
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x8bd78(%rip), %xmm0    # 0xb76c0
subsd -0x8(%rbp), %xmm0
movsd 0x8bdbb(%rip), %xmm1    # 0xb7710
mulsd %xmm0, %xmm1
movsd 0x8b6cf(%rip), %xmm0    # 0xb7030
addsd -0x10(%rbp), %xmm0
divsd %xmm0, %xmm1
movsd 0x8bd96(%rip), %xmm0    # 0xb7708
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
movsd 0x8bd6e(%rip), %xmm2    # 0xb7700
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x8bd4a(%rip), %xmm0    # 0xb7700
mulsd -0x48(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
subsd -0x18(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x8b76c(%rip), %xmm0    # 0xb7150
mulsd -0x48(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
mulsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0x2b830
movsd %xmm0, -0x70(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
movsd -0x50(%rbp), %xmm1
mulsd -0x50(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x6410
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd 0x8bc8e(%rip), %xmm1    # 0xb76f8
callq 0x6820
movsd %xmm0, -0x68(%rbp)
movsd 0x8b6d4(%rip), %xmm0    # 0xb7150
mulsd -0x50(%rbp), %xmm0
mulsd -0x68(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movsd -0x68(%rbp), %xmm3
movsd -0x68(%rbp), %xmm2
mulsd -0x58(%rbp), %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
addsd -0x60(%rbp), %xmm1
divsd %xmm1, %xmm0
addsd -0x8(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::add_component(DNest4::RNG&)
double RJObject<ConditionalPrior>::add_component(RNG& rng)
{
	if(num_components >= max_num_components)
	{
		std::cerr<<"# WARNING: Trying to add component ";
		std::cerr<<"but already full!"<<std::endl;
		return 0.;
	}

	// Increment counter
	num_components++;

	// Generate component
	std::vector<double> component(num_dimensions);
	for(int j=0; j<num_dimensions; j++)
		component[j] = rng.rand();
	u_components.push_back(component);
	conditional_prior.from_uniform(component);
	components.push_back(component);

	// Accumulate added/removed component info
	added.push_back(component);

	return 0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl 0xb4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jl 0x2ec15
movq 0xeb40e(%rip), %rdi     # 0x119fe8
leaq 0x891bf(%rip), %rsi     # 0xb7da0
callq 0x64f0
movq 0xeb3fb(%rip), %rdi     # 0x119fe8
leaq 0x891d0(%rip), %rsi     # 0xb7dc4
callq 0x64f0
movq %rax, %rdi
movq 0xeb315(%rip), %rsi     # 0x119f18
callq 0x6530
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2ed33
movq -0x50(%rbp), %rax
movl 0xb4(%rax), %ecx
incl %ecx
movl %ecx, 0xb4(%rax)
movslq 0x4(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x7e10
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x163f0
jmp 0x2ec4f
leaq -0x31(%rbp), %rdi
callq 0x8190
movl $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x2eccd
movq -0x18(%rbp), %rdi
callq 0xb26f0
movsd %xmm0, -0x68(%rbp)
jmp 0x2ec7b
movslq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc6a0
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x2ec5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x8190
jmp 0x2ed3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x78f0
jmp 0x2ed3e
movq -0x50(%rbp), %rdi
addq $0xd0, %rdi
leaq -0x30(%rbp), %rsi
callq 0x15770
jmp 0x2ece3
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbe0
jmp 0x2ecf6
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x15770
jmp 0x2ed0c
movq -0x50(%rbp), %rdi
addq $0xe8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x15770
jmp 0x2ed22
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x78f0
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)