LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/OMS.cc
// Function: Sort(double**, int, int)
void Sort(	double **MoleculeCoordinates, 
		int Criterion,
		int Size)
{

	int i,j;
	double *Swap;

	for (i = 0 ; i < Size-1; i++)
		for (j = 0 ; j < Size - i - 1; j++)
			if (MoleculeCoordinates[j][Criterion] > MoleculeCoordinates[j+1][Criterion]) 
			{
				Swap = MoleculeCoordinates[j];
				MoleculeCoordinates[j] = MoleculeCoordinates[j+1];
				MoleculeCoordinates[j+1] = Swap;
			}
}

// Assembly:
movslq %esi, %rax
cmpl $0x2, %edx
pushq $0x1
popq %rcx
cmovgel %edx, %ecx
decl %ecx
xorl %esi, %esi
cmpq %rcx, %rsi
je 0xc3e34
movl %esi, %r8d
notl %r8d
addl %edx, %r8d
movslq %r8d, %r8
xorl %r9d, %r9d
cmpq %r8, %r9
jge 0xc3e2f
movq (%rdi,%r9,8), %r10
movq 0x8(%rdi,%r9,8), %r11
movsd (%r10,%rax,8), %xmm0
ucomisd (%r11,%rax,8), %xmm0
jbe 0xc3e2a
movq %r11, (%rdi,%r9,8)
movq %r10, 0x8(%rdi,%r9,8)
incq %r9
jmp 0xc3e05
incq %rsi
jmp 0xc3df1
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Swap.h
// Function: Eigen::internal::assign_LinearTraversal_CompleteUnrolling<Eigen::SwapWrapper<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, 1, 3>::run(Eigen::SwapWrapper<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>>&, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true> const&)
void copyCoeff(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_expression.size());
      Scalar tmp = m_expression.coeff(index);
      m_expression.coeffRef(index) = _other.coeff(index);
      _other.coeffRef(index) = tmp;
    }

// Assembly:
movq (%rdi), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq (%rsi), %rcx
movsd 0x8(%rcx), %xmm1
movsd %xmm1, 0x8(%rax)
movsd %xmm0, 0x8(%rcx)
movsd 0x10(%rax), %xmm0
movsd 0x10(%rcx), %xmm1
movsd %xmm1, 0x10(%rax)
movsd %xmm0, 0x10(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Matrix.h
// Function: Eigen::Matrix<double, 3, 1, 0, 3, 1>::Matrix(long)
Matrix(Index dim)
      : Base(dim, RowsAtCompileTime == 1 ? 1 : dim, ColsAtCompileTime == 1 ? 1 : dim)
    {
      Base::_check_template_params();
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Matrix)
      eigen_assert(dim >= 0);
      eigen_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == dim);
      EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
    }

// Assembly:
pushq %rax
testq %rsi, %rsi
js 0xc4a2c
cmpq $0x3, %rsi
jne 0xc4a4b
popq %rax
retq
leaq 0x4216b(%rip), %rdi     # 0x106b9e
leaq 0x4216d(%rip), %rsi     # 0x106ba7
leaq 0x42180(%rip), %rcx     # 0x106bc1
movl $0xf0, %edx
callq 0x42c0
leaq 0x421ed(%rip), %rdi     # 0x106c3f
leaq 0x4214e(%rip), %rsi     # 0x106ba7
leaq 0x42161(%rip), %rcx     # 0x106bc1
movl $0xf1, %edx
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Householder/Householder.h
// Function: void Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>>::applyHouseholderOnTheLeft<Eigen::VectorBlock<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1>>(Eigen::VectorBlock<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1> const&, double const&, double*)
void MatrixBase<Derived>::applyHouseholderOnTheLeft(
  const EssentialPart& essential,
  const Scalar& tau,
  Scalar* workspace)
{
  if(rows() == 1)
  {
    *this *= Scalar(1)-tau;
  }
  else
  {
    Map<typename internal::plain_row_type<PlainObject>::type> tmp(workspace,cols());
    Block<Derived, EssentialPart::SizeAtCompileTime, Derived::ColsAtCompileTime> bottom(derived(), 1, 0, rows()-1, cols());
    tmp.noalias() = essential.adjoint() * bottom;
    tmp += this->row(0);
    this->row(0) -= tau * tmp;
    bottom.noalias() -= tau * essential * tmp;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdx, %r15
movq %rdi, %r13
cmpq $0x1, 0x8(%rdi)
jne 0xc4fd9
movsd 0x3709a(%rip), %xmm0    # 0xfc058
subsd (%r15), %xmm0
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r13, %rdi
callq 0xc5d7a
jmp 0xc5108
movq %rsi, %rbx
movq 0x10(%r13), %rdx
leaq 0x10(%rsp), %rdi
movq %rcx, %rsi
callq 0xc5ff2
movq 0x8(%r13), %r8
movq 0x10(%r13), %r9
decq %r8
leaq 0x120(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0xc5dc8
movups (%rbx), %xmm0
leaq 0x30(%rsp), %rbp
movaps %xmm0, (%rbp)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%rbp)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x28(%rbp)
movq 0x38(%rbx), %rax
movq %rax, 0x38(%rbp)
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xc60a6
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xc610a
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xc6570
movq %r14, %rdi
movq %r12, %rsi
callq 0xc5e36
movsd (%r15), %xmm0
movq (%r14), %rax
movq 0x10(%r14), %rcx
movq %rax, (%rbp)
movq %rcx, 0x10(%rbp)
movsd %xmm0, 0x20(%rbp)
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xc6570
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xc5e5e
movsd (%r15), %xmm0
movups (%rbx), %xmm1
movaps %xmm1, (%r13)
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r13)
movups 0x28(%rbx), %xmm1
movups %xmm1, 0x28(%r13)
movq 0x38(%rbx), %rax
movq %rax, 0x38(%r13)
movsd %xmm0, 0x40(%r13)
leaq 0x78(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc67e2
leaq 0x8(%rsp), %rdi
leaq 0x120(%rsp), %rax
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0xc5e86
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Block.h
// Function: Eigen::Block<Eigen::Matrix<double, 1, 3, 1, 1, 3>, 1, -1, false>::Block(Eigen::Matrix<double, 1, 3, 1, 1, 3>&, long, long, long, long)
inline Block(XprType& xpr,
          Index a_startRow, Index a_startCol,
          Index blockRows, Index blockCols)
      : Impl(xpr, a_startRow, a_startCol, blockRows, blockCols)
    {
      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
      eigen_assert(a_startRow >= 0 && blockRows >= 0 && a_startRow  <= xpr.rows() - blockRows
          && a_startCol >= 0 && blockCols >= 0 && a_startCol <= xpr.cols() - blockCols);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
callq 0xc5404
cmpq $0x1, %r12
jne 0xc53e4
testq %r15, %r15
js 0xc53c5
jne 0xc53c5
movq %rbx, %rax
orq %r14, %rax
js 0xc53c5
pushq $0x3
popq %rax
subq %rbx, %rax
cmpq %r14, %rax
jl 0xc53c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x41edd(%rip), %rdi     # 0x1072a9
leaq 0x41a73(%rip), %rsi     # 0x106e46
leaq 0x41e19(%rip), %rcx     # 0x1071f3
movl $0x8e, %edx
callq 0x42c0
leaq 0x41d8b(%rip), %rdi     # 0x107176
leaq 0x41a54(%rip), %rsi     # 0x106e46
leaq 0x41dfa(%rip), %rcx     # 0x1071f3
movl $0x8c, %edx
callq 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/MapBase.h
// Function: Eigen::MapBase<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>, 0>::MapBase(double*, long, long)
inline MapBase(PointerType dataPtr, Index nbRows, Index nbCols)
            : m_data(dataPtr), m_rows(nbRows), m_cols(nbCols)
    {
      eigen_assert( (dataPtr == 0)
              || (   nbRows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
                  && nbCols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols)));
      checkSanity();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
addq $0x10, %rdi
movq %rcx, %rsi
callq 0xc5314
testq %r15, %r15
je 0xc55e5
cmpq $0x1, %rbx
jne 0xc55eb
orq %r14, %rbx
js 0xc55eb
popq %rbx
popq %r14
popq %r15
retq
leaq 0x41915(%rip), %rdi     # 0x106f07
leaq 0x419c0(%rip), %rsi     # 0x106fb9
leaq 0x41ed6(%rip), %rcx     # 0x1074d6
movl $0x94, %edx
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Redux.h
// Function: Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const, 1, -1, true> const> const, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const, -1, 1, true> const>, 0, 0>::run(Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const, 1, -1, true> const> const, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const, -1, 1, true> const> const&, Eigen::internal::scalar_sum_op<double> const&)
static EIGEN_STRONG_INLINE Scalar run(const Derived& mat, const Func& func)
  {
    eigen_assert(mat.rows()>0 && mat.cols()>0 && "you are using an empty matrix");
    Scalar res;
    res = mat.coeffByOuterInner(0, 0);
    for(Index i = 1; i < mat.innerSize(); ++i)
      res = func(res, mat.coeffByOuterInner(0, i));
    for(Index i = 1; i < mat.outerSize(); ++i)
      for(Index j = 0; j < mat.innerSize(); ++j)
        res = func(res, mat.coeffByOuterInner(i, j));
    return res;
  }

// Assembly:
pushq %rax
movq 0x68(%rdi), %rax
testq %rax, %rax
jle 0xc6550
movq (%rdi), %rcx
movq 0x60(%rdi), %rdx
movsd (%rcx), %xmm0
mulsd (%rdx), %xmm0
pushq $0x1
popq %rsi
cmpq %rsi, %rax
je 0xc654e
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0xc6536
popq %rax
retq
leaq 0x41063(%rip), %rdi     # 0x1075ba
leaq 0x4109c(%rip), %rsi     # 0x1075fa
leaq 0x43318(%rip), %rcx     # 0x10987d
movl $0xaf, %edx
callq 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Householder/Householder.h
// Function: void Eigen::MatrixBase<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>>::makeHouseholder<Eigen::VectorBlock<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>, -1>>(Eigen::VectorBlock<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>, -1>&, double&, double&) const
void MatrixBase<Derived>::makeHouseholder(
  EssentialPart& essential,
  Scalar& tau,
  RealScalar& beta) const
{
  using std::sqrt;
  using numext::conj;
  
  EIGEN_STATIC_ASSERT_VECTOR_ONLY(EssentialPart)
  VectorBlock<const Derived, EssentialPart::SizeAtCompileTime> tail(derived(), 1, size()-1);
  
  RealScalar tailSqNorm = size()==1 ? RealScalar(0) : tail.squaredNorm();
  Scalar c0 = coeff(0);

  if(tailSqNorm == RealScalar(0) && numext::imag(c0)==RealScalar(0))
  {
    tau = RealScalar(0);
    beta = numext::real(c0);
    essential.setZero();
  }
  else
  {
    beta = sqrt(numext::abs2(c0) + tailSqNorm);
    if (numext::real(c0)>=RealScalar(0))
      beta = -beta;
    essential = tail / (c0 - beta);
    tau = conj((beta - c0) / beta);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rcx
decq %rcx
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r12, %rsi
callq 0xc5930
cmpq $0x1, 0x8(%r12)
jne 0xc5717
movq (%r12), %rax
movsd (%rax), %xmm2
jmp 0xc5735
leaq 0x10(%rsp), %rdi
callq 0xc593e
movq (%r12), %rax
movsd (%rax), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xc5755
jp 0xc5755
andq $0x0, (%rbx)
movsd %xmm2, (%r14)
movq %r15, %rdi
callq 0xc5978
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd %xmm2, 0x8(%rsp)
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0xc576f
sqrtsd %xmm0, %xmm0
jmp 0xc5774
callq 0x4390
movapd 0x3ae54(%rip), %xmm1    # 0x1005d0
xorpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm3
cmpnlesd %xmm3, %xmm2
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
movlpd %xmm2, (%r14)
movapd %xmm3, %xmm0
subsd %xmm2, %xmm0
movups 0x10(%rsp), %xmm1
movupd 0x28(%rsp), %xmm2
leaq 0x70(%rsp), %rsi
movaps %xmm1, (%rsi)
movupd %xmm2, 0x18(%rsi)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsi)
movups 0x50(%rsp), %xmm1
movaps %xmm1, 0x40(%rsi)
movups 0x60(%rsp), %xmm1
movaps %xmm1, 0x50(%rsi)
movsd %xmm0, 0x60(%rsi)
movq %r15, %rdi
callq 0xc5c3a
movsd (%r14), %xmm0
movapd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
jmp 0xc5746
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/CwiseNullaryOp.h
// Function: Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Block<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false>, -1, 1, false>>::CwiseNullaryOp(long, long, Eigen::internal::scalar_constant_op<double> const&)
CwiseNullaryOp(Index nbRows, Index nbCols, const NullaryOp& func = NullaryOp())
      : m_rows(nbRows), m_cols(nbCols), m_functor(func)
    {
      eigen_assert(nbRows >= 0
            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == nbRows)
            &&  nbCols >= 0
            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == nbCols));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0xc5314
movsd (%r15), %xmm0
movsd %xmm0, 0x10(%r12)
cmpq $0x1, %rbx
jne 0xc5bc0
orq %r14, %rbx
js 0xc5bc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x422bf(%rip), %rdi     # 0x107e86
leaq 0x42355(%rip), %rsi     # 0x107f23
leaq 0x42370(%rip), %rcx     # 0x107f45
pushq $0x3f
popq %rdx
callq 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: Eigen::DenseBase<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>>::operator*=(double const&)
inline Derived& DenseBase<Derived>::operator*=(const Scalar& other)
{
  typedef typename Derived::PlainObject PlainObject;
  SelfCwiseBinaryOp<internal::scalar_product_op<Scalar>, Derived, typename PlainObject::ConstantReturnType> tmp(derived());
  tmp = PlainObject::Constant(rows(),cols(),other);
  return derived();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rdi, (%r14)
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc5eb8
movq %r14, %rdi
movq %r15, %rsi
callq 0xc5edc
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/MapBase.h
// Function: Eigen::MapBase<Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>>, 0>::MapBase(double*, long)
inline MapBase(PointerType dataPtr, Index vecSize)
            : m_data(dataPtr),
              m_rows(RowsAtCompileTime == Dynamic ? vecSize : Index(RowsAtCompileTime)),
              m_cols(ColsAtCompileTime == Dynamic ? vecSize : Index(ColsAtCompileTime))
    {
      EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
      eigen_assert(vecSize >= 0);
      eigen_assert(dataPtr == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == vecSize);
      checkSanity();
    }

// Assembly:
movq %rsi, (%rdi)
movq %rdx, 0x10(%rdi)
testq %rdx, %rdx
js 0xc5fff
retq
pushq %rax
leaq 0x429e4(%rip), %rdi     # 0x1089eb
leaq 0x40fab(%rip), %rsi     # 0x106fb9
leaq 0x429e3(%rip), %rcx     # 0x1089f8
movl $0x8a, %edx
callq 0x42c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/products/CoeffBasedProduct.h
// Function: Eigen::CoeffBasedProduct<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const, 6>::CoeffBasedProduct<Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false>>(Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, 3, 1, true>, -1, 1, false> const> const&, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false> const&)
inline CoeffBasedProduct(const Lhs& lhs, const Rhs& rhs)
      : m_lhs(lhs), m_rhs(rhs)
    {
      // we don't allow taking products of matrices of different real types, as that wouldn't be vectorizable.
      // We still allow to mix T and complex<T>.
      EIGEN_STATIC_ASSERT((internal::scalar_product_traits<typename Lhs::RealScalar, typename Rhs::RealScalar>::Defined),
        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
      eigen_assert(lhs.cols() == rhs.rows()
        && "invalid matrix product"
        && "if you wanted a coeff-wise or a dot product use the respective explicit functions");
    }

// Assembly:
movq %rsi, %rax
movq %rdi, %r8
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rdi)
movups 0x28(%rsi), %xmm0
movups %xmm0, 0x28(%rdi)
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
addq $0x40, %rdi
pushq $0x9
popq %rcx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
andq $0x0, 0xa0(%r8)
movq 0x8(%rax), %rax
cmpq 0x8(%rdx), %rax
jne 0xc60ea
retq
pushq %rax
leaq 0x42b3f(%rip), %rdi     # 0x108c31
leaq 0x42bc4(%rip), %rsi     # 0x108cbd
leaq 0x42beb(%rip), %rcx     # 0x108ceb
movl $0x9e, %edx
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Assign.h
// Function: Eigen::internal::assign_impl<Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false>, Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>>, Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>, 0, 0, 0>::run(Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false>, Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>>&, Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256> const&)
static inline void run(Derived1 &dst, const Derived2 &src)
  {
    const Index innerSize = dst.innerSize();
    const Index outerSize = dst.outerSize();
    for(Index outer = 0; outer < outerSize; ++outer)
      for(Index inner = 0; inner < innerSize; ++inner)
        dst.copyCoeffByOuterInner(outer, inner, src);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %r13
xorl %r15d, %r15d
testq %r13, %r13
cmovleq %r15, %r13
movq 0x10(%rax), %rbp
testq %rbp, %rbp
cmovleq %r15, %rbp
cmpq %rbp, %r15
je 0xc6a6d
xorl %r12d, %r12d
cmpq %r12, %r13
je 0xc6a68
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xc6a7c
incq %r12
jmp 0xc6a4d
incq %r15
jmp 0xc6a45
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: void Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, 1, -1, false>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const>>::copyCoeff<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const>>(long, Eigen::DenseBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const>> const&)
void copyCoeff(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_matrix.size());
      Scalar& tmp = m_matrix.coeffRef(index);
      tmp = m_functor(tmp, _other.coeff(index));
    }

// Assembly:
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x38(%rax), %rax
movq (%rdx), %rdi
movsd (%rdi,%rsi,8), %xmm0
mulsd 0x20(%rdx), %xmm0
imulq %rsi, %rax
movsd (%rcx,%rax,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rax,8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: void Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3>, -1, -1, false>, -1, -1, false>, Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>>::copyCoeff<Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>>(long, long, Eigen::DenseBase<Eigen::CoeffBasedProduct<Eigen::Matrix<double, -1, 1, 0, 3, 1>, Eigen::Map<Eigen::Matrix<double, 1, -1, 1, 1, 3>, 0, Eigen::Stride<0, 0>> const, 256>> const&)
void copyCoeff(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());
      Scalar& tmp = m_matrix.coeffRef(row,col);
      tmp = m_functor(tmp, _other.coeff(row,col));
    }

// Assembly:
movq (%rdi), %rax
movq 0x40(%rax), %rdi
imulq %rdx, %rdi
shlq $0x3, %rdi
addq (%rax), %rdi
movsd (%rcx,%rsi,8), %xmm0
movq 0x20(%rcx), %rax
mulsd (%rax,%rdx,8), %xmm0
movsd (%rdi,%rsi,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rsi,8)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/QR/ColPivHouseholderQR.h
// Function: void Eigen::internal::solve_retval<Eigen::ColPivHouseholderQR<Eigen::Matrix<double, 3, 3, 0, 3, 3>>, Eigen::Matrix<double, 3, 1, 0, 3, 1>>::evalTo<Eigen::Matrix<double, 3, 1, 0, 3, 1>>(Eigen::Matrix<double, 3, 1, 0, 3, 1>&) const
void evalTo(Dest& dst) const
  {
    eigen_assert(rhs().rows() == dec().rows());

    const Index cols = dec().cols(),
				nonzero_pivots = dec().nonzeroPivots();

    if(nonzero_pivots == 0)
    {
      dst.setZero();
      return;
    }

    typename Rhs::PlainObject c(rhs());

    // Note that the matrix Q = H_0^* H_1^*... so its inverse is Q^* = (H_0 H_1 ...)^T
    c.applyOnTheLeft(householderSequence(dec().matrixQR(), dec().hCoeffs())
                     .setLength(dec().nonzeroPivots())
		     .transpose()
      );

    dec().matrixR()
       .topLeftCorner(nonzero_pivots, nonzero_pivots)
       .template triangularView<Upper>()
       .solveInPlace(c.topRows(nonzero_pivots));

    for(Index i = 0; i < nonzero_pivots; ++i) dst.row(dec().colsPermutation().indices().coeff(i)) = c.row(i);
    for(Index i = nonzero_pivots; i < cols; ++i) dst.row(dec().colsPermutation().indices().coeff(i)).setZero();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xc6f50
testq %rax, %rax
je 0xc6f37
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0xc7160
movq (%r14), %rdi
callq 0xc6f92
movq %rax, %r12
movq (%r14), %rdi
leaq 0x48(%rdi), %r13
callq 0xc6f50
movq %rsp, %rbp
movq %r12, (%rbp)
movq %r13, 0x8(%rbp)
movb $0x1, 0x10(%rbp)
movq %rax, 0x18(%rbp)
andq $0x0, 0x20(%rbp)
movq %rbp, %rdi
leaq 0x30(%rsp), %r13
movq %r13, %rsi
callq 0xc71a6
movq (%r14), %rdi
callq 0xc6fc0
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r15, %rcx
callq 0xc6fee
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm1, 0x10(%rbp)
movaps %xmm0, (%rbp)
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r13, %rbp
movq %r13, %rsi
movq %r15, %rdx
callq 0xc7006
movq %rsp, %rdi
movq %r12, %rsi
callq 0xc7e02
xorl %r12d, %r12d
testq %r15, %r15
movq %r15, %r13
cmovleq %r12, %r13
cmpq %r12, %r13
je 0xc6ef8
movq %rsp, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0xc8d28
movq (%r14), %rdi
callq 0xc7020
movslq (%rax,%r12,4), %rdx
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0xc8d28
movq (%rsp), %rax
movsd (%rax), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
incq %r12
jmp 0xc6eb6
movq %rsp, %r12
cmpq $0x3, %r15
jge 0xc6f25
movq (%r14), %rdi
callq 0xc7020
movslq (%rax,%r15,4), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc8d28
movq %r12, %rdi
callq 0xc7052
incq %r15
jmp 0xc6efb
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc6f82
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Householder/HouseholderSequence.h
// Function: void Eigen::HouseholderSequence<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, 1>::applyThisOnTheLeft<Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 1, 1, 1, 1, 1>>(Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 1, 1, 1, 1, 1>&) const
inline void applyThisOnTheLeft(Dest& dst, Workspace& workspace) const
    {
      workspace.resize(dst.cols());
      for(Index k = 0; k < m_length; ++k)
      {
        Index actual_k = m_trans ? k : m_length-k-1;
        dst.bottomRows(rows()-m_shift-actual_k)
           .applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
pushq $-0x1
popq %rbx
xorl %r14d, %r14d
leaq 0x40(%rsp), %r12
leaq 0x18(%rsp), %r13
movq 0x18(%r15), %rbp
cmpq %rbp, %r14
jge 0xc723d
addq %rbx, %rbp
cmpb $0x0, 0x10(%r15)
cmovneq %r14, %rbp
movq 0x20(%r15), %rax
addq %rbp, %rax
pushq $0x3
popq %rdx
subq %rax, %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0xc724c
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xc7398
shlq $0x3, %rbp
addq 0x8(%r15), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
callq 0xc726a
incq %r14
decq %rbx
jmp 0xc71dd
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./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, 3, 3, 0, 3, 3> 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, 3, 1, 0, 3, 1>, -1, 1, false>, -1, 1, false>, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> 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, 3, 3, 0, 3, 3> 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, 3, 1, 0, 3, 1>, -1, 1, false>, -1, 1, false>&, Eigen::GeneralProduct<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Matrix<double, 3, 3, 0, 3, 3> 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(0,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
leaq 0x8(%rsp), %rbp
leaq 0x18(%rdi), %r12
movb $0x1, %al
xorl %r13d, %r13d
leaq 0x40(%rsp), %r15
testb $0x1, %al
je 0xc7a06
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xc7b14
movq 0x30(%r14), %rax
movsd (%rax,%r13,8), %xmm0
movups (%r14), %xmm1
movups %xmm1, (%rbp)
movups (%r12), %xmm1
movups %xmm1, 0x18(%rbp)
movsd 0x28(%r14), %xmm1
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %r15, %rdi
movq %rsp, %rsi
callq 0xc7a18
xorl %eax, %eax
pushq $0x1
popq %r13
jmp 0xc79b4
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/Assign.h
// Function: Eigen::internal::assign_impl<Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>, 3, 0, 0>::run(Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>>&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const> const&)
static EIGEN_STRONG_INLINE void run(Derived1 &dst, const Derived2 &src)
  {
    const Index size = dst.size();
    typedef packet_traits<typename Derived1::Scalar> PacketTraits;
    enum {
      packetSize = PacketTraits::size,
      dstAlignment = PacketTraits::AlignedOnScalar ? Aligned : int(assign_traits<Derived1,Derived2>::DstIsAligned) ,
      srcAlignment = assign_traits<Derived1,Derived2>::JointAlignment
    };
    const Index alignedStart = assign_traits<Derived1,Derived2>::DstIsAligned ? 0
                             : internal::first_aligned(&dst.coeffRef(0), size);
    const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

    unaligned_assign_impl<assign_traits<Derived1,Derived2>::DstIsAligned!=0>::run(src,dst,0,alignedStart);

    for(Index index = alignedStart; index < alignedEnd; index += packetSize)
    {
      dst.template copyPacket<Derived2, dstAlignment, srcAlignment>(index, src);
    }

    unaligned_assign_impl<>::run(src,dst,alignedEnd,size);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r14
movl %ecx, %r15d
shrl $0x3, %r15d
andl $0x1, %r15d
cmpq %r14, %r15
cmovgeq %r14, %r15
movq %rsi, %r12
testb $0x7, %cl
cmovneq %r14, %r15
movq %r14, %rax
subq %r15, %rax
pushq $0x2
popq %rcx
cqto
idivq %rcx
leaq (%r15,%rax,2), %r13
movq %rsi, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xc8cd0
cmpq %r13, %r15
jge 0xc8cb5
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc8cfe
addq $0x2, %r15
jmp 0xc8c9c
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc8cd0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./Eigen/src/Core/SelfCwiseBinaryOp.h
// Function: void Eigen::SelfCwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0, Eigen::Stride<0, 0>>, Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>>::copyPacket<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>, 1, 0>(long, Eigen::DenseBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_multiple_op<double>, Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, -1, 1, false> const>> const&)
void copyPacket(Index index, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(index >= 0 && index < m_matrix.size());
      m_matrix.template writePacket<StoreMode>(index,
        m_functor.packetOp(m_matrix.template packet<StoreMode>(index),_other.template packet<LoadMode>(index)) );
    }

// Assembly:
movq (%rdi), %rax
movq (%rax), %rax
movapd (%rax,%rsi,8), %xmm0
movq (%rdx), %rcx
movupd (%rcx,%rsi,8), %xmm1
movsd 0x68(%rdx), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
subpd %xmm2, %xmm0
movapd %xmm0, (%rax,%rsi,8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/./zeojobs.h
// Function: zeoJob::zeoJob()
zeoJob()
   {
   setupErrorFlag = false;
   probeRadiusFlag = false;
   volumeRunFlag = false;
   extendedOutputFlag = false;
   nMCsamplesScaleFactorFlag = false;
   nMCsamplesScaleFactor = 1.0;
   nMCAVsampleDensity = MCAVppA3; // use defauls from zeo_consts.h
   nMCASAsampleDensity = MCASAppA2; 
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
addq $0x248, %rdi            # imm = 0x248
callq 0xd52ce
xorl %eax, %eax
movb %al, (%rbx)
andw $0x0, 0x228(%rbx)
movb %al, 0x244(%rbx)
movb %al, 0x238(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x230(%rbx)
movabsq $0x32000000c8, %rax     # imm = 0x32000000C8
movq %rax, 0x23c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xd1a12
movq %rbx, %rdi
callq 0x4780
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/bench.cpp
// Function: is_sorted(unsigned long const*, unsigned long)
bool is_sorted(const uint64_t* p, size_t size) {
  for (size_t i = 0; i + 1 < size; i++) {
    if (p[i] > p[i + 1]) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq $0x1
popq %rcx
movq %rcx, %rax
cmpq %rsi, %rcx
jae 0x2356
movq -0x8(%rdi,%rax,8), %rdx
leaq 0x1(%rax), %rcx
cmpq (%rdi,%rax,8), %rdx
jbe 0x233f
cmpq %rsi, %rax
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/bench.cpp
// Function: bench_one(sort_algo const&, unsigned long const*, unsigned long*, unsigned long)
void bench_one(const sort_algo& algo, const uint64_t* input, uint64_t* buffer, size_t size) {
    // assert(!is_sorted(input, size));

    // clock_t before, after;
    int64_t elapsed;
    for (int i = 0; i < repeats; i++) {
      std::copy(input, input + size, buffer);
      
      // before = clock();
      SimpleTimer timer;
      algo.fn(buffer, size);
      elapsed = timer.elapsedNanos();
      // after  = clock();
    }

    assert(is_sorted(buffer, size));

    // printf(",%*.1f", (int)strlen(algo.name), (after - before) * 1000000000. / size / CLOCKS_PER_SEC);
    printf(",%*.1f", (int)strlen(algo.name), (double)elapsed / size);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq (,%rcx,8), %rax
movq %rax, (%rsp)
pushq $0x2
popq %r13
leaq 0x10(%rsp), %rbp
subl $0x1, %r13d
jb 0x243a
testq %rbx, %rbx
je 0x2418
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x21e0
movq %rbp, %rdi
pushq $0x1
popq %rsi
callq 0x2762
movq %r15, %rdi
movq %rbx, %rsi
callq *0x8(%r14)
movq %rbp, %rdi
callq 0x2776
movq %rax, %r12
jmp 0x23fc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x233c
testb %al, %al
je 0x249a
movq (%r14), %rdi
callq 0x20a0
cvtsi2sd %r12, %xmm0
movq %rbx, %xmm1
punpckldq 0x2bad(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2bb5(%rip), %xmm1     # 0x5020
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
leaq 0x2c18(%rip), %rdi      # 0x509a
movl %eax, %esi
movb $0x1, %al
callq 0x2040
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b8f(%rip), %rdi      # 0x5030
leaq 0x2ba0(%rip), %rsi      # 0x5048
leaq 0x2ba3(%rip), %rcx      # 0x5052
pushq $0x4d
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/./simple-timer.hpp
// Function: SimpleTimerT<std::chrono::_V2::system_clock>::checkState(SimpleTimerT<std::chrono::_V2::system_clock>::State, char const*)
void checkState(State expected, const char *msg) {
        if (mode_ != expected) {
            if (mode_ != STARTED && mode_ != STOPPED) {
                throw std::logic_error("bad state (maybe uninit?)");
            } else {
                throw std::logic_error(msg);
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %ebp
cmpl %esi, %ebp
jne 0x2a3e
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
cmpl $0x2, %ebp
jae 0x2a5e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
jmp 0x2a6d
leaq 0x26fc(%rip), %rsi      # 0x5161
movq %rbx, %rdi
callq 0x21d0
movq 0x5574(%rip), %rsi      # 0x7fe8
movq 0x5555(%rip), %rdx      # 0x7fd0
movq %rbx, %rdi
callq 0x21f0
jmp 0x2a85
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/msort-copy.cpp
// Function: void msort_with_tmp<int (*)(void const*, void const*)>(msort_param const*, void*, unsigned long, int (*)(void const*, void const*))
void msort_with_tmp (const struct msort_param *p, void *b, size_t n, C cmp)
{
  char *b1, *b2;
  size_t n1, n2;

  if (n <= 1)
    return;

  n1 = n / 2;
  n2 = n - n1;
  b1 = (char *)b;
  b2 = (char *) b + (n1 * p->s);

  msort_with_tmp (p, b1, n1, cmp);
  msort_with_tmp (p, b2, n2, cmp);

  char *tmp = p->t;
  const size_t s = p->s;
  assert(p->var == 1);
  while (n1 > 0 && n2 > 0)
  {
    if (cmp(b1, b2) <= 0)
    {
      *(uint64_t *) tmp = *(uint64_t *) b1;
      b1 += sizeof (uint64_t);
      --n1;
    }
    else
    {
      *(uint64_t *) tmp = *(uint64_t *) b2;
      b2 += sizeof (uint64_t);
      --n2;
    }
    tmp += sizeof (uint64_t);
  }

  if (n1 > 0)
    memcpy (tmp, b1, n1 * s);
  memcpy (b, p->t, (n - n2) * s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x2, %rdx
jae 0x2e9e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %r13
shrq %r13
movq %rdx, 0x20(%rsp)
movq %rdx, %r12
subq %r13, %r12
movq (%rdi), %r14
imulq %r13, %r14
addq %rsi, %r14
movq %r13, %rdx
callq 0x2e7b
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x2e7b
cmpq $0x1, 0x8(%r15)
jne 0x2f7d
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq 0x10(%r15), %r15
movq %rbx, 0x18(%rsp)
testq %r13, %r13
je 0x2f34
testq %r12, %r12
je 0x2f34
movq %rbx, %rdi
movq %r14, %rsi
callq *%rbp
testl %eax, %eax
jle 0x2f1e
movq %r14, %rax
addq $0x8, %r14
decq %r12
jmp 0x2f28
movq %rbx, %rax
addq $0x8, %rbx
decq %r13
movq (%rax), %rax
movq %rax, (%r15)
addq $0x8, %r15
jmp 0x2efc
testq %r13, %r13
movq 0x8(%rsp), %r14
je 0x2f50
imulq %r14, %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2130
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
subq %r12, %rdx
imulq %r14, %rdx
movq 0x18(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
leaq 0x23b3(%rip), %rdi      # 0x5337
leaq 0x232e(%rip), %rsi      # 0x52b9
leaq 0x23b1(%rip), %rcx      # 0x5343
pushq $0x3a
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/radix1.cpp
// Function: radix_sort1(unsigned long*, unsigned long)
void radix_sort1(uint64_t *a, size_t count)
{
    using queuetype = std::vector<uint64_t>;

    for (size_t pass = 0; pass < RADIX_LEVELS; pass++) {
        uint64_t shift = pass * RADIX_BITS;
        std::array<queuetype, RADIX_SIZE> queues;

        // copy each element into the appropriate queue based on the current RADIX_BITS sized
        // "digit" within it
        for (size_t i = 0; i < count; i++) {
            size_t value = a[i];
            size_t index = (value >> shift) & RADIX_MASK;
            queues[index].push_back(value);
        }

        // copy all the queues back over top of the original array in order
        uint64_t* aptr = a;
        for (auto& queue : queues) {
            aptr = std::copy(queue.begin(), queue.end(), aptr);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1818, %rsp           # imm = 0x1818
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x18(%rsp), %rbp
leaq 0x10(%rsp), %r12
cmpq $0x8, %r15
je 0x3159
leaq (,%r15,8), %r13
movl $0x1800, %edx           # imm = 0x1800
movq %rbp, %rdi
xorl %esi, %esi
callq 0x20e0
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x3107
movq (%r14,%rbp,8), %rax
movq %rax, 0x10(%rsp)
movl %r13d, %ecx
shrq %cl, %rax
movzbl %al, %eax
imulq $0x18, %rax, %rax
leaq (%rsp,%rax), %rdi
addq $0x18, %rdi
movq %r12, %rsi
callq 0x3180
incq %rbp
jmp 0x30d7
movq %r15, 0x8(%rsp)
pushq $0x8
popq %r15
movq %r14, %r13
cmpq $0x1808, %r15           # imm = 0x1808
je 0x313f
movq 0x10(%rsp,%r15), %rsi
movq 0x18(%rsp,%r15), %rbp
subq %rsi, %rbp
je 0x3136
movq %r13, %rdi
movq %rbp, %rdx
callq 0x21e0
addq %rbp, %r13
addq $0x18, %r15
jmp 0x3113
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
callq 0x31a0
movq 0x8(%rsp), %r15
incq %r15
jmp 0x30b4
addq $0x1818, %rsp           # imm = 0x1818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/travisdowns[P]sort-bench/radix5.cpp
// Function: radix_sort5(unsigned long*, unsigned long)
void radix_sort5(uint64_t *a, size_t count)
{
    std::unique_ptr<uint64_t[]> queue_area(new uint64_t[count]);

    freq_array_type freqs = {};
    count_frequency(a, count, freqs);

    uint64_t *from = a, *to = queue_area.get();
    
    for (size_t pass = 0; pass < RADIX_LEVELS; pass++) {
        uint64_t shift = pass * RADIX_BITS;

        // array of pointers to the current position in each queue, which we set up based on the
        // known final sizes of each queue (i.e., "tighly packed")
        uint64_t * queue_ptrs[RADIX_SIZE], * next = to;
        for (size_t i = 0; i < RADIX_SIZE; i++) {
            queue_ptrs[i] = next;
            next += freqs[pass][i];
        }

        // copy each element into the appropriate queue based on the current RADIX_BITS sized
        // "digit" within it
        for (size_t i = 0; i < count; i++) {
            size_t value = from[i];
            size_t index = (value >> shift) & RADIX_MASK;
            *queue_ptrs[index]++ = value;
        }

        // swap from and to areas
        std::swap(from, to);
    }

    if (RADIX_LEVELS & 1) {
        std::copy(queue_area.get(), queue_area.get() + count, a);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4810, %rsp           # imm = 0x4810
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rax
shrq $0x3d, %rax
leaq (,%rsi,8), %rcx
xorl %r13d, %r13d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x8(%rsp)
leaq 0x810(%rsp), %r15
movl $0x4000, %edx           # imm = 0x4000
movq %r15, %rdi
xorl %esi, %esi
callq 0x20e0
cmpq %rbx, %r13
je 0x384e
movq (%r12,%r13,8), %rax
xorl %ecx, %ecx
cmpq $0x4000, %rcx           # imm = 0x4000
je 0x3849
movzbl %al, %edx
leaq (%rsp,%rdx,8), %rdx
addq $0x810, %rdx            # imm = 0x810
incq (%rcx,%rdx)
shrq $0x8, %rax
addq $0x800, %rcx            # imm = 0x800
jmp 0x3821
incq %r13
jmp 0x3816
xorl %eax, %eax
cmpq $0x8, %rax
je 0x38be
movq %r12, %rdx
movq %r14, %rcx
xorl %esi, %esi
cmpq $0x100, %rsi            # imm = 0x100
je 0x3879
movq %rcx, 0x10(%rsp,%rsi,8)
movq (%r15,%rsi,8), %rdi
leaq (%rcx,%rdi,8), %rcx
incq %rsi
jmp 0x385e
leaq (,%rax,8), %rcx
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x38ac
movq (%rdx,%rsi,8), %rdi
movq %rdi, %r8
shrq %cl, %r8
movzbl %r8b, %r8d
movq 0x10(%rsp,%r8,8), %r9
leaq 0x8(%r9), %r10
movq %r10, 0x10(%rsp,%r8,8)
movq %rdi, (%r9)
incq %rsi
jmp 0x3883
incq %rax
addq $0x800, %r15            # imm = 0x800
movq %r14, %r12
movq %rdx, %r14
jmp 0x3850
leaq 0x8(%rsp), %rdi
callq 0x294a
addq $0x4810, %rsp           # imm = 0x4810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/pollo[P]graph-partitioning/graph.cpp
// Function: Graph::add_neighbor(int, int)
void Graph::add_neighbor(int node_index, int neighbor_index)
{
  if (node_index != neighbor_index)
  {
    if (node_index>=counted_nodes_number ||
        neighbor_index>=counted_nodes_number)
    {
      counted_nodes_number = max(node_index, neighbor_index) + 1;
      neighbors.resize(max(counted_nodes_number, (int) neighbors.size()));
    }

    if (find(neighbors[node_index].begin(),
             neighbors[node_index].end(),
             neighbor_index) == neighbors[node_index].end())
    {
      neighbors[node_index].push_back(neighbor_index);
      neighbors[neighbor_index].push_back(node_index);
      counted_edges_number += 1;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpl %edx, %esi
je 0x2938
movl %edx, %ecx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl %esi, %eax
setg %dl
cmpl %ecx, %eax
setg %al
testb %al, %dl
jne 0x28e7
cmpl %ecx, %ebp
cmovgl %ebp, %ecx
incl %ecx
movl %ecx, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
cmpl %eax, %ecx
cmovlel %eax, %ecx
movslq %ecx, %rsi
callq 0x2e26
movslq %ebp, %rax
movq 0x10(%rbx), %rcx
imulq $0x18, %rax, %r14
movq (%rcx,%r14), %rdi
movq 0x8(%rcx,%r14), %rsi
leaq 0x8(%rsp), %rdx
callq 0x32de
movq 0x10(%rbx), %rdi
cmpq 0x8(%rdi,%r14), %rax
jne 0x2938
addq %r14, %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2e5c
movslq (%r14), %rax
imulq $0x18, %rax, %rdi
addq 0x10(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2e5c
incq (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop