LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x24690
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a690
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jne 0x6a627
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x286d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a6c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6a630
jmp 0x6a632
jmp 0x6a651
leaq 0x5efa2(%rip), %rdi     # 0xc95db
leaq 0x5efde(%rip), %rsi     # 0xc961e
movl $0x269, %edx            # imm = 0x269
leaq 0x5effc(%rip), %rcx     # 0xc9648
callq 0x104a0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x4ee00
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a680
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6a6f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x286d0
movq %rax, %rsi
decq %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4ceb0
movq -0x90(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x6aab0
jmp 0x6a96f
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4dbd0
jmp 0x6a97e
leaq -0x50(%rbp), %rdi
callq 0x6afb0
movq %rax, -0x98(%rbp)
jmp 0x6a990
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6afd0
jmp 0x6a9a2
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x6b000
jmp 0x6a9b1
leaq -0x60(%rbp), %rdi
callq 0x6b050
movq %rax, -0xa0(%rbp)
jmp 0x6a9c3
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x6b070
jmp 0x6a9d5
testb $0x1, -0x19(%rbp)
je 0x6aa8e
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6b0a0
movq %rax, -0xa8(%rbp)
jmp 0x6a9fc
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x6b0c0
jmp 0x6aa18
movq -0x8(%rbp), %rdi
callq 0x24690
movq %rax, -0xb8(%rbp)
jmp 0x6aa2a
movq -0xb8(%rbp), %rsi
decq %rsi
leaq -0x88(%rbp), %rdi
callq 0x6b120
movq %rax, -0xc0(%rbp)
jmp 0x6aa49
movq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x6b140
movq %rax, -0xc8(%rbp)
jmp 0x6aa63
movq -0xc8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x6b160
jmp 0x6aa75
jmp 0x6aa8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x24650
jmp 0x6aaa0
leaq -0x30(%rbp), %rdi
callq 0x24650
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x10cc0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6b670
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x70fdf
movq -0x28(%rbp), %rdi
callq 0x4df90
movsd %xmm0, -0x2c8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x515e0
movq %rax, %rdi
callq 0x4df90
movaps %xmm0, %xmm1
movsd -0x2c8(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x160(%rbp)
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq -0x38(%rbp), %rdx
leaq -0x1a8(%rbp), %rdi
callq 0x71070
leaq -0x158(%rbp), %rdi
leaq -0x160(%rbp), %rsi
leaq -0x1a8(%rbp), %rdx
callq 0x71030
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x2c0(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x70690
movq %rax, %rdi
callq 0x4df90
movaps %xmm0, %xmm1
movsd -0x2c0(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x220(%rbp)
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq -0x38(%rbp), %rdx
leaq -0x288(%rbp), %rdi
callq 0x71180
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
leaq -0x288(%rbp), %rdx
callq 0x71140
leaq -0x108(%rbp), %rdi
leaq -0x158(%rbp), %rsi
leaq -0x218(%rbp), %rdx
callq 0x710d0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq -0x38(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2b8(%rbp)
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x2b0(%rbp)
leaq -0x2a2(%rbp), %rdi
callq 0x54230
movq -0x2b8(%rbp), %rsi
movq -0x2b0(%rbp), %rdx
leaq -0x2a0(%rbp), %rdi
leaq -0x2a2(%rbp), %rcx
callq 0x5a910
leaq -0x2a0(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x711e0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x70e54
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x286d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jge 0x74abe
movq -0x8(%rbp), %rdi
callq 0x24690
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x37360
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x74aab
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x74ad0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x74a7e
jmp 0x74aad
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x74a38
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: void Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>>::copyPacket<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 1, 0>(long, long, Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>> const&)
void copyPacket(Index row, Index col, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(row >= 0 && row < rows()
                        && col >= 0 && col < cols());
      m_matrix.template writePacket<StoreMode>(row, col,
        m_functor.packetOp(m_matrix.template packet<StoreMode>(row, col),_other.template packet<LoadMode>(row, col)) );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rdi
callq 0x75850
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x80(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x759a0
movapd %xmm0, -0x50(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x75a20
movq -0x80(%rbp), %rdi
movapd %xmm0, -0x60(%rbp)
leaq -0x50(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4bb00
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movapd %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rcx
callq 0x75920
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>> const>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, 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::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>> const>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, 2>::sub>(Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>> const>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, 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::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>> const>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, false> const>, 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x75e40
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x79684
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x796d0
movq -0x8(%rbp), %rdi
callq 0x79760
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x79780
movsd %xmm0, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x797c0
movq %rax, %rdx
leaq -0xc8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x79720
movq -0xd8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x79690
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x795f0
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/MathFunctions.h
// Function: Eigen::internal::hypot_impl<double>::run(double const&, double const&)
static inline RealScalar run(const Scalar& x, const Scalar& y)
  {
    using std::max;
    using std::min;
    using std::abs;
    using std::sqrt;
    RealScalar _x = abs(x);
    RealScalar _y = abs(y);
    RealScalar p = (max)(_x, _y);
    if(p==RealScalar(0)) return 0;
    RealScalar q = (min)(_x, _y);
    RealScalar qp = q/p;
    return p * sqrt(RealScalar(1) + qp*qp);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x4dd00
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x4dd00
movsd %xmm0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x58d00
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7fc24
jp 0x7fc24
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x7fc83
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7fc90
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x3c407(%rip), %xmm1    # 0xbc070
addsd %xmm1, %xmm0
callq 0x10560
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x28(%rbp), %rdi
callq 0x85bc0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x85a0e
jmp 0x859a6
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movb $0x1, %al
xorl %ecx, %ecx
cmpq %rdx, %rcx
movb %al, -0x35(%rbp)
jne 0x859d4
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x85bf0
movb %al, -0x36(%rbp)
jmp 0x859cc
movb -0x36(%rbp), %al
xorb $-0x1, %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x859dd
jmp 0x85a0c
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x85c10
jmp 0x859f3
jmp 0x859a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x85da0
jmp 0x85a74
jmp 0x85a65
jmp 0x85a10
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x85d80
movq %rax, -0x40(%rbp)
jmp 0x85a37
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x85a63
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x85c10
jmp 0x85a61
jmp 0x85a10
jmp 0x85a65
leaq -0x28(%rbp), %rdi
callq 0x85da0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x28(%rbp), %rdi
callq 0x85bc0
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x1, 0x80(%rcx)
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x87150
testb $0x1, -0x9(%rbp)
je 0x85b9a
jmp 0x85ae7
movq -0x50(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, %rax
jbe 0x85b27
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x85c10
jmp 0x85b0b
jmp 0x85ae7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x85da0
jmp 0x85ba9
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x871d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x87240
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x87200
testb $0x1, %al
jne 0x85b62
jmp 0x85b8a
leaq -0x40(%rbp), %rdi
callq 0x87270
movq %rax, %rdi
callq 0x87290
movq %rax, %rdi
callq 0x872e0
jmp 0x85b7d
jmp 0x85b7f
leaq -0x40(%rbp), %rdi
callq 0x87310
jmp 0x85b3b
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x87330
leaq -0x28(%rbp), %rdi
callq 0x85da0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Kingsford-Group[P]ghost2/include/./threadpool/./detail/worker_thread.hpp
// Function: 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>>::run()
void run()
	  { 
		  scope_guard notify_exception(bind(&worker_thread::died_unexpectedly, this));

		  while(m_pool->execute_task()) {}

		  notify_exception.disable();
		  m_pool->worker_destructed(this->shared_from_this());
	  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
leaq 0xd7f(%rip), %rax       # 0x89150
movq %rax, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x890c0
movq -0x58(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x68(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
xorl %esi, %esi
callq 0x891c0
movq -0xa0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x89230
jmp 0x88424
leaq -0x50(%rbp), %rdi
callq 0x261a0
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
callq 0x89260
movq %rax, %rdi
callq 0x892b0
movb %al, -0xa9(%rbp)
jmp 0x8844d
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x88459
jmp 0x8848c
jmp 0x8842d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x261a0
jmp 0x8851a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x88511
leaq -0x30(%rbp), %rdi
callq 0x89460
jmp 0x88497
movq -0xa8(%rbp), %rdi
addq $0x10, %rdi
callq 0x89260
movq -0xa8(%rbp), %rsi
movq %rax, -0xb8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x89550
jmp 0x884c3
movq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x89480
jmp 0x884d8
leaq -0x98(%rbp), %rdi
callq 0x84f50
leaq -0x30(%rbp), %rdi
callq 0x895d0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x84f50
leaq -0x30(%rbp), %rdi
callq 0x895d0
movq -0x80(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq %rsi, %rdx
addq $0xa0, %rdx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x87e40
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq 0x10(%rax), %rcx
decq %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rax), %rcx
decq %rcx
movq %rcx, 0x20(%rax)
callq 0x88010
movq %rax, -0x38(%rbp)
jmp 0x894dc
movq -0x38(%rbp), %rdi
addq $0xc8, %rdi
callq 0x87150
movq -0x48(%rbp), %rax
movb 0x80(%rax), %al
testb $0x1, %al
je 0x89538
leaq -0x20(%rbp), %rdi
callq 0x88010
movq %rax, -0x58(%rbp)
jmp 0x89509
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x88, %rdi
callq 0x897d0
jmp 0x8951f
jmp 0x89538
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x880f0
jmp 0x89547
leaq -0x20(%rbp), %rdi
callq 0x880f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10cc0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq %rsi, %rdx
addq $0xa0, %rdx
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x87e40
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq 0x10(%rax), %rcx
decq %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rax), %rcx
decq %rcx
movq %rcx, 0x20(%rax)
callq 0x88010
movq %rax, -0x38(%rbp)
jmp 0x8972c
movq -0x38(%rbp), %rdi
addq $0xc8, %rdi
callq 0x87150
movq -0x48(%rbp), %rax
movb 0x80(%rax), %al
testb $0x1, %al
je 0x89788
leaq -0x20(%rbp), %rdi
callq 0x88010
movq %rax, -0x58(%rbp)
jmp 0x89759
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x88, %rdi
callq 0x897d0
jmp 0x8976f
jmp 0x897b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x880f0
jmp 0x897c7
leaq -0x20(%rbp), %rdi
callq 0x88010
movq %rax, -0x60(%rbp)
jmp 0x89797
movq -0x60(%rbp), %rdi
addq $0x78, %rdi
callq 0x89840
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x89890
jmp 0x897b6
jmp 0x897b8
leaq -0x20(%rbp), %rdi
callq 0x880f0
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10cc0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, %rdx
addq $0xa0, %rdx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x87e40
movq -0x48(%rbp), %rdi
callq 0x88010
movq %rax, %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x8e740
movb %al, -0x39(%rbp)
jmp 0x8e6c9
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8e6d2
jmp 0x8e70e
leaq -0x28(%rbp), %rdi
callq 0x88010
movq %rax, %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x8e770
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x8e719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x880f0
jmp 0x8e72d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x880f0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10cc0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xa7780
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rdx)
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdx)
movq -0x20(%rbp), %rax
movq %rax, 0x28(%rdx)
movq %rdx, %rdi
addq $0x28, %rdi
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x20, %rdx
callq 0xa77c0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
imulq 0x28(%rax), %rcx
movq %rcx, 0x30(%rax)
movq 0x28(%rax), %rcx
imulq 0x20(%rax), %rcx
movq %rcx, 0x38(%rax)
movq 0x28(%rax), %rcx
shlq $0x3, %rcx
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x56c70
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xa7880
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x80, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x37360
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jle 0xa7839
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x40(%rbp)
jmp 0xa7841
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xa7841
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0xa786b
movabsq $0xfffffffc, %rcx       # imm = 0xFFFFFFFC
andq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x89fdd(%rip)     # 0x131878
jne 0xa78cf
callq 0xa7960
movslq %eax, %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0xa7930
movq %rax, 0x89fba(%rip)     # 0x131870
callq 0xa7990
movslq %eax, %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0xa7930
movq %rax, 0x89fa9(%rip)     # 0x131878
cmpl $0x1, -0x4(%rbp)
jne 0xa78f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x89f8d(%rip)     # 0x131870
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x89f87(%rip)     # 0x131878
jmp 0xa791b
cmpl $0x0, -0x4(%rbp)
jne 0xa7917
movq 0x89f70(%rip), %rcx     # 0x131870
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x89f6a(%rip), %rcx     # 0x131878
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xa7919
jmp 0xa7919
jmp 0xa791b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %ecx, %ecx
movl %ecx, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x38(%rbp)
movl %eax, %esi
movl -0x38(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movl %ecx, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0x2e1c3(%rip), %rsi     # 0xd5bd8
callq 0xa7a90
testb $0x1, %al
jne 0xa7a20
jmp 0xa7a36
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0xa7ae0
jmp 0xa7a89
leaq -0x30(%rbp), %rdi
leaq 0x2e1a4(%rip), %rsi     # 0xd5be5
callq 0xa7a90
testb $0x1, %al
jne 0xa7a60
leaq -0x30(%rbp), %rdi
leaq 0x2e19d(%rip), %rsi     # 0xd5bf2
callq 0xa7a90
testb $0x1, %al
jne 0xa7a60
jmp 0xa7a73
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa7b30
jmp 0xa7a87
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0xa7ae0
jmp 0xa7a89
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x33f0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
leaq 0x732b(%rip), %rsi      # 0xb0fc
callq 0x5310
jmp 0x3dd8
leaq -0x1a(%rbp), %rdi
callq 0x3290
movq -0x18(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x57f0
jmp 0x3e00
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x22, %edx
callq 0x57a0
jmp 0x3e14
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3470
movq %rax, -0xd8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
leaq -0x68(%rbp), %rdi
callq 0x3150
movq -0xd8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x3f29
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movq -0xe8(%rbp), %rsi
movq %rax, %rcx
movq -0xe0(%rbp), %rax
leaq 0x3(%rax,%rcx), %rdx
leaq -0x88(%rbp), %rdi
movq $-0x1, %rcx
callq 0x3260
jmp 0x3ea1
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x32f0
leaq -0x88(%rbp), %rdi
callq 0x3150
movq -0xc0(%rbp), %rdi
leaq 0x71e0(%rip), %rsi      # 0xb0ae
xorl %eax, %eax
movl %eax, %edx
callq 0x3110
movq %rax, -0x90(%rbp)
cmpq $-0x1, -0x90(%rbp)
je 0x3f27
movq -0xc0(%rbp), %rsi
movq -0x90(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0xb0(%rbp), %rdi
callq 0x3260
jmp 0x3f08
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x32f0
leaq -0xb0(%rbp), %rdi
callq 0x3150
jmp 0x3f29
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3f3f
movq -0xc0(%rbp), %rdi
callq 0x3150
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x5790
nopw (%rax,%rax)
// File: acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::Core(int, char**)
Core::Core(int ac, char **av) : parser(Parser(ac, av))
{
	std::map<std::string, std::string> map = this->parser.getMap();
	this->updateActivate(this->parser.getMap());
	if (!parser.isGraphicMode()) {

		this->terminal =  new Curses(this->data);
		this->terminalInterface();
	} else {
		execve("graphic/myHpot", av, av);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq 0x15fc3(%rip), %rax     # 0x1aa78
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x70(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x8ee0
movq -0x68(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x60(%rbp)
callq 0x6cf0
jmp 0x4adf
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0xa660
movq %rax, -0x78(%rbp)
jmp 0x4af2
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x6e20
jmp 0x4b01
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0xa660
movq %rax, -0x80(%rbp)
jmp 0x4b14
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x4c20
jmp 0x4b23
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
callq 0xa820
movb %al, -0x81(%rbp)
jmp 0x4b38
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x4bd0
jmp 0x4b48
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x4410
movq %rax, -0x90(%rbp)
jmp 0x4b5b
movq -0x90(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x68, %rsi
callq 0xf570
jmp 0x4b71
movq -0x68(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, 0x700(%rdi)
callq 0x60a0
jmp 0x4b8a
jmp 0x4be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4bff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4bf6
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x43e0
jmp 0x4bf6
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xf425(%rip), %rdi      # 0x14004
callq 0x46b0
leaq -0x58(%rbp), %rdi
callq 0x6e50
addq $0x90, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x6e50
movq -0x60(%rbp), %rdi
callq 0x6e70
movq -0x70(%rbp), %rdi
callq 0x6f00
movq -0x20(%rbp), %rdi
callq 0x46f0
nopw (%rax,%rax)
// File: acherkaoui[P]HTOP/core/Core.cpp
// Function: Core::terminalInterface()
void Core::terminalInterface()
{
	std::map<std::string, std::string> map = this->parser.getMap();

	while(true) {
		(*terminal).clearTerminal();
		if(data.clock.isActive())
			(*terminal).printTime();
		if(data.cpu.isActive())
			(*terminal).printCpu();
		if(data.ram.isActive())
			(*terminal).printRam();
		if(data.user.isActive())
			(*terminal).printUser();
		if(data.network.isActive())
			(*terminal).printNet();
		(*terminal).refreshTerminal();
		usleep(30000);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0xa660
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x6e20
jmp 0x60cb
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x124c0
jmp 0x60dd
movq -0x50(%rbp), %rdi
addq $0xa0, %rdi
callq 0xbd20
movb %al, -0x51(%rbp)
jmp 0x60f2
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x60fb
jmp 0x6129
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x12120
jmp 0x610d
jmp 0x6129
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6e50
jmp 0x6211
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
callq 0xbd20
movb %al, -0x52(%rbp)
jmp 0x613b
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x6144
jmp 0x6158
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x119e0
jmp 0x6156
jmp 0x6158
movq -0x50(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0xbd20
movb %al, -0x53(%rbp)
jmp 0x616d
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x6176
jmp 0x618a
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x10070
jmp 0x6188
jmp 0x618a
movq -0x50(%rbp), %rdi
addq $0x2b0, %rdi            # imm = 0x2B0
callq 0xbd20
movb %al, -0x54(%rbp)
jmp 0x619f
movb -0x54(%rbp), %al
testb $0x1, %al
jne 0x61a8
jmp 0x61bc
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x10f10
jmp 0x61ba
jmp 0x61bc
movq -0x50(%rbp), %rdi
addq $0xd0, %rdi
callq 0xbd20
movb %al, -0x55(%rbp)
jmp 0x61d1
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x61da
jmp 0x61ee
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0x11530
jmp 0x61ec
jmp 0x61ee
movq -0x50(%rbp), %rax
movq 0x700(%rax), %rdi
callq 0xfa40
jmp 0x6200
movl $0x7530, %edi           # imm = 0x7530
callq 0x45c0
jmp 0x620c
jmp 0x60c9
movq -0x40(%rbp), %rdi
callq 0x46f0
nopw (%rax,%rax)
// File: acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Parser::parse(std::string file)
{
	std::ifstream input(file);
	std::string line;

	if (!input.is_open())
		return (1);
	while (!input.eof()) {
		getline(input, line);
		if (line.find('=') == std::string::npos)
			return (1);
		this->_map[line.substr(0, line.find('='))] =
		line.substr(line.find('=') + 1);
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2a8(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
movl $0x8, %edx
callq 0x4660
leaq -0x240(%rbp), %rdi
callq 0x45b0
movq -0x2a0(%rbp), %rdi
callq 0x4650
movb %al, -0x291(%rbp)
jmp 0x9596
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x95cf
jmp 0x95a2
movl $0x1, -0x4(%rbp)
movl $0x1, -0x250(%rbp)
jmp 0x9777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x979b
jmp 0x95d1
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x4730
movb %al, -0x2a9(%rbp)
jmp 0x95f1
movb -0x2a9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x9602
jmp 0x9766
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x40e0
jmp 0x9617
leaq -0x240(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4580
cmpq $-0x1, %rax
jne 0x9648
movl $0x1, -0x4(%rbp)
movl $0x1, -0x250(%rbp)
jmp 0x9777
xorl %eax, %eax
movl %eax, %edx
leaq -0x240(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
movl $0x3d, %esi
callq 0x4580
movq -0x2b8(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0x270(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4440
jmp 0x9686
movq -0x2a8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x2d0(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x2c0(%rbp)
leaq -0x240(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
movl $0x3d, %esi
callq 0x4580
movq -0x2c8(%rbp), %rsi
movq -0x2c0(%rbp), %rdx
movq %rax, %rcx
leaq -0x290(%rbp), %rdi
callq 0x4440
jmp 0x96da
movq -0x2d0(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x6fd0
movq %rax, -0x2d8(%rbp)
jmp 0x96f6
movq -0x2d8(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x4510
leaq -0x290(%rbp), %rdi
callq 0x42a0
leaq -0x270(%rbp), %rdi
callq 0x42a0
jmp 0x95d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x9758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x42a0
leaq -0x270(%rbp), %rdi
callq 0x42a0
jmp 0x979b
movl $0x0, -0x4(%rbp)
movl $0x1, -0x250(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x42a0
leaq -0x220(%rbp), %rdi
callq 0x4130
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
leaq -0x240(%rbp), %rdi
callq 0x42a0
leaq -0x220(%rbp), %rdi
callq 0x4130
movq -0x248(%rbp), %rdi
callq 0x46f0
nop
// File: acherkaoui[P]HTOP/core/Parser.cpp
// Function: Parser::isBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool Parser::isBool(std::string boolean) const
{
	return (boolean == "1" ||
		boolean == "0" ||
		boolean == "true" ||
		boolean == "false");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x9bb8(%rip), %rsi      # 0x141ae
callq 0x70b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xa652
movq -0x20(%rbp), %rdi
leaq 0x9b9e(%rip), %rsi      # 0x141b0
callq 0x70b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xa652
movq -0x20(%rbp), %rdi
leaq 0x9a39(%rip), %rsi      # 0x14067
callq 0x70b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0xa652
movq -0x20(%rbp), %rdi
leaq 0x9b68(%rip), %rsi      # 0x141b2
callq 0x70b0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: acherkaoui[P]HTOP/modules/CPU.cpp
// Function: GetActiveTime(CPUData_s const&)
static size_t GetActiveTime(const CPUData &data)
{
	return  (data.times[S_USER] +
		data.times[S_NICE] +
		data.times[S_SYSTEM] +
		data.times[S_IRQ] +
		data.times[S_SOFTIRQ] +
		data.times[S_STEAL] +
		data.times[S_GUEST] +
		data.times[S_GUEST_NICE]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x28(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x30(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x48(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x50(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x58(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x60(%rcx), %rax
movq -0x8(%rbp), %rcx
addq 0x68(%rcx), %rax
popq %rbp
retq
nopw (%rax,%rax)