LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/Transpositions.h
// Function: void Eigen::internal::transposition_matrix_product_retval<Eigen::Transpositions<-1, -1, int>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1, false>::evalTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&) const
inline void evalTo(Dest& dst) const
    {
      const int size = m_transpositions.size();
      Index j = 0;

      if(!(is_same<MatrixTypeNestedCleaned,Dest>::value && extract_data(dst) == extract_data(m_matrix)))
        dst = m_matrix;

      for(int k=(Transposed?size-1:0) ; Transposed?k>=0:k<size ; Transposed?--k:++k)
        if((j=m_transpositions.coeff(k))!=k)
        {
          if(Side==OnTheLeft)
            dst.row(k).swap(dst.row(j));
          else if(Side==OnTheRight)
            dst.col(k).swap(dst.col(j));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movl 0x8(%rax), %r12d
movq (%rbx), %rax
cmpq (%rsi), %rax
je 0x261a9
movq %rbx, %rdi
callq 0x23a40
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x2620c
movq (%r14), %rax
movq (%rax), %rax
movl (%rax,%r15,4), %eax
cmpq %rax, %r15
je 0x26207
movslq %eax, %rbp
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x26a06
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x26a06
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rcx
movsd (%rcx), %xmm1
movsd %xmm1, (%rax)
movsd %xmm0, (%rcx)
incq %r15
jmp 0x261b8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, 1, -1, 1>::resize(long, long, long)
EIGEN_STRONG_INLINE void resize(DenseIndex size, DenseIndex, DenseIndex nbCols)
    {
      if(size != _Rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_cols = nbCols;
    }
    inline const T *data() const { return m_data; }
    inline T *data() { return m_data; }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x27d36
movq %rsi, %r15
movq (%r14), %rdi
callq 0xe670
testq %r15, %r15
je 0x27d31
movq %r15, %rdi
callq 0x23655
jmp 0x27d33
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::gemv_selector<1, 0, true>::run<Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>(Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4> const&, Eigen::Matrix<double, 1, -1, 1, 1, -1>&, Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 4>::Scalar const&)
static void run(const ProductType& prod, Dest& dest, const typename ProductType::Scalar& alpha)
  {
    Transpose<Dest> destT(dest);
    enum { OtherStorageOrder = StorageOrder == RowMajor ? ColMajor : RowMajor };
    gemv_selector<OnTheRight,OtherStorageOrder,BlasCompatible>
      ::run(GeneralProduct<Transpose<const typename ProductType::_RhsNested>,Transpose<const typename ProductType::_LhsNested>, GemvProduct>
        (prod.rhs().transpose(), prod.lhs().transpose()), destT, alpha);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
leaq 0x18(%rsp), %r14
movq %rsi, (%r14)
movq 0x8(%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x28098
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27fa6
movq 0x30(%rsp), %rdi
callq 0xe670
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
callq 0xe670
movq %rbx, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
      m_cols = nbCols;
    }
    inline const T *data() const { return m_data; }
    inline T *data() { return m_data; }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x292fc
movq %rsi, %r12
movq (%r15), %rdi
callq 0xe670
testq %r12, %r12
je 0x292f7
movq %r12, %rdi
callq 0x23655
jmp 0x292f9
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::TriangularBase<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>::evalToLazy<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::MatrixBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&) const
void TriangularBase<Derived>::evalToLazy(MatrixBase<DenseDerived> &other) const
{
  enum {
    unroll = DenseDerived::SizeAtCompileTime != Dynamic
                   && internal::traits<Derived>::CoeffReadCost != Dynamic
                   && DenseDerived::SizeAtCompileTime * internal::traits<Derived>::CoeffReadCost / 2
                        <= EIGEN_UNROLLING_LIMIT
  };
  other.derived().resize(this->rows(), this->cols());

  internal::triangular_assignment_selector
    <DenseDerived, typename internal::traits<Derived>::MatrixTypeNestedCleaned, Derived::Mode,
    unroll ? int(DenseDerived::SizeAtCompileTime) : Dynamic,
    true // clear the opposite triangular part
    >::run(other.derived(), derived().nestedExpression());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x18db6
movq (%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29de4
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: Eigen::internal::triangular_assignment_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1u, -1, true>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&)
static inline void run(Derived1 &dst, const Derived2 &src)
  {
    for(Index j = 0; j < dst.cols(); ++j)
    {
      for(Index i = j; i < dst.rows(); ++i)
        dst.copyCoeff(i, j, src);
      Index maxi = (std::min)(j, dst.rows());
      if (ClearOpposite)
        for(Index i = 0; i < maxi; ++i)
          dst.coeffRef(i, j) = static_cast<typename Derived1::Scalar>(0);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movq 0x8(%rdi), %rdx
leaq (,%rdx,8), %rcx
movq %rcx, -0x8(%rsp)
leaq 0x8(,%rdx,8), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %r15, %rdx
movq %r15, %r12
cmovlq %rdx, %r12
movq %r15, %r13
cmovgq %rdx, %r13
testq %r12, %r12
movl $0x0, %ecx
cmovleq %rcx, %r12
cmpq %rax, %r15
je 0x29ea1
addq %r14, %r13
movq 0x8(%rsi), %rbp
movq (%rdi), %rcx
addq %rbx, %rcx
incq %rbp
imulq %r11, %rbp
addq (%rsi), %rbp
xorl %r8d, %r8d
cmpq %r8, %r13
je 0x29e75
movsd (%rbp,%r8,8), %xmm0
movsd %xmm0, (%rcx,%r8,8)
incq %r8
jmp 0x29e5e
movq (%rdi), %rcx
addq %r10, %rcx
xorl %r8d, %r8d
cmpq %r8, %r12
je 0x29e8d
andq $0x0, (%rcx,%r8,8)
incq %r8
jmp 0x29e7e
incq %r15
decq %r14
addq %r9, %rbx
addq $0x8, %r11
addq -0x8(%rsp), %r10
jmp 0x29e22
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1u>::lazyAssign<Eigen::CwiseUnaryOp<Eigen::internal::scalar_quotient1_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>>(Eigen::MatrixBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_quotient1_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const>> const&)
void TriangularView<MatrixType, Mode>::lazyAssign(const MatrixBase<OtherDerived>& other)
{
  enum {
    unroll = MatrixType::SizeAtCompileTime != Dynamic
          && internal::traits<OtherDerived>::CoeffReadCost != Dynamic
          && MatrixType::SizeAtCompileTime*internal::traits<OtherDerived>::CoeffReadCost/2 <= EIGEN_UNROLLING_LIMIT
  };
  eigen_assert(m_matrix.rows() == other.rows() && m_matrix.cols() == other.cols());

  internal::triangular_assignment_selector
    <MatrixType, OtherDerived, int(Mode),
    unroll ? int(MatrixType::SizeAtCompileTime) : Dynamic,
    false // do not change the opposite triangular part
    >::run(m_matrix.const_cast_derived(), other.derived());
}

// Assembly:
movq (%rdi), %rdi
movq 0x8(%rdi), %rcx
movq (%rsi), %rax
cmpq 0x8(%rax), %rcx
jne 0x29ffc
movq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
je 0x2a01c
pushq %rax
leaq 0x21e92(%rip), %rdi     # 0x4be96
leaq 0x21ece(%rip), %rsi     # 0x4bed9
leaq 0x21ef1(%rip), %rcx     # 0x4bf03
movl $0x269, %edx            # imm = 0x269
callq 0xe380
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Eigenvalues/Tridiagonalization.h
// Function: void Eigen::internal::tridiagonalization_inplace_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, false>::run<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, bool)
static void run(MatrixType& mat, DiagonalType& diag, SubDiagonalType& subdiag, bool extractQ)
  {
    CoeffVectorType hCoeffs(mat.cols()-1);
    tridiagonalization_inplace(mat,hCoeffs);
    diag = mat.diagonal().real();
    subdiag = mat.template diagonal<-1>().real();
    if(extractQ)
      mat = HouseholderSequenceType(mat, hCoeffs.conjugate())
            .setLength(mat.rows() - 1)
            .setShift(1);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
decq %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x23d12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a14c
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0x2bfc0
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsi)
movq %r15, %rdi
callq 0x2c07a
testb %bpl, %bpl
je 0x2a11a
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsi)
movq %r14, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movq 0x8(%rbx), %rax
decq %rax
movq %rax, 0x18(%rsi)
movq $0x1, 0x20(%rsi)
movq %rbx, %rdi
callq 0x2c13c
movq 0x8(%rsp), %rdi
callq 0xe670
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a137
jmp 0x2a137
jmp 0x2a137
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xe670
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/SelfadjointRank2Update.h
// Function: Eigen::internal::selfadjoint_rank2_update_selector<double, long, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 1>::run(double*, long, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false> const&, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const&, double const&)
static void run(Scalar* mat, Index stride, const UType& u, const VType& v, const Scalar& alpha)
  {
    const Index size = u.size();
    for (Index i=0; i<size; ++i)
    {
      Map<Matrix<Scalar,Dynamic,1> >(mat+stride*i+i, size-i) +=
                        (numext::conj(alpha) * numext::conj(u.coeff(i))) * v.tail(size-i)
                      + (alpha * numext::conj(v.coeff(i))) * u.tail(size-i);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rdi, %r12
movq 0x8(%rdx), %r13
xorl %ebp, %ebp
testq %r13, %r13
movl $0x0, %eax
cmovgq %r13, %rax
movq %rax, 0x28(%rsp)
leaq 0x8(,%rsi,8), %rax
movq %rax, 0x20(%rsp)
cmpq %rbp, 0x28(%rsp)
je 0x2bb4e
movq 0x18(%rsp), %rbx
movsd (%rbx), %xmm0
movq (%r15), %rax
mulsd (%rax,%rbp,8), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
movq 0x10(%rsp), %r14
movq %r14, %rsi
movq %r13, %rdx
callq 0x2bb60
movups 0x88(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
leaq 0xa0(%rsp), %rcx
movups (%rcx), %xmm0
leaq 0x48(%rsp), %rax
movups %xmm0, (%rax)
movups 0x18(%rcx), %xmm0
movups %xmm0, 0x18(%rax)
movq 0xc8(%rsp), %rax
movq %rax, 0x70(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x78(%rsp)
movsd (%rbx), %xmm0
movq (%r14), %rax
mulsd (%rax,%rbp,8), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x160(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2bb94
movups 0x160(%rsp), %xmm0
movaps %xmm0, 0xd0(%rsp)
leaq 0x178(%rsp), %rcx
movups (%rcx), %xmm0
leaq 0xe8(%rsp), %rax
movups %xmm0, (%rax)
movups 0x18(%rcx), %xmm0
movups %xmm0, 0x18(%rax)
movups 0x30(%rcx), %xmm0
movups %xmm0, 0x30(%rax)
movups 0x1b8(%rsp), %xmm0
movups %xmm0, 0x128(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x138(%rsp)
leaq 0x1c8(%rsp), %rbx
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x2bb78
leaq 0x148(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x267f4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2bbac
incq %rbp
decq %r13
addq 0x20(%rsp), %r12
jmp 0x2ba0b
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Householder/Householder.h
// Function: void Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>>::applyHouseholderOnTheRight<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false>>(Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const&, double const&, double*)
void MatrixBase<Derived>::applyHouseholderOnTheRight(
  const EssentialPart& essential,
  const Scalar& tau,
  Scalar* workspace)
{
  if(cols() == 1)
  {
    *this *= Scalar(1)-tau;
  }
  else
  {
    Map<typename internal::plain_col_type<PlainObject>::type> tmp(workspace,rows());
    Block<Derived, Derived::RowsAtCompileTime, EssentialPart::SizeAtCompileTime> right(derived(), 0, 1, rows(), cols()-1);
    tmp.noalias() = right * essential.conjugate();
    tmp += this->col(0);
    this->col(0) -= tau * tmp;
    right.noalias() -= tau * tmp * essential.transpose();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movq %rdi, %r15
cmpq $0x1, 0x10(%rdi)
jne 0x2c513
movsd 0x13b78(%rip), %xmm0    # 0x40070
subsd (%r14), %xmm0
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x2ca82
jmp 0x2c620
movq %rsi, %rbx
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x267f4
movq 0x8(%r15), %r8
movq 0x10(%r15), %r9
decq %r9
leaq 0xc0(%rsp), %r13
pushq $0x1
popq %rcx
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2cad0
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2cd96
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2cde4
leaq 0x20(%rsp), %r12
movq 0x70(%r12), %rdi
callq 0xe670
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2d0d4
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2cb3e
movsd (%r14), %xmm0
movups (%r13), %xmm1
leaq 0xa0(%rsp), %r12
movaps %xmm1, (%r12)
movsd %xmm0, 0x18(%r12)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2d0d4
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2cb66
movsd (%r14), %xmm0
movups (%r13), %xmm1
movaps %xmm1, (%rbp)
movsd %xmm0, 0x18(%rbp)
movups (%rbx), %xmm0
movaps %xmm0, 0x20(%rbp)
movupd 0x18(%rbx), %xmm0
movupd %xmm0, 0x38(%rbp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x48(%rbp)
andq $0x0, 0x58(%rbp)
leaq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x2d41a
movq 0x68(%rsp), %rdi
callq 0xe670
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0x2c647
movq %rax, %rbx
movq 0x90(%rsp), %rdi
callq 0xe670
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/TriangularMatrix.h
// Function: Eigen::internal::triangular_assignment_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 10u, -1, false>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&)
static inline void run(Derived1 &dst, const Derived2 &src)
  {
    for(Index j = 0; j < dst.cols(); ++j)
    {
      Index maxi = (std::min)(j, dst.rows());
      for(Index i = 0; i < maxi; ++i)
        dst.copyCoeff(i, j, src);
      if (ClearOpposite)
        for(Index i = maxi; i < dst.rows(); ++i)
          dst.coeffRef(i, j) = Scalar(0);
    }
  }

// Assembly:
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
leaq (,%rax,8), %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r10, %rax
movq %r10, %r11
cmovlq %rax, %r11
testq %r11, %r11
cmovleq %r8, %r11
cmpq %rcx, %r10
jge 0x2ca7e
movq (%rdi), %rbx
addq %r9, %rbx
xorl %r14d, %r14d
cmpq %r14, %r11
je 0x2ca76
movsd 0x10(%rsi), %xmm0
movsd %xmm0, (%rbx,%r14,8)
incq %r14
jmp 0x2ca61
incq %r10
addq %rdx, %r9
jmp 0x2ca42
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::outer_product_selector_run<Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, -1>, 0, Eigen::Stride<0, 0>>, 2>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, -1, false>, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, -1>, 0, Eigen::Stride<0, 0>>, 2>::sub>(Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, -1>, 0, Eigen::Stride<0, 0>>, 2> const&, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, -1, false>&, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, -1>, 0, Eigen::Stride<0, 0>>, 2>::sub const&, Eigen::internal::false_type const&)
EIGEN_DONT_INLINE void outer_product_selector_run(const ProductType& prod, Dest& dest, const Func& func, const false_type&)
{
  typedef typename Dest::Index Index;
  // FIXME make sure lhs is sequentially stored
  // FIXME not very good if rhs is real and lhs complex while alpha is real too
  const Index cols = dest.cols();
  for (Index j=0; j<cols; ++j)
    func(dest.col(j), prod.rhs().coeff(j) * prod.lhs());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rbp
leaq 0x18(%rdi), %r13
xorl %r15d, %r15d
testq %rbp, %rbp
cmovleq %r15, %rbp
leaq 0x40(%rsp), %r12
cmpq %r15, %rbp
je 0x2e05c
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2d65e
movq 0x30(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movups (%r14), %xmm1
leaq 0x8(%rsp), %rax
movups %xmm1, (%rax)
movups (%r13), %xmm1
movups %xmm1, 0x18(%rax)
movsd 0x28(%r14), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %r12, %rdi
movq %rsp, %rsi
callq 0x2e06e
incq %r15
jmp 0x2e008
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Jacobi/Jacobi.h
// Function: Eigen::JacobiRotation<double>::makeGivens(double const&, double const&, double*, Eigen::internal::false_type)
void JacobiRotation<Scalar>::makeGivens(const Scalar& p, const Scalar& q, Scalar* r, internal::false_type)
{
  using std::sqrt;
  using std::abs;
  if(q==Scalar(0))
  {
    m_c = p<Scalar(0) ? Scalar(-1) : Scalar(1);
    m_s = Scalar(0);
    if(r) *r = abs(p);
  }
  else if(p==Scalar(0))
  {
    m_c = Scalar(0);
    m_s = q<Scalar(0) ? Scalar(1) : Scalar(-1);
    if(r) *r = abs(q);
  }
  else if(abs(p) > abs(q))
  {
    Scalar t = q/p;
    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
    if(p<Scalar(0))
      u = -u;
    m_c = Scalar(1)/u;
    m_s = -t * m_c;
    if(r) *r = p * u;
  }
  else
  {
    Scalar t = p/q;
    Scalar u = sqrt(Scalar(1) + numext::abs2(t));
    if(q<Scalar(0))
      u = -u;
    m_s = -Scalar(1)/u;
    m_c = -t * m_s;
    if(r) *r = q * u;
  }

}

// Assembly:
movsd (%rdx), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd (%rsi), %xmm1
jne 0x2e643
jp 0x2e643
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
leaq 0x11b76(%rip), %rdx     # 0x401a0
movsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rdi)
andq $0x0, 0x8(%rdi)
testq %rcx, %rcx
je 0x2e67e
movsd (%rsi), %xmm0
jmp 0x2e672
ucomisd %xmm0, %xmm1
jne 0x2e67f
jp 0x2e67f
andq $0x0, (%rdi)
xorl %eax, %eax
ucomisd (%rdx), %xmm0
seta %al
leaq 0x11b31(%rip), %rsi     # 0x40190
movsd (%rsi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rdi)
testq %rcx, %rcx
je 0x2e67e
movsd (%rdx), %xmm0
andpd 0x11ab6(%rip), %xmm0    # 0x40130
movsd %xmm0, (%rcx)
retq
movapd 0x11aa9(%rip), %xmm0    # 0x40130
movapd %xmm1, %xmm3
andpd %xmm0, %xmm3
andpd %xmm2, %xmm0
ucomisd %xmm0, %xmm3
jbe 0x2e6fa
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
mulsd %xmm2, %xmm0
movsd 0x119c3(%rip), %xmm3    # 0x40070
addsd %xmm3, %xmm0
sqrtsd %xmm0, %xmm0
movapd 0x11a83(%rip), %xmm4    # 0x40140
xorpd %xmm5, %xmm5
cmpltsd %xmm5, %xmm1
movapd %xmm1, %xmm5
andnpd %xmm0, %xmm5
xorpd %xmm4, %xmm0
andpd %xmm1, %xmm0
orpd %xmm5, %xmm0
divsd %xmm0, %xmm3
movsd %xmm3, (%rdi)
xorpd %xmm4, %xmm2
mulsd %xmm3, %xmm2
movsd %xmm2, 0x8(%rdi)
testq %rcx, %rcx
je 0x2e67e
mulsd (%rsi), %xmm0
jmp 0x2e67a
divsd %xmm2, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x11962(%rip), %xmm0    # 0x40070
sqrtsd %xmm0, %xmm0
movapd 0x11a26(%rip), %xmm3    # 0x40140
xorpd %xmm4, %xmm4
cmpltsd %xmm4, %xmm2
movapd %xmm2, %xmm4
andnpd %xmm0, %xmm4
xorpd %xmm3, %xmm0
andpd %xmm2, %xmm0
orpd %xmm4, %xmm0
movsd 0x11939(%rip), %xmm2    # 0x40078
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rdi)
xorpd %xmm3, %xmm1
mulsd %xmm2, %xmm1
movsd %xmm1, (%rdi)
testq %rcx, %rcx
je 0x2e67e
mulsd (%rdx), %xmm0
jmp 0x2e67a
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::wait(unsigned long) const volatile
void wait(size_t const task_threshold = 0) const volatile
    {
      const pool_type* self = const_cast<const pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      if(0 == task_threshold)
      {
        while(0 != self->m_active_worker_count || !self->m_scheduler.empty())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
      else
      {
        while(task_threshold < self->m_active_worker_count + self->m_scheduler.size())
        { 
          self->m_worker_idle_or_terminated_event.wait(lock);
        }
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa0(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2fe14
testq %r14, %r14
je 0x2fcf9
leaq 0x28(%rbx), %r15
leaq 0xc8(%rbx), %r12
leaq 0x8(%rsp), %r13
movq 0x20(%rbx), %rbp
movq %r15, %rdi
callq 0x3078c
addq %rbp, %rax
cmpq %r14, %rax
jbe 0x2fd23
movq %r12, %rdi
movq %r13, %rsi
callq 0x2fe20
jmp 0x2fcd8
leaq 0xc8(%rbx), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x20(%rbx)
jne 0x2fd16
movq 0x58(%rbx), %rax
cmpq 0x38(%rbx), %rax
je 0x2fd23
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fe20
jmp 0x2fd05
leaq 0x8(%rsp), %rdi
callq 0x2fefe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fd3e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2fefe
movq %rbx, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::terminate_all_workers(bool) volatile
void terminate_all_workers(bool const wait) volatile
    {
      pool_type* self = const_cast<pool_type*>(this);
      recursive_mutex::scoped_lock lock(self->m_monitor);

      self->m_terminate_all_workers = true;

      m_target_worker_count = 0;
      self->m_task_or_terminate_workers_event.notify_all();

      if(wait)
      {
        while(m_active_worker_count > 0)
        {
          self->m_worker_idle_or_terminated_event.wait(lock);
        }

        for(typename std::vector<shared_ptr<worker_type> >::iterator it = self->m_terminated_workers.begin();
          it != self->m_terminated_workers.end();
          ++it)
        {
          (*it)->join();
        }
        self->m_terminated_workers.clear();
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa0(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2fe14
movb $0x1, 0x80(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x120(%rbx), %rdi
callq 0x307d4
testl %ebp, %ebp
je 0x2fde8
leaq 0xc8(%rbx), %r14
leaq 0x8(%rsp), %r15
cmpq $0x0, 0x20(%rbx)
je 0x2fdb3
movq %r14, %rdi
movq %r15, %rsi
callq 0x2fe20
jmp 0x2fd9f
leaq 0x88(%rbx), %r14
movq 0x88(%rbx), %r15
cmpq 0x90(%rbx), %r15
je 0x2fde0
movq %r15, %rdi
callq 0x30824
movq %rax, %rdi
callq 0x3084e
addq $0x10, %r15
jmp 0x2fdc1
movq %r14, %rdi
callq 0x30862
leaq 0x8(%rsp), %rdi
callq 0x2fefe
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fdff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2fefe
movq %rbx, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::resize(unsigned long) volatile
bool resize(size_t const worker_count) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor); 

      if(!m_terminate_all_workers)
      {
        m_target_worker_count = worker_count;
      }
      else
      { 
        return false;
      }


      if(m_worker_count <= m_target_worker_count)
      { // increase worker count
        while(m_worker_count < m_target_worker_count)
        {
          try
          {
            worker_thread<pool_type>::create_and_attach(lockedThis->shared_from_this());
            m_worker_count++;
            m_active_worker_count++;	
          }
          catch(thread_resource_error)
          {
            return false;
          }
        }
      }
      else
      { // decrease worker count
        lockedThis->m_task_or_terminate_workers_event.notify_all();   // TODO: Optimize number of notified workers
      }

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x2ffde
cmpb $0x0, 0x80(%r14)
je 0x30b71
xorl %ebp, %ebp
jmp 0x30b91
movq %r15, 0x18(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jbe 0x30ba8
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x307d4
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x30576
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x30b8e
movq %r12, %rdi
movq %r14, %rsi
callq 0x30d60
movq %r12, %rdi
callq 0x30c44
movq %r15, %rdi
callq 0x1ce8e
incq 0x10(%r14)
incq 0x20(%r14)
jmp 0x30bb0
movq %rdx, %r12
movq %rax, %r14
jmp 0x30bf5
movq %rdx, %r12
movq %rax, %r14
movq %r15, %rdi
callq 0x1ce8e
cmpl $0x1, %r12d
jne 0x30c2b
movq %r14, %rdi
callq 0xe6f0
movq %rsp, %rdi
movq %rax, %rsi
callq 0x30d9c
movq %r14, %rdi
callq 0xe260
movq %rsp, %rdi
callq 0x30452
callq 0xe990
jmp 0x30b6d
movq %rax, %r14
movq %rbx, %rdi
callq 0x30576
movq %r14, %rdi
callq 0xe9f0
movq %rax, %rdi
callq 0x1899a
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::execute_task() volatile
bool execute_task() volatile
    {
      function0<void> task;

      { // fetch task
        pool_type* lockedThis = const_cast<pool_type*>(this);
        recursive_mutex::scoped_lock lock(lockedThis->m_monitor);

        // decrease number of threads if necessary
        if(m_worker_count > m_target_worker_count)
        {	
          return false;	// terminate worker
        }


        // wait for tasks
        while(lockedThis->m_scheduler.empty())
        {	
          // decrease number of workers if necessary
          if(m_worker_count > m_target_worker_count)
          {	
            return false;	// terminate worker
          }
          else
          {
            m_active_worker_count--;
            lockedThis->m_worker_idle_or_terminated_event.notify_all();	
            lockedThis->m_task_or_terminate_workers_event.wait(lock);
            m_active_worker_count++;
          }
        }

        task = lockedThis->m_scheduler.top();
        lockedThis->m_scheduler.pop();
      }

      // call task function
      if(task)
      {
        task();
      }
 
      //guard->disable();
      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
andq $0x0, 0x18(%rsp)
leaq 0xa0(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2fe14
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jbe 0x31415
xorl %ebx, %ebx
jmp 0x31471
leaq 0xc8(%rbx), %r14
leaq 0x120(%rbx), %r15
leaq 0x8(%rsp), %r12
movq 0x38(%rbx), %rsi
cmpq %rsi, 0x58(%rbx)
jne 0x31459
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
ja 0x31411
decq 0x20(%rbx)
movq %r14, %rdi
callq 0x307d4
movq %r15, %rdi
movq %r12, %rsi
callq 0x2fe20
incq 0x20(%rbx)
jmp 0x31428
leaq 0x18(%rsp), %rdi
callq 0x3196e
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x31a08
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x2fefe
testb %bl, %bl
je 0x31491
cmpq $0x0, 0x18(%rsp)
je 0x31491
leaq 0x18(%rsp), %rdi
callq 0x319c4
leaq 0x18(%rsp), %rdi
callq 0x194d6
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x314b2
jmp 0x314ad
movq %rax, %rbx
jmp 0x314bf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2fefe
leaq 0x18(%rsp), %rdi
callq 0x194d6
movq %rbx, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::worker_destructed(boost::shared_ptr<boost::threadpool::detail::worker_thread<boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>>>) volatile
void worker_destructed(shared_ptr<worker_type> worker) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);
      m_worker_count--;
      m_active_worker_count--;
      lockedThis->m_worker_idle_or_terminated_event.notify_all();	

      if(m_terminate_all_workers)
      {
        lockedThis->m_terminated_workers.push_back(worker);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x2ffde
decq 0x10(%r15)
decq 0x20(%r15)
leaq 0xc8(%r15), %rdi
callq 0x307d4
movb 0x80(%r15), %al
cmpb $0x1, %al
jne 0x3151d
addq $0x88, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x31626
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30576
movq %rax, %r14
movq %rbx, %rdi
callq 0x30576
movq %r14, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::worker_died_unexpectedly(boost::shared_ptr<boost::threadpool::detail::worker_thread<boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>>>) volatile
void worker_died_unexpectedly(shared_ptr<worker_type> worker) volatile
    {
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor);

      m_worker_count--;
      m_active_worker_count--;
      lockedThis->m_worker_idle_or_terminated_event.notify_all();	

      if(m_terminate_all_workers)
      {
        lockedThis->m_terminated_workers.push_back(worker);
      }
      else
      {
        lockedThis->m_size_policy->worker_died_unexpectedly(m_worker_count);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x2ffde
decq 0x10(%r14)
decq 0x20(%r14)
leaq 0xc8(%r14), %rdi
callq 0x307d4
movb 0x80(%r14), %al
cmpb $0x1, %al
jne 0x315f1
addq $0x88, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x31626
jmp 0x31606
leaq 0x78(%r14), %rdi
callq 0x3165c
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x31684
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30576
movq %rax, %r14
movq %rbx, %rdi
callq 0x30576
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/./threadpool/./detail/pool_core.hpp
// Function: boost::threadpool::detail::pool_core<boost::function0<void>, boost::threadpool::fifo_scheduler, boost::threadpool::static_size, boost::threadpool::resize_controller, boost::threadpool::wait_for_all_tasks>::schedule(boost::function0<void> const&) volatile
bool schedule(task_type const & task) volatile
    {	
      locking_ptr<pool_type, recursive_mutex> lockedThis(*this, m_monitor); 
      
      if(lockedThis->m_scheduler.push(task))
      {
        lockedThis->m_task_or_terminate_workers_event.notify_one();
        return true;
      }
      else
      {
        return false;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0xa0(%rdi), %rbx
movq %rbx, %rdi
callq 0x2ffde
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x32a94
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
callq 0x32a44
movq %rbx, %rdi
callq 0x30576
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x30576
movq %r14, %rdi
callq 0xe9f0
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: void Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const
void scaleAndAddTo(Dest& dst, const Scalar& alpha) const
    {
      eigen_assert(dst.rows()==m_lhs.rows() && dst.cols()==m_rhs.cols());

      typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(m_lhs);
      typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(m_rhs);

      Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(m_lhs)
                                 * RhsBlasTraits::extractScalarFactor(m_rhs);

      typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar,
              Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType;

      typedef internal::gemm_functor<
        Scalar, Index,
        internal::general_matrix_matrix_product<
          Index,
          LhsScalar, (_ActualLhsType::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate),
          RhsScalar, (_ActualRhsType::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
          (Dest::Flags&RowMajorBit) ? RowMajor : ColMajor>,
        _ActualLhsType, _ActualRhsType, Dest, BlockingType> GemmFunctor;

      BlockingType blocking(dst.rows(), dst.cols(), lhs.cols());

      internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>(GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), this->rows(), this->cols(), Dest::Flags&RowMajorBit);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rsi
movq (%rdi), %r12
cmpq 0x8(%r12), %rsi
jne 0x3a15b
movq %rdi, %rbx
movq 0x10(%r14), %rax
movq 0x8(%rdi), %r13
cmpq 0x10(%r13), %rax
jne 0x3a15b
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%r12), %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x3a190
leaq 0x58(%rsp), %rdi
movq %r12, (%rdi)
movq %r13, 0x8(%rdi)
movq %r14, 0x10(%rdi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
movq %r15, 0x20(%rdi)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x8(%rax), %rsi
movq 0x10(%rcx), %rdx
xorl %ecx, %ecx
callq 0x3a1e8
leaq 0x10(%rsp), %rdi
callq 0x3a1fa
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1d2d0(%rip), %rdi     # 0x57432
leaq 0x1d2fe(%rip), %rsi     # 0x57467
leaq 0x1d32d(%rip), %rcx     # 0x5749d
movl $0x18f, %edx            # imm = 0x18F
callq 0xe380
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3a1fa
movq %rbx, %rdi
callq 0xe9f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: Eigen::internal::gemm_blocking_space<0, double, double, -1, -1, -1, 1, false>::gemm_blocking_space(long, long, long)
gemm_blocking_space(DenseIndex rows, DenseIndex cols, DenseIndex depth)
    {
      this->m_mc = Transpose ? cols : rows;
      this->m_nc = Transpose ? rows : cols;
      this->m_kc = depth;

      computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, this->m_nc);
      m_sizeA = this->m_mc * this->m_kc;
      m_sizeB = this->m_kc * this->m_nc;
      m_sizeW = this->m_kc*Traits::WorkSpaceFactor;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rdi), %rax
movq %rsi, 0x18(%rdi)
leaq 0x20(%rdi), %r8
movq %rdx, 0x20(%rdi)
addq $0x28, %rdi
movq %rcx, 0x28(%rbx)
movq %rax, %rsi
movq %r8, %rdx
callq 0x3a219
movq 0x28(%rbx), %rax
movq 0x18(%rbx), %rcx
imulq %rax, %rcx
movq %rcx, 0x30(%rbx)
movq 0x20(%rbx), %rcx
imulq %rax, %rcx
movq %rcx, 0x38(%rbx)
shlq $0x3, %rax
movq %rax, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: void Eigen::internal::computeProductBlockingSizes<double, double, 1, long>(long&, long&, long&)
void computeProductBlockingSizes(SizeType& k, SizeType& m, SizeType& n)
{
  EIGEN_UNUSED_VARIABLE(n);
  // Explanations:
  // Let's recall the product algorithms form kc x nc horizontal panels B' on the rhs and
  // mc x kc blocks A' on the lhs. A' has to fit into L2 cache. Moreover, B' is processed
  // per kc x nr vertical small panels where nr is the blocking size along the n dimension
  // at the register level. For vectorization purpose, these small vertical panels are unpacked,
  // e.g., each coefficient is replicated to fit a packet. This small vertical panel has to
  // stay in L1 cache.
  std::ptrdiff_t l1, l2;

  typedef gebp_traits<LhsScalar,RhsScalar> Traits;
  enum {
    kdiv = KcFactor * 2 * Traits::nr
         * Traits::RhsProgress * sizeof(RhsScalar),
    mr = gebp_traits<LhsScalar,RhsScalar>::mr,
    mr_mask = (0xffffffff/mr)*mr
  };

  manage_caching_sizes(GetAction, &l1, &l2);
  k = std::min<SizeType>(k, l1/kdiv);
  SizeType _m = k>0 ? l2/(4 * sizeof(LhsScalar) * k) : 0;
  if(_m<m) m = _m & mr_mask;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %rdx
xorl %edi, %edi
movq %r12, %rsi
callq 0x3a28a
movq (%r12), %rax
movl $0x80, %ecx
cqto
idivq %rcx
movq (%r15), %rcx
cmpq %rcx, %rax
cmovlq %rax, %rcx
movq %rcx, (%r15)
testq %rcx, %rcx
jle 0x3a272
movq 0x8(%rsp), %rax
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %r14
cmpq (%rbx), %r14
jge 0x3a27e
andl $-0x4, %r14d
movq %r14, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::manage_caching_sizes(Eigen::Action, long*, long*)
inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1=0, std::ptrdiff_t* l2=0)
{
  static std::ptrdiff_t m_l1CacheSize = 0;
  static std::ptrdiff_t m_l2CacheSize = 0;
  if(m_l2CacheSize==0)
  {
    m_l1CacheSize = manage_caching_sizes_helper(queryL1CacheSize(),8 * 1024);
    m_l2CacheSize = manage_caching_sizes_helper(queryTopLevelCacheSize(),1*1024*1024);
  }
  
  if(action==SetAction)
  {
    // set the cpu cache size and cache all block sizes from a global cache size in byte
    eigen_internal_assert(l1!=0 && l2!=0);
    m_l1CacheSize = *l1;
    m_l2CacheSize = *l2;
  }
  else if(action==GetAction)
  {
    eigen_internal_assert(l1!=0 && l2!=0);
    *l1 = m_l1CacheSize;
    *l2 = m_l2CacheSize;
  }
  else
  {
    eigen_internal_assert(false);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0x43392(%rip)     # 0x7d630
jne 0x3a2cc
callq 0x3a30a
testl %eax, %eax
movl $0x2000, %ecx           # imm = 0x2000
cmovgl %eax, %ecx
movq %rcx, 0x43372(%rip)     # 0x7d628
callq 0x3a331
testl %eax, %eax
movl $0x100000, %ecx         # imm = 0x100000
cmovgl %eax, %ecx
movq %rcx, 0x43364(%rip)     # 0x7d630
cmpl $0x1, %ebp
je 0x3a2e5
testl %ebp, %ebp
jne 0x3a305
leaq 0x43354(%rip), %rax     # 0x7d630
leaq 0x43345(%rip), %rcx     # 0x7d628
jmp 0x3a2f9
movq %r14, %rax
leaq 0x43341(%rip), %r14     # 0x7d630
movq %rbx, %rcx
leaq 0x4332f(%rip), %rbx     # 0x7d628
movq (%rcx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rax
movq %rax, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kingsford-Group[P]ghost2/include/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::queryCacheSizes(int&, int&, int&)
inline void queryCacheSizes(int& l1, int& l2, int& l3)
{
  #ifdef EIGEN_CPUID
  int abcd[4];

  // identify the CPU vendor
  EIGEN_CPUID(abcd,0x0,0);
  int max_std_funcs = abcd[1];
  if(cpuid_is_vendor(abcd,"GenuineIntel"))
    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);
  else if(cpuid_is_vendor(abcd,"AuthenticAMD") || cpuid_is_vendor(abcd,"AMDisbetter!"))
    queryCacheSizes_amd(l1,l2,l3);
  else
    // by default let's use Intel's API
    queryCacheSizes_intel(l1,l2,l3,max_std_funcs);

  // here is the list of other vendors:
//   ||cpuid_is_vendor(abcd,"VIA VIA VIA ")
//   ||cpuid_is_vendor(abcd,"CyrixInstead")
//   ||cpuid_is_vendor(abcd,"CentaurHauls")
//   ||cpuid_is_vendor(abcd,"GenuineTMx86")
//   ||cpuid_is_vendor(abcd,"TransmetaCPU")
//   ||cpuid_is_vendor(abcd,"RiseRiseRise")
//   ||cpuid_is_vendor(abcd,"Geode by NSC")
//   ||cpuid_is_vendor(abcd,"SiS SiS SiS ")
//   ||cpuid_is_vendor(abcd,"UMC UMC UMC ")
//   ||cpuid_is_vendor(abcd,"NexGenDriven")
  #else
  l1 = l2 = l3 = -1;
  #endif
}

// Assembly:
movq %rdx, %r8
xorl %ecx, %ecx
xorl %eax, %eax
xchgq %rbx, %r9
cpuid
xchgq %rbx, %r9
cmpl $0x68747541, %r9d       # imm = 0x68747541
je 0x3a3c0
cmpl $0x69444d41, %r9d       # imm = 0x69444D41
je 0x3a3b2
cmpl $0x756e6547, %r9d       # imm = 0x756E6547
jne 0x3a3d8
xorl $0x49656e69, %edx       # imm = 0x49656E69
xorl $0x6c65746e, %ecx       # imm = 0x6C65746E
orl %edx, %ecx
jne 0x3a3d8
movq %r8, %rdx
movl $0x756e6547, %ecx       # imm = 0x756E6547
jmp 0x3a3e3
xorl $0x74656273, %edx       # imm = 0x74656273
xorl $0x21726574, %ecx       # imm = 0x21726574
jmp 0x3a3cc
xorl $0x69746e65, %edx       # imm = 0x69746E65
xorl $0x444d4163, %ecx       # imm = 0x444D4163
orl %edx, %ecx
jne 0x3a3d8
movq %r8, %rdx
jmp 0x3a3f1
movq %r8, %rdx
movl %r9d, %ecx
jmp 0x3a3e3
// File: /workspace/github_cpp_makefile_star2_O2/deanturpin[P]curly/./curly.h
// Function: find_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string find_token(const std::string &token, const std::string &s) noexcept {

  std::string token_value = "";

  const auto i = s.find('"' + token + '"');
  if (i != std::string::npos) {
    token_value = s.substr(i + 3 + token.size());

    // Refine token, try to find the end of the value definition
    const auto end = token_value.find_first_of("},");

    if (end != std::string::npos)
      token_value = token_value.substr(0, end);
  }

  return token_value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2840(%rip), %rsi      # 0x5104
movq %rsp, %rdx
callq 0x30f6
leaq 0x20(%rsp), %rdi
pushq $0x22
popq %rsi
movq %r15, %rdx
callq 0x3272
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
pushq $0x22
popq %rdx
callq 0x3250
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2310
movq %rax, %r12
movq %r13, %rdi
callq 0x20b0
leaq 0x20(%rsp), %rdi
callq 0x20b0
cmpq $-0x1, %r12
je 0x2984
movq 0x8(%r15), %rax
leaq (%r12,%rax), %rdx
addq $0x3, %rdx
movq %rsp, %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x21b0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x20b0
leaq 0x2768(%rip), %rsi      # 0x50b6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x20c0
cmpq $-0x1, %rax
je 0x2984
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21b0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x3245