LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3edef(%rip), %rcx     # 0x4700e
movq (%rsi), %rax
cmpb $0x1, (%rcx)
jne 0x833e
movsd 0x10(%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
movsd 0x33f98(%rip), %xmm0    # 0x3c1d8
ja 0x836d
ucomisd 0x33f02(%rip), %xmm1    # 0x3c150
ja 0x836d
movsd 0x18(%rax), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
ja 0x836d
ucomisd 0x33dc1(%rip), %xmm1    # 0x3c030
jae 0x836d
movsd 0x20(%rax), %xmm1
ucomisd %xmm1, %xmm2
ja 0x836d
ucomisd 0x33ec4(%rip), %xmm1    # 0x3c150
ja 0x836d
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 0x836d
movsd (%rax), %xmm1
movsd 0x33ce6(%rip), %xmm0    # 0x3c030
ucomisd %xmm1, %xmm0
movsd 0x33e82(%rip), %xmm0    # 0x3c1d8
ja 0x836d
ucomisd 0x33e80(%rip), %xmm1    # 0x3c1e0
ja 0x836d
xorpd %xmm2, %xmm2
ucomisd 0x8(%rax), %xmm2
jbe 0x8375
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsd 0x10(%rax), %xmm3
ucomisd %xmm3, %xmm2
ja 0x836d
ucomisd 0x33dc8(%rip), %xmm3    # 0x3c150
ja 0x836d
movsd 0x18(%rax), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x836d
ucomisd 0x33c8f(%rip), %xmm2    # 0x3c030
jae 0x836d
movsd 0x20(%rax), %xmm2
ucomisd %xmm2, %xmm3
ja 0x836d
ucomisd 0x33d9a(%rip), %xmm2    # 0x3c150
jbe 0x82be
jmp 0x836d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ec3f(%rip), %rax     # 0x4700e
cmpb $0x1, (%rax)
jne 0x83f9
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_O2/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 0x3eb87(%rip), %rax     # 0x4700e
cmpb $0x1, (%rax)
jne 0x84b1
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_O2/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 %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x9441
movq %rax, 0x8(%r14)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6090
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x6600
leaq 0x30(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x62c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x94a1
movq %r14, %rdi
movq %r12, %rsi
callq 0xb120
jmp 0x947b
leaq 0x30(%rsp), %rdi
callq 0x6360
leaq 0x8(%rsp), %rdi
callq 0x6798
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x94c9
movq %rax, %rbx
jmp 0x94db
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6360
leaq 0x8(%rsp), %rdi
callq 0x6798
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9420
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x9531
movq %r14, %rdi
movq %r15, %rsi
callq 0xb142
jmp 0x950b
movq %rsp, %rdi
callq 0x716e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x716e
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/src/Data.cpp
// Function: Data::topslope() const
double Data::topslope() const
{
  if (datamulti) {
    double slope = 0.0;
    for(size_t j=0; j<number_instruments; j++)
    {
      vector<double> obsy, obst;
      for (size_t i=0; i<y.size(); ++i) {
        if (obsi[i] == j + 1) {
          obsy.push_back(y[i]);
          obst.push_back(t[i]);
        }
      }
      const auto miny = std::min_element(obsy.begin(), obsy.end());
      const auto maxy = std::max_element(obsy.begin(), obsy.end());
      const auto mint = std::min_element(obst.begin(), obst.end());
      const auto maxt = std::max_element(obst.begin(), obst.end());
      double this_obs_topslope = (*maxy - *miny) / (*maxt - *mint);
      if (this_obs_topslope > slope)
        slope = this_obs_topslope;
    }
    return slope;
  }

  else {
    return get_RV_span() / get_timespan();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xf4(%rdi)
jne 0xaaa1
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
leaq 0x10(%rsp), %rbp
leaq 0x30(%rsp), %r15
movslq 0xf8(%rbx), %rax
cmpq %rax, %r14
jae 0xaac5
andq $0x0, 0x20(%rsp)
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
andq $0x0, 0x40(%rsp)
movapd %xmm1, 0x30(%rsp)
incq %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0xaa17
movq 0x48(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r14
jne 0xaa0e
addq %r12, %rsi
movq %rbp, %rdi
callq 0xb120
movq (%rbx), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0xb120
incq %r13
addq $0x8, %r12
jmp 0xa9d4
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb51d
movq %rax, %r12
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb548
movq %rax, %r13
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb51d
movq %rax, %rbp
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb548
movsd (%r13), %xmm1
subsd (%r12), %xmm1
movsd (%rax), %xmm0
subsd (%rbp), %xmm0
divsd %xmm0, %xmm1
maxsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movq %r15, %rdi
callq 0x716e
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
callq 0x716e
movsd 0x8(%rsp), %xmm0
jmp 0xa999
movq %rbx, %rdi
callq 0xaaf8
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0xb41a
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaad8
jmp 0xaad8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x716e
leaq 0x10(%rsp), %rdi
callq 0x716e
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xac01
xorps %xmm0, %xmm0
xorl %r12d, %r12d
leaq 0x10(%rsp), %r14
movslq 0xf8(%rbx), %rax
cmpq %rax, %r12
jae 0xac16
movsd %xmm0, 0x8(%rsp)
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
incq %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0xabb8
movq 0x48(%rbx), %rax
movslq (%rax,%r13,4), %rax
cmpq %rax, %r12
jne 0xabaf
addq %r15, %rsi
movq %r14, %rdi
callq 0xb120
incq %r13
addq $0x8, %r15
jmp 0xab83
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb51d
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb548
movsd (%rax), %xmm0
subsd (%r15), %xmm0
maxsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x716e
movsd 0x8(%rsp), %xmm0
jmp 0xab56
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xaaf8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xac26
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x716e
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %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 0xb320
movslq 0xf8(%rbx), %rax
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x3, %rcx
xorl %edx, %edx
cmpq %rax, %rdx
je 0xacdc
movq 0x18(%rbx), %rsi
movq 0x48(%rbx), %rdi
incq %rdx
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
cmpq %r8, %rcx
je 0xaca8
movslq (%rdi,%r8,4), %r10
cmpq %r10, %rdx
jne 0xaca3
addsd (%rsi,%r8,8), %xmm0
incl %r9d
incq %r8
jmp 0xac8c
cvtsi2sd %r9d, %xmm1
divsd %xmm1, %xmm0
movq 0x18(%rsp), %r8
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0xac72
movslq (%rdi,%r9,4), %r10
cmpq %r10, %rdx
jne 0xacd7
movsd (%rsi,%r9,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r8,%r9,8)
incq %r9
jmp 0xacb9
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
xorpd %xmm0, %xmm0
movq %rax, %rdx
cmpq %rcx, %rdx
je 0xacfc
addsd (%rdx), %xmm0
addq $0x8, %rdx
jmp 0xaced
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq %rdx, %xmm1
punpckldq 0x312fd(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31305(%rip), %xmm1    # 0x3c020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
cmpq %rcx, %rax
je 0xad4a
movsd (%rax), %xmm1
subsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm2
addq $0x8, %rax
jmp 0xad2f
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
decq %rax
movq %rax, %xmm0
punpckldq 0x312aa(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x312b2(%rip), %xmm0    # 0x3c020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x716e
movsd 0x10(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55eb6(%rip), %rsi     # 0x64580
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x11aa2
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xb866
leaq 0x3892d(%rip), %rax     # 0x47018
movl (%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r14, %r15
je 0xe7f5
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0xe7ed
movsd (%rax,%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 0x2df3c(%rip), %xmm3    # 0x3c690
addsd 0x138(%rsp), %xmm3
movsd (%rcx,%r15,8), %xmm2
callq 0xe83e
movq 0x320(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, 0x10(%rsp)
addsd (%rcx,%r15,8), %xmm0
callq 0x6750
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 0x6750
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
addq $0x10, %r12
jmp 0xe707
incq %r15
jmp 0xe6f8
leaq 0x20(%rsp), %rdi
callq 0x716e
leaq 0x38(%rsp), %rdi
callq 0xb0be
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xe82c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x716e
leaq 0x38(%rsp), %rdi
callq 0xb0be
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d8fd(%rip), %xmm2    # 0x3c150
divsd %xmm1, %xmm2
subsd %xmm3, %xmm0
mulsd %xmm2, %xmm0
movaps %xmm4, %xmm1
callq 0x119fc
movsd %xmm0, 0x10(%rsp)
callq 0x6750
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm2
movsd 0x2d7a4(%rip), %xmm0    # 0x3c030
subsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x6420
movsd 0x2d8ab(%rip), %xmm3    # 0x3c150
subsd %xmm0, %xmm3
movsd 0x2ddd7(%rip), %xmm1    # 0x3c688
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_O2/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 0x55c94(%rip), %rsi     # 0x64580
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x11aa2
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xb866
leaq 0x3870b(%rip), %rax     # 0x47018
movl (%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r14, %r15
je 0xea17
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0xea0f
movsd (%rax,%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 0x2dd1a(%rip), %xmm3    # 0x3c690
addsd 0x138(%rsp), %xmm3
movsd (%rcx,%r15,8), %xmm2
callq 0xe83e
movq 0x320(%rbx), %rax
movq 0x368(%rbx), %rcx
movsd (%rax,%r15,8), %xmm1
movsd %xmm1, 0x10(%rsp)
addsd (%rcx,%r15,8), %xmm0
callq 0x6750
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 0x6750
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
addq $0x10, %r12
jmp 0xe929
incq %r15
jmp 0xe91a
leaq 0x20(%rsp), %rdi
callq 0x716e
leaq 0x38(%rsp), %rdi
callq 0xb0be
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0xea4e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x716e
leaq 0x38(%rsp), %rdi
callq 0xb0be
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd 0x2aff5(%rip), %xmm2    # 0x3c6b8
xorl %eax, %eax
ucomisd %xmm1, %xmm2
seta %al
leaq 0x2b05d(%rip), %rcx     # 0x3c730
movsd (%rcx,%rax,8), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x2aa6a(%rip), %xmm1    # 0x3c150
callq 0x6510
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x18(%rsp)
callq 0x11766
movsd (%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x2a920(%rip), %xmm0    # 0x3c030
addsd 0x10(%rsp), %xmm0
pushq $0x64
popq %rbx
ucomisd 0x10(%rsp), %xmm0
jbe 0x1175c
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd %xmm2, (%rsp)
callq 0x117ef
movsd (%rsp), %xmm2
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
andpd 0x2aa0c(%rip), %xmm0    # 0x3c160
movapd %xmm1, %xmm2
decl %ebx
jne 0x11719
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6750
movsd 0x2a899(%rip), %xmm2    # 0x3c038
movsd 0x18(%rsp), %xmm3
mulsd %xmm3, %xmm2
addsd 0x20(%rsp), %xmm2
movsd 0x2af09(%rip), %xmm1    # 0x3c6c0
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_O2/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 0x6750
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x2aea3(%rip), %xmm1    # 0x3c6c8
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 0x2a93e(%rip), %xmm3    # 0x3c198
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 0x2ae42(%rip), %xmm4    # 0x3c6d0
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_O2/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 $0x20, %rsp
movsd %xmm2, 0x8(%rsp)
movsd 0x2adf2(%rip), %xmm4    # 0x3c6b8
xorl %eax, %eax
ucomisd %xmm2, %xmm4
seta %al
leaq 0x2ae5a(%rip), %rcx     # 0x3c730
movsd (%rcx,%rax,8), %xmm2
movsd %xmm2, 0x10(%rsp)
movsd 0x2a867(%rip), %xmm2    # 0x3c150
movapd %xmm2, %xmm4
divsd %xmm1, %xmm4
subsd %xmm3, %xmm0
mulsd %xmm4, %xmm0
movsd %xmm0, (%rsp)
movapd %xmm2, %xmm1
callq 0x6510
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, 0x18(%rsp)
callq 0x11766
movsd (%rsp), %xmm1
movapd %xmm0, %xmm2
movsd 0x2a703(%rip), %xmm0    # 0x3c030
addsd 0x10(%rsp), %xmm0
pushq $0x64
popq %rbx
ucomisd 0x10(%rsp), %xmm0
jbe 0x11979
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd %xmm2, (%rsp)
callq 0x117ef
movsd (%rsp), %xmm2
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
andpd 0x2a7ef(%rip), %xmm0    # 0x3c160
movapd %xmm1, %xmm2
decl %ebx
jne 0x11936
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x118b3
movsd %xmm0, 0x10(%rsp)
callq 0x6750
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm2
movsd 0x2a679(%rip), %xmm0    # 0x3c030
subsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x6420
movsd 0x2a780(%rip), %xmm2    # 0x3c150
subsd %xmm0, %xmm2
movsd 0x2acac(%rip), %xmm1    # 0x3c688
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_O2/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:
subq $0x38, %rsp
movsd %xmm1, (%rsp)
movsd 0x2a743(%rip), %xmm1    # 0x3c150
callq 0x14157
movapd %xmm0, 0x20(%rsp)
movsd 0x2a730(%rip), %xmm1    # 0x3c150
subsd %xmm0, %xmm1
movsd 0x2ac5c(%rip), %xmm3    # 0x3c688
cmpltsd %xmm0, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movapd %xmm3, 0x10(%rsp)
movsd 0x2a5e5(%rip), %xmm2    # 0x3c030
movsd (%rsp), %xmm1
subsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm3, %xmm0
callq 0x141b3
movapd %xmm0, %xmm3
movapd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x142e0
movapd 0x20(%rsp), %xmm1
ucomisd 0x2abfd(%rip), %xmm1    # 0x3c688
jbe 0x11a9d
movsd 0x2a6bb(%rip), %xmm1    # 0x3c150
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0xe8, %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xb246
leaq 0x100(%rbx), %rdi
xorl %esi, %esi
callq 0xb246
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x812a
movl 0x8(%rbx), %r15d
cmpb $0x0, 0xc(%rbx)
jne 0x11cbf
movl (%rbx), %eax
testl %eax, %eax
je 0x11cae
cmpl $0x1, %eax
jne 0x11cbf
movl 0x8(%rbx), %esi
incl %esi
movq %r14, %rdi
callq 0x38cc4
movl %eax, %r15d
movq %r14, %rdi
callq 0x38b70
leal 0x1(%r15), %eax
cvtsi2sd %eax, %xmm1
movsd 0x2a38e(%rip), %xmm2    # 0x3c030
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x11c7a
jmp 0x11cbf
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x38cc4
movl %eax, %r15d
leaq 0xb8(%rbx), %rdi
xorl %esi, %esi
callq 0xb246
leaq 0xd0(%rbx), %rdi
xorl %esi, %esi
callq 0xb246
andl $0x0, 0xb4(%rbx)
testl %r15d, %r15d
cmovgl %r15d, %r12d
subl $0x1, %r12d
jb 0x11cfc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14d22
jmp 0x11ce9
movb $0x1, 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
leaq 0x100(%rdi), %rbx
leaq 0xe8(%rdi), %r15
xorl %r12d, %r12d
pushq $0x18
popq %r13
xorl %ebp, %ebp
movq 0x100(%r14), %rsi
movq 0x108(%r14), %rax
subq %rsi, %rax
cqto
idivq %r13
cmpq %rax, %rbp
jae 0x11d78
movq (%rsi,%r12), %rax
addq %r12, %rsi
movsd 0x8(%rax), %xmm0
xorps 0x2a9ad(%rip), %xmm0    # 0x3c710
movlps %xmm0, 0x8(%rax)
movq %r15, %rdi
callq 0xb142
incq %rbp
addq $0x18, %r12
jmp 0x11d35
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb23e
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11e6b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
cmpq 0x8(%rax), %rcx
jge 0x11eb6
xorl %eax, %eax
jmp 0x11e6d
jge 0x11ecf
cmpq $0x1, 0x18(%rdi)
jne 0x11e9d
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 0x2b45b(%rip), %rdi     # 0x3d2ff
leaq 0x2b274(%rip), %rsi     # 0x3d11f
leaq 0x2b35b(%rip), %rcx     # 0x3d20d
pushq $0x49
jmp 0x11ee6
leaq 0x2b301(%rip), %rdi     # 0x3d1be
leaq 0x2b25b(%rip), %rsi     # 0x3d11f
leaq 0x2b342(%rip), %rcx     # 0x3d20d
pushq $0x45
jmp 0x11ee6
leaq 0x2b3d2(%rip), %rdi     # 0x3d2a8
leaq 0x2b242(%rip), %rsi     # 0x3d11f
leaq 0x2b329(%rip), %rcx     # 0x3d20d
pushq $0x48
popq %rdx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1229b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0xe8, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0xb246
leaq 0x100(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xb246
movb $0x1, 0xb0(%rbx)
pushq $0x2
popq %r13
pushq $0x3
popq %r15
cmpb $0x1, 0xc(%rbx)
jne 0x121b0
movq %r14, %rdi
movl %r13d, %esi
callq 0x38cc4
incl %eax
jmp 0x121bb
movq %r14, %rdi
movl %r15d, %esi
callq 0x38cc4
testb %bpl, %bpl
jne 0x121c5
cmpl $0x1, %eax
je 0x1219b
testl %eax, %eax
je 0x121e8
cmpl $0x1, %eax
je 0x12200
cmpl $0x2, %eax
xorpd %xmm1, %xmm1
jne 0x1228d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15758
jmp 0x121f3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1557e
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0x1228d
movq %r14, %rdi
callq 0x38b70
movsd 0x29f88(%rip), %xmm1    # 0x3c198
ucomisd %xmm0, %xmm1
jae 0x12264
leaq 0xb8(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x1567a
leaq 0x10(%rbx), %rdi
addq $0xd0, %rbx
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3b01e
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1567a
movsd 0x8(%rsp), %xmm1
jmp 0x1228d
leaq 0x10(%rbx), %rdi
leaq 0xb8(%rbx), %rdx
leaq 0xd0(%rbx), %rcx
movq %r14, %rsi
callq 0x3aec4
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
movb $0x0, 0xb0(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %esi
movq %rbx, %rdi
callq 0x66b0
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x66b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x852e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6480
movl 0xb4(%r14), %esi
movq %rbx, %rdi
callq 0x66b0
movq %rax, %rdi
movl %ebp, %esi
callq 0x6480
xorl %r15d, %r15d
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jge 0x13f9c
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0xb4(%r14), %rbp
cmpq %rbp, %r13
jge 0x13f91
movq 0xb8(%r14), %rax
movq (%rax,%r12), %rax
movsd (%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
pushq $0x20
popq %rsi
callq 0x6480
incq %r13
addq $0x18, %r12
jmp 0x13f40
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6610
movq %rax, %rdi
pushq $0x20
popq %rsi
callq 0x6480
incl %ebp
cmpl 0x8(%r14), %ebp
jl 0x13f79
incq %r15
jmp 0x13f31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/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:
subq $0x18, %rsp
movapd %xmm1, (%rsp)
callq 0x6510
movapd (%rsp), %xmm4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm4
jne 0x14176
jnp 0x141ae
ucomisd %xmm1, %xmm0
jne 0x1417e
jnp 0x141a2
movapd %xmm0, %xmm2
cmpnltpd %xmm1, %xmm2
movapd %xmm4, %xmm3
cmpltpd %xmm1, %xmm3
xorpd %xmm2, %xmm3
movd %xmm3, %eax
testb $0x1, %al
jne 0x141ae
addsd %xmm4, %xmm0
jmp 0x141ae
andpd 0x28566(%rip), %xmm4    # 0x3c710
movapd %xmm4, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x48, %rsp
movapd %xmm0, %xmm4
movsd 0x284c5(%rip), %xmm5    # 0x3c688
subsd %xmm0, %xmm5
mulsd 0x28509(%rip), %xmm5    # 0x3c6d8
movsd 0x27e59(%rip), %xmm3    # 0x3c030
addsd %xmm1, %xmm3
divsd %xmm3, %xmm5
addsd 0x284f9(%rip), %xmm5    # 0x3c6e0
mulsd %xmm0, %xmm4
mulsd %xmm5, %xmm1
movsd 0x28471(%rip), %xmm3    # 0x3c668
movapd %xmm2, %xmm6
mulsd %xmm3, %xmm6
addsd %xmm1, %xmm6
mulsd %xmm6, %xmm5
mulsd %xmm5, %xmm3
movsd %xmm6, 0x8(%rsp)
movapd %xmm6, %xmm1
subsd %xmm2, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm4, %xmm1
movsd %xmm0, 0x18(%rsp)
mulsd %xmm0, %xmm1
addsd %xmm5, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
movapd 0x27f19(%rip), %xmm2    # 0x3c160
andpd %xmm1, %xmm2
movapd %xmm1, 0x30(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm0, (%rsp)
movsd %xmm5, 0x10(%rsp)
mulsd %xmm5, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x14278
sqrtsd %xmm0, %xmm0
jmp 0x14289
movapd %xmm2, 0x20(%rsp)
callq 0x63a0
movapd 0x20(%rsp), %xmm2
addsd %xmm0, %xmm2
movsd 0x28453(%rip), %xmm1    # 0x3c6e8
movapd %xmm2, %xmm0
callq 0x66c0
movapd 0x30(%rsp), %xmm2
addsd %xmm2, %xmm2
mulsd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
addsd 0x18(%rsp), %xmm2
divsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/src/RVmodel.cpp
// Function: kepler::refine_estimate(double, double, double, double)
inline double refine_estimate(double M, double ecc, double ome, double E)
    {
        double sE = E - sin(E);
        double cE = 1 - cos(E);

        double f_0 = ecc * sE + E * ome - M;
        double f_1 = ecc * cE + ome;
        double f_2 = ecc * (E - sE);
        double f_3 = 1 - f_1;
        double d_3 = -f_0 / (f_1 - 0.5 * f_0 * f_2 / f_1);
        double d_4 = -f_0 / (f_1 + 0.5 * d_3 * f_2 + (d_3 * d_3) * f_3 / 6);
        double d_42 = d_4 * d_4;
        double dE = -f_0 /
                (f_1 + 0.5 * d_4 * f_2 + d_4 * d_4 * f_3 / 6 - d_42 * d_4 * f_2 / 24);

        return E + dE;
    }

// Assembly:
subq $0x28, %rsp
movsd %xmm3, (%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd %xmm3, %xmm0
callq 0x60b0
movsd (%rsp), %xmm1
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x6750
movsd 0x27d08(%rip), %xmm1    # 0x3c030
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm3
movsd (%rsp), %xmm0
mulsd %xmm0, %xmm3
movsd 0x18(%rsp), %xmm4
movapd %xmm4, %xmm8
movsd 0x8(%rsp), %xmm6
mulsd %xmm6, %xmm8
addsd %xmm3, %xmm8
subsd 0x20(%rsp), %xmm8
mulsd %xmm4, %xmm2
movapd %xmm4, %xmm7
addsd %xmm5, %xmm2
movapd %xmm0, %xmm4
subsd %xmm6, %xmm4
movapd 0x2838f(%rip), %xmm5    # 0x3c710
xorpd %xmm8, %xmm5
movsd 0x27e0a(%rip), %xmm3    # 0x3c198
movapd %xmm8, %xmm6
mulsd %xmm3, %xmm6
mulsd %xmm7, %xmm4
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm6
divsd %xmm2, %xmm6
movapd %xmm2, %xmm7
subsd %xmm6, %xmm7
movapd %xmm5, %xmm6
divsd %xmm7, %xmm6
movapd %xmm6, %xmm7
mulsd %xmm3, %xmm7
mulsd %xmm4, %xmm7
mulsd %xmm6, %xmm6
mulsd %xmm1, %xmm6
divsd 0x2831d(%rip), %xmm6    # 0x3c6f0
addsd %xmm2, %xmm7
addsd %xmm7, %xmm6
divsd %xmm6, %xmm5
movapd %xmm5, %xmm6
mulsd %xmm5, %xmm6
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
mulsd %xmm6, %xmm5
unpcklpd %xmm5, %xmm1            # xmm1 = xmm1[0],xmm5[0]
unpcklpd %xmm4, %xmm6            # xmm6 = xmm6[0],xmm4[0]
mulpd %xmm1, %xmm6
divpd 0x28335(%rip), %xmm6    # 0x3c740
addsd %xmm6, %xmm3
unpckhpd %xmm6, %xmm6            # xmm6 = xmm6[1,1]
subsd %xmm6, %xmm3
divsd %xmm3, %xmm8
subsd %xmm8, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl 0xb4(%rdi), %eax
cmpl 0x8(%rdi), %eax
jge 0x14d7b
movq %rsi, %r14
movq %rdi, %rbx
incl %eax
movl %eax, 0xb4(%rdi)
movslq 0x4(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb320
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x14daa
movq %r14, %rdi
callq 0x38b70
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x14d5a
movq 0x4f266(%rip), %rbx     # 0x63fe8
leaq 0x28013(%rip), %rsi     # 0x3cd9c
movq %rbx, %rdi
callq 0x6430
leaq 0x28028(%rip), %rsi     # 0x3cdc0
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
jmp 0x14df8
leaq 0xd0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb142
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x83be
leaq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb142
addq $0xe8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb142
leaq 0x8(%rsp), %rdi
callq 0x716e
xorps %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x14e07
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x716e
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, 1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
    {
      if(size != m_rows*_Cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x14f72
movq %rsi, %r15
movq (%r14), %rdi
callq 0x64a0
testq %r15, %r15
jle 0x14f6d
movq %r15, %rdi
callq 0x14f7c
jmp 0x14f6f
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq