LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::aligned_malloc(unsigned long)
EIGEN_DEVICE_FUNC inline void* aligned_malloc(std::size_t size)
{
  check_that_malloc_is_allowed();

  void *result;
  #if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED

    EIGEN_USING_STD(malloc)
    result = malloc(size);

    #if EIGEN_DEFAULT_ALIGN_BYTES==16
    eigen_assert((size<16 || (std::size_t(result)%16)==0) && "System's malloc returned an unaligned pointer. Compile with EIGEN_MALLOC_ALREADY_ALIGNED=0 to fallback to handmade aligned memory allocator.");
    #endif
  #else
    result = handmade_aligned_malloc(size);
  #endif

  if(!result && size)
    throw_std_bad_alloc();

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x6500
movq %rax, %rbx
cmpq $0x10, %r14
setae %al
testb $0xf, %bl
setne %cl
testb %cl, %al
jne 0x15010
testq %rbx, %rbx
sete %al
testq %r14, %r14
setne %cl
testb %al, %cl
je 0x15005
callq 0x14fa3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x27f7c(%rip), %rdi     # 0x3cf93
leaq 0x32039(%rip), %rsi     # 0x47057
leaq 0x28029(%rip), %rcx     # 0x3d04e
movl $0xb8, %edx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::resize(long, long)
void resize(Index rows, Index cols)
    {
      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime)
                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime)
                   && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array.");
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols);
      #ifdef EIGEN_INITIALIZE_COEFFS
        Index size = rows*cols;
        bool size_changed = size != this->size();
        m_storage.resize(size, rows, cols);
        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
      #else
        m_storage.resize(rows*cols, rows, cols);
      #endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rax
orq %rsi, %rax
js 0x150f9
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x150df
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rbx
cmpq %r14, %rax
jge 0x150df
callq 0x14fa3
movq %rbx, %rsi
imulq %r14, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x15118
leaq 0x282b9(%rip), %rdi     # 0x3d3b9
leaq 0x31f23(%rip), %rsi     # 0x4702a
leaq 0x2843a(%rip), %rcx     # 0x3d548
movl $0x11d, %edx            # imm = 0x11D
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
      m_cols = cols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x15156
movq %rsi, %r12
movq (%r15), %rdi
callq 0x64a0
testq %r12, %r12
jle 0x15151
movq %r12, %rdi
callq 0x14f7c
jmp 0x15153
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/PlainObjectBase.h
// Function: void Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::resizeLike<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::EigenBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&)
EIGEN_DEVICE_FUNC
    EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
    {
      const OtherDerived& other = _other.derived();
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
      const Index othersize = other.rows()*other.cols();
      if(RowsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(1, othersize);
      }
      else if(ColsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(othersize, 1);
      }
      else resize(other.rows(), other.cols());
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rcx
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x151e9
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %rsi, %rax
jge 0x151e9
callq 0x14fa3
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rcx
cmpq $0x1, %rsi
sete %al
cmpq $0x1, %rcx
sete %dl
orb %al, %dl
je 0x15211
imulq %rcx, %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1524c
leaq 0x283ab(%rip), %rdi     # 0x3d5c3
leaq 0x31e0b(%rip), %rsi     # 0x4702a
leaq 0x283c4(%rip), %rcx     # 0x3d5ea
movl $0x176, %edx            # imm = 0x176
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/AssignEvaluator.h
// Function: void Eigen::internal::call_dense_assignment_loop<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::ArrayWrapper<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const, Eigen::ArrayWrapper<Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const>, Eigen::internal::assign_op<double, double>>(Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::ArrayWrapper<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const, Eigen::ArrayWrapper<Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const> const&, Eigen::internal::assign_op<double, double> const&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;

  SrcEvaluatorType srcEvaluator(src);

  // NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
  // we need to resize the destination after the source evaluator has been created.
  resize_if_allowed(dst, src, func);

  DstEvaluatorType dstEvaluator(dst);
    
  typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());

  dense_assignment_loop<Kernel>::run(kernel);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
leaq 0x40(%rsp), %r15
movq %rax, (%r15)
movq 0x30(%rsi), %rax
movq %rax, 0x10(%r15)
movq 0x38(%rsi), %rax
movq (%rax), %rax
movq %rax, 0x18(%r15)
callq 0x32b85
movq (%r14), %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq 0x30(%r14), %rax
movq %rax, 0x10(%rcx)
leaq 0x20(%rsp), %rdi
movq %rcx, (%rdi)
movq %r15, 0x8(%rdi)
movq %rbx, 0x10(%rdi)
movq %r14, 0x18(%rdi)
callq 0x32bd2
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::perturb_num_components(DNest4::RNG&)
double RJObject<ConditionalPrior>::perturb_num_components(RNG& rng)
{
	double logH = 0.;

	// Work out how many components we will have after the change
	double delta = max_num_components*rng.randh();
	int difference = (int)delta;
	// In case difference is zero, make it +1 or -1. Also, just do this
    // sometimes just because it's gentle
	if(difference == 0)
	{
		if(rng.rand() <= 0.5)
			difference = -1;
		else
			difference =  1;
	}
	int new_num_components = DNest4::mod(num_components + difference, max_num_components + 1);
	difference = new_num_components - num_components;

    // Add to logH for non-uniform prior on N
	if(prior_type == PriorType::log_uniform)
		logH += log(num_components + 1) - log(new_num_components + 1);

	// Now do the required changes
	if(difference > 0)
	{
		for(int i=0; i<difference; i++)
			logH += add_component(rng);
	}
	else
	{
		for(int i=0; i<-difference; i++)
			logH += remove_component(rng);
	}

	return logH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cvtsi2sdl 0x8(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x38bee
mulsd (%rsp), %xmm0
cvttsd2si %xmm0, %edi
testl %edi, %edi
jne 0x155c6
movq %rbx, %rdi
callq 0x38b70
xorl %edi, %edi
movsd 0x26bdc(%rip), %xmm1    # 0x3c198
ucomisd %xmm0, %xmm1
adcl $-0x1, %edi
orl $0x1, %edi
addl 0xb4(%r14), %edi
movl 0x8(%r14), %esi
incl %esi
callq 0x39174
movl %eax, %ebp
movl 0xb4(%r14), %eax
movl %ebp, %r15d
subl %eax, %r15d
xorpd %xmm0, %xmm0
cmpl $0x1, (%r14)
jne 0x1561d
incl %eax
cvtsi2sd %eax, %xmm0
callq 0x63b0
movsd %xmm0, (%rsp)
incl %ebp
cvtsi2sd %ebp, %xmm0
callq 0x63b0
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
testl %r15d, %r15d
movsd %xmm0, (%rsp)
jg 0x15664
negl %r15d
subl $0x1, %r15d
jb 0x1566a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15944
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
jmp 0x1562a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14d22
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
subl $0x1, %r15d
jae 0x1564b
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/DNest4/code/RJObject/RJObjectImpl.h
// Function: DNest4::RJObject<RVConditionalPrior>::remove_component(DNest4::RNG&)
double RJObject<ConditionalPrior>::remove_component(RNG& rng)
{
	if(num_components <= 0)
	{
		std::cerr<<"# WARNING: Trying to remove component ";
		std::cerr<<"but already empty!"<<std::endl;
		return 0.;
	}

	// Find one to delete
	int i = rng.rand_int(num_components);

	// Accumulate added/removed component info
	removed.push_back(components[i]);

	// Delete it
	u_components.erase(u_components.begin() + i);
	components.erase(components.begin() + i);

	// Decrement counter
	num_components--;

	return 0.;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0xb4(%rdi), %eax
testl %eax, %eax
jle 0x159b3
movq %rdi, %rbx
movq %rsi, %rdi
movl %eax, %esi
callq 0x38cc4
leaq 0x100(%rbx), %rdi
leaq 0xb8(%rbx), %r14
cltq
imulq $0x18, %rax, %r15
movq 0xb8(%rbx), %rsi
addq %r15, %rsi
callq 0xb142
leaq 0xd0(%rbx), %rdi
movq 0xd0(%rbx), %rsi
addq %r15, %rsi
callq 0x159ea
addq 0xb8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x159ea
decl 0xb4(%rbx)
jmp 0x159e0
movq 0x4e62e(%rip), %rbx     # 0x63fe8
leaq 0x27e70(%rip), %rsi     # 0x3d831
movq %rbx, %rdi
callq 0x6430
leaq 0x27e88(%rip), %rsi     # 0x3d858
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0x61c0
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/AssignEvaluator.h
// Function: void Eigen::internal::resize_if_allowed<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, double, double>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::internal::assign_op<double, double> const&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
  Index dstRows = src.rows();
  Index dstCols = src.cols();
  if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
    dst.resize(dstRows, dstCols);
  eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbx
cmpq %r14, 0x8(%rdi)
jne 0x16091
movq %rbx, %rax
movq %r14, %rcx
cmpq %rbx, 0x10(%r15)
je 0x160a7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x150a0
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
cmpq %r14, %rcx
jne 0x160b7
cmpq %rbx, %rax
jne 0x160b7
popq %rbx
popq %r14
popq %r15
retq
leaq 0x27663(%rip), %rdi     # 0x3d721
leaq 0x30fbb(%rip), %rsi     # 0x47080
leaq 0x2789c(%rip), %rcx     # 0x3d968
movl $0x2eb, %edx            # imm = 0x2EB
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/Block.h
// Function: Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false>::Block(Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>&, long, long, long, long)
Block(XprType& xpr,
          Index startRow, Index startCol,
          Index blockRows, Index blockCols)
      : Impl(xpr, startRow, startCol, blockRows, blockCols)
    {
      eigen_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
      eigen_assert(startRow >= 0 && blockRows >= 0 && startRow  <= xpr.rows() - blockRows
          && startCol >= 0 && blockCols >= 0 && startCol <= xpr.cols() - blockCols);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
callq 0x166ee
cmpq $0x1, %r13
jne 0x166cf
testq %r12, %r12
js 0x166b0
jne 0x166b0
movq %rbx, %rax
orq %r14, %rax
js 0x166b0
movq 0x10(%r15), %rax
subq %rbx, %rax
cmpq %r14, %rax
jl 0x166b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2782d(%rip), %rdi     # 0x3dee4
leaq 0x327ad(%rip), %rsi     # 0x48e6b
leaq 0x27d42(%rip), %rcx     # 0x3e407
movl $0x93, %edx
callq 0x62b0
leaq 0x2769d(%rip), %rdi     # 0x3dd73
leaq 0x3278e(%rip), %rsi     # 0x48e6b
leaq 0x27d23(%rip), %rcx     # 0x3e407
movl $0x91, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/Redux.h
// Function: double Eigen::DenseBase<Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Map<Eigen::Matrix<double, -1, -1, 1, -1, -1> const, 0, Eigen::OuterStride<-1>> const, 1, -1, true> const, 1, -1, false> const> const, Eigen::Map<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, 0, Eigen::Stride<0, 0>> const>>::redux<Eigen::internal::scalar_sum_op<double, double>>(Eigen::internal::scalar_sum_op<double, double> const&) const
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename internal::traits<Derived>::Scalar
DenseBase<Derived>::redux(const Func& func) const
{
  eigen_assert(this->rows()>0 && this->cols()>0 && "you are using an empty matrix");

  typedef typename internal::redux_evaluator<Derived> ThisEvaluator;
  ThisEvaluator thisEval(derived());

  // The initial expression is passed to the reducer as an additional argument instead of
  // passing it as a member of redux_evaluator to help  
  return internal::redux_impl<Func, ThisEvaluator>::run(thisEval, func, derived());
}

// Assembly:
subq $0x38, %rsp
movq 0x90(%rdi), %rax
testq %rax, %rax
jle 0x1e414
movq %rdi, %rdx
movq (%rdi), %rcx
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movq 0x80(%rdx), %rcx
movq %rcx, 0x10(%rdi)
movq 0x88(%rdx), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x28(%rdi)
callq 0x1e434
addq $0x38, %rsp
retq
leaq 0x1fc9e(%rip), %rdi     # 0x3e0b9
leaq 0x290d6(%rip), %rsi     # 0x474f8
leaq 0x24f21(%rip), %rcx     # 0x4334a
movl $0x19b, %edx            # imm = 0x19B
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/Redux.h
// Function: double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false> const>>, 0, 0>::run<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false> const>>(Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false> const>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>, 1, -1, false> const> const&)
EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE
  Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
  {
    eigen_assert(xpr.rows()>0 && xpr.cols()>0 && "you are using an empty matrix");
    Scalar res;
    res = eval.coeffByOuterInner(0, 0);
    for(Index i = 1; i < xpr.innerSize(); ++i)
      res = func(res, eval.coeffByOuterInner(0, i));
    for(Index i = 1; i < xpr.outerSize(); ++i)
      for(Index j = 0; j < xpr.innerSize(); ++j)
        res = func(res, eval.coeffByOuterInner(i, j));
    return res;
  }

// Assembly:
pushq %rax
movq 0x10(%rdx), %rax
testq %rax, %rax
jle 0x168ef
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movsd (%rdx), %xmm0
andpd 0x2589d(%rip), %xmm0    # 0x3c160
decq %rax
leaq (%rdx,%rcx,8), %rdx
shlq $0x3, %rcx
movapd 0x2588a(%rip), %xmm1    # 0x3c160
subq $0x1, %rax
jb 0x168ed
movsd (%rdx), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
addq %rcx, %rdx
jmp 0x168d6
popq %rax
retq
leaq 0x27e58(%rip), %rdi     # 0x3e74e
leaq 0x30bfb(%rip), %rsi     # 0x474f8
leaq 0x27e8a(%rip), %rcx     # 0x3e78e
movl $0xc8, %edx
callq 0x62b0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/ProductEvaluators.h
// Function: void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, -1, false>, Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 1, -1, false> const>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, 1, false>>(Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, 1, false>&, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, -1, -1, false> const&, Eigen::Transpose<Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 1, -1, false> const> const&, double const&)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
  {
    LhsNested actual_lhs(lhs);
    RhsNested actual_rhs(rhs);
    internal::gemv_dense_selector<Side,
                            (int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
                            bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
                           >::run(actual_lhs, actual_rhs, dst, alpha);
  }

// Assembly:
subq $0xd8, %rsp
movq %rcx, %rax
movq %rdi, %r8
pushq $0xd
popq %rcx
leaq 0x70(%rsp), %r9
movq %r9, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq (%rdx), %rcx
leaq 0x20(%rsp), %rdi
movq %rcx, -0x18(%rdi)
movq 0x10(%rdx), %rcx
movq %rcx, -0x8(%rdi)
leaq 0x18(%rdx), %rsi
pushq $0xa
popq %rcx
rep  movsq (%rsi), %es:(%rdi)
leaq 0x8(%rsp), %rsi
movq %r9, %rdi
movq %r8, %rdx
movq %rax, %rcx
callq 0x1830c
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/examples/trends/../../eigen/Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::ArrayWrapper<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>>>, Eigen::internal::evaluator<Eigen::ArrayWrapper<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>, Eigen::internal::div_assign_op<double, double>, 0>, 3, 0>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::ArrayWrapper<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>>>, Eigen::internal::evaluator<Eigen::ArrayWrapper<Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>, Eigen::internal::div_assign_op<double, double>, 0>&)
void run(Kernel &kernel)
  {
    const Index size = kernel.size();
    typedef typename Kernel::Scalar Scalar;
    typedef typename Kernel::PacketType PacketType;
    enum {
      requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
      packetSize = unpacket_traits<PacketType>::size,
      dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
      dstAlignment = packet_traits<Scalar>::AlignedOnScalar ? int(requestedAlignment)
                                                            : int(Kernel::AssignmentTraits::DstAlignment),
      srcAlignment = Kernel::AssignmentTraits::JointAlignment
    };
    const Index alignedStart = dstIsAligned ? 0 : internal::first_aligned<requestedAlignment>(kernel.dstDataPtr(), size);
    const Index alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;

    unaligned_dense_assignment_loop<dstIsAligned!=0>::run(kernel, 0, alignedStart);

    for(Index index = alignedStart; index < alignedEnd; index += packetSize)
      kernel.template assignPacket<dstAlignment, srcAlignment, PacketType>(index);

    unaligned_dense_assignment_loop<>::run(kernel, alignedEnd, size);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r14
movq %r14, %r15
testb $0x7, %al
jne 0x32d9f
shrl $0x3, %eax
andl $0x1, %eax
cmpq %r14, %rax
cmovgeq %r14, %rax
movq %rax, %r15
movq %r14, %rax
subq %r15, %rax
pushq $0x2
popq %rcx
cqto
idivq %rcx
leaq (%r15,%rax,2), %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x32e06
cmpq %r12, %r15
jge 0x32dec
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rax), %rax
movq (%rcx), %rcx
movupd (%rcx,%r15,8), %xmm0
movapd (%rax,%r15,8), %xmm1
divpd %xmm0, %xmm1
movapd %xmm1, (%rax,%r15,8)
addq $0x2, %r15
jmp 0x32dbe
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x32e06
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/SolveTriangular.h
// Function: Eigen::internal::triangular_solver_selector<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 2, 2, 0, -1>::run(Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const> const&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>&)
static void run(const Lhs& lhs, Rhs& rhs)
  {
    typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);

    const Index size = lhs.rows();
    const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();

    typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
              Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;

    BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);

    triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
                               (Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
      ::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x30(%rdi), %r14
movq (%rdi), %r15
movq 0x10(%rdi), %r12
movq 0x8(%rsi), %r13
movq 0x10(%rsi), %rdx
movq %rsp, %rdi
pushq $0x1
popq %rbp
movq %r13, %rsi
movq %r12, %rcx
movq %rbp, %r8
xorl %r9d, %r9d
callq 0x18518
movq (%rbx), %r8
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r9
movq %rsp, %rax
pushq %rax
pushq 0x30(%rbx)
callq 0x1857a
popq %rax
popq %rcx
movq %rsp, %rdi
callq 0x18ca8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x18ca8
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: Eigen::internal::gemm_blocking_space<0, double, double, -1, -1, -1, 4, false>::gemm_blocking_space(long, long, long, long, bool)
gemm_blocking_space(Index rows, Index cols, Index depth, Index num_threads, bool l3_blocking)
    {
      this->m_mc = Transpose ? cols : rows;
      this->m_nc = Transpose ? rows : cols;
      this->m_kc = depth;

      if(l3_blocking)
      {
        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, this->m_nc, num_threads);
      }
      else  // no l3 blocking
      {
        Index n = this->m_nc;
        computeProductBlockingSizes<LhsScalar,RhsScalar,KcFactor>(this->m_kc, this->m_mc, n, num_threads);
      }

      m_sizeA = this->m_mc * this->m_kc;
      m_sizeB = this->m_kc * this->m_nc;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %rsi
movq %rax, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
movq %rcx, 0x20(%rbx)
testl %r9d, %r9d
je 0x18548
leaq 0x18(%rbx), %rdx
jmp 0x18553
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq %rax, %rdx
movq %r8, %rcx
callq 0x18cbe
movq 0x20(%rbx), %rax
movq 0x10(%rbx), %rcx
imulq %rax, %rcx
movq %rcx, 0x28(%rbx)
imulq 0x18(%rbx), %rax
movq %rax, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::manage_caching_sizes(Eigen::Action, long*, long*, long*)
inline void manage_caching_sizes(Action action, std::ptrdiff_t* l1, std::ptrdiff_t* l2, std::ptrdiff_t* l3)
{
  static CacheSizes m_cacheSizes;

  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_cacheSizes.m_l1 = *l1;
    m_cacheSizes.m_l2 = *l2;
    m_cacheSizes.m_l3 = *l3;
  }
  else if(action==GetAction)
  {
    eigen_internal_assert(l1!=0 && l2!=0);
    *l1 = m_cacheSizes.m_l1;
    *l2 = m_cacheSizes.m_l2;
    *l3 = m_cacheSizes.m_l3;
  }
  else
  {
    eigen_internal_assert(false);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movb 0x4b6cb(%rip), %al      # 0x646b0
testb %al, %al
je 0x19044
testl %ebp, %ebp
je 0x19012
cmpl $0x1, %ebp
jne 0x19039
movq %r15, %rax
leaq 0x4b6ac(%rip), %r15     # 0x646a8
movq %r14, %rcx
leaq 0x4b69a(%rip), %r14     # 0x646a0
movq %rbx, %rdx
leaq 0x4b688(%rip), %rbx     # 0x64698
jmp 0x19027
leaq 0x4b68f(%rip), %rax     # 0x646a8
leaq 0x4b680(%rip), %rcx     # 0x646a0
leaq 0x4b671(%rip), %rdx     # 0x64698
movq (%rdx), %rdx
movq %rdx, (%rbx)
movq (%rcx), %rcx
movq %rcx, (%r14)
movq (%rax), %rax
movq %rax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b665(%rip), %rdi     # 0x646b0
callq 0x6720
testl %eax, %eax
je 0x18fe9
leaq 0x4b63d(%rip), %rdi     # 0x64698
callq 0x19088
leaq 0x4b649(%rip), %rdi     # 0x646b0
callq 0x62a0
jmp 0x18fe9
movq %rax, %rbx
leaq 0x4b635(%rip), %rdi     # 0x646b0
callq 0x6270
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::queryCacheSizes_amd(int&, int&, int&)
inline void queryCacheSizes_amd(int& l1, int& l2, int& l3)
{
  int abcd[4];
  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
  EIGEN_CPUID(abcd,0x80000005,0);
  l1 = (abcd[2] >> 24) * 1024; // C[31:24] = L1 size in KB
  abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
  EIGEN_CPUID(abcd,0x80000006,0);
  l2 = (abcd[2] >> 16) * 1024; // C[31;16] = l2 cache size in KB
  l3 = ((abcd[3] & 0xFFFC000) >> 18) * 512 * 1024; // D[31;18] = l3 cache size in 512KB
}

// Assembly:
movq %rdx, %r8
movl $0x80000005, %eax       # imm = 0x80000005
xorl %ecx, %ecx
xchgq %rbx, %r9
cpuid
xchgq %rbx, %r9
sarl $0xe, %ecx
movl $0xfffffc00, %r9d       # imm = 0xFFFFFC00
andl %r9d, %ecx
movl %ecx, (%rdi)
xorl %ecx, %ecx
movl $0x80000006, %eax       # imm = 0x80000006
xchgq %rbx, %rdi
cpuid
xchgq %rbx, %rdi
sarl $0x6, %ecx
andl %r9d, %ecx
movl %ecx, (%rsi)
addl %edx, %edx
andl $0x1ff80000, %edx       # imm = 0x1FF80000
movl %edx, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::queryCacheSizes_intel_direct(int&, int&, int&)
inline void queryCacheSizes_intel_direct(int& l1, int& l2, int& l3)
{
  int abcd[4];
  l1 = l2 = l3 = 0;
  int cache_id = 0;
  int cache_type = 0;
  do {
    abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
    EIGEN_CPUID(abcd,0x4,cache_id);
    cache_type  = (abcd[0] & 0x0F) >> 0;
    if(cache_type==1||cache_type==3) // data or unified cache
    {
      int cache_level = (abcd[0] & 0xE0) >> 5;  // A[7:5]
      int ways        = (abcd[1] & 0xFFC00000) >> 22; // B[31:22]
      int partitions  = (abcd[1] & 0x003FF000) >> 12; // B[21:12]
      int line_size   = (abcd[1] & 0x00000FFF) >>  0; // B[11:0]
      int sets        = (abcd[2]);                    // C[31:0]

      int cache_size = (ways+1) * (partitions+1) * (line_size+1) * (sets+1);

      switch(cache_level)
      {
        case 1: l1 = cache_size; break;
        case 2: l2 = cache_size; break;
        case 3: l3 = cache_size; break;
        default: break;
      }
    }
    cache_id++;
  } while(cache_type>0 && cache_id<16);
}

// Assembly:
pushq %rbp
pushq %rbx
movq %rdx, %r8
andl $0x0, (%rdx)
andl $0x0, (%rsi)
andl $0x0, (%rdi)
xorl %r10d, %r10d
movl $0x4, %r9d
movl %r9d, %eax
movl %r10d, %ecx
xchgq %rbx, %r11
cpuid
xchgq %rbx, %r11
movl %eax, %edx
andl $0xd, %edx
cmpl $0x1, %edx
jne 0x19251
movl %eax, %ebx
shrl $0x5, %ebx
andl $0x7, %ebx
movq %rdi, %rdx
cmpl $0x1, %ebx
je 0x19222
cmpl $0x3, %ebx
je 0x1921f
movq %rsi, %rdx
cmpl $0x2, %ebx
je 0x19222
jmp 0x19251
movq %r8, %rdx
movl %r11d, %ebx
shrl $0x16, %ebx
movl %r11d, %ebp
shrl $0xc, %ebp
andl $0x3ff, %ebp            # imm = 0x3FF
andl $0xfff, %r11d           # imm = 0xFFF
incl %ebx
incl %ebp
incl %r11d
imull %ebp, %r11d
incl %ecx
imull %ebx, %ecx
imull %r11d, %ecx
movl %ecx, (%rdx)
testb $0xf, %al
je 0x19262
leal 0x1(%r10), %eax
cmpl $0xf, %r10d
movl %eax, %r10d
jb 0x191e8
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::lhs_process_one_packet<4, 2l, 1l, double, double, double, double vector[2], double vector[2], double vector[2], double vector[2], Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, Eigen::internal::BlasLinearMapper<double, long, 0, 1>, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>>::peeled_kc_onestep(long, double const*, double const*, Eigen::internal::gebp_traits<double, double, false, false, 1, 0>, double vector[2]*, Eigen::internal::QuadPacket<double vector[2]>*, double vector[2]*, double vector[2]*, double vector[2]*, double vector[2]*, double vector[2]*)
EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA, const RhsScalar* blB, GEBPTraits traits, LhsPacket *A0, RhsPacketx4 *rhs_panel, RhsPacket *T0, AccPacket *C0, AccPacket *C1, AccPacket *C2, AccPacket *C3)
  {
    EIGEN_ASM_COMMENT("begin step of gebp micro kernel 1X4");
    EIGEN_ASM_COMMENT("Note: these asm comments work around bug 935!");
    traits.loadLhs(&blA[(0+1*K)*LhsProgress], *A0);
    traits.loadRhs(&blB[(0+4*K)*RhsProgress], *rhs_panel);
    traits.madd(*A0, *rhs_panel, *C0, *T0, fix<0>);
    traits.madd(*A0, *rhs_panel, *C1, *T0, fix<1>);
    traits.madd(*A0, *rhs_panel, *C2, *T0, fix<2>);
    traits.madd(*A0, *rhs_panel, *C3, *T0, fix<3>);
    #if EIGEN_GNUC_AT_LEAST(6,0) && defined(EIGEN_VECTORIZE_SSE)
    __asm__  ("" : "+x,m" (*A0));
    #endif
    EIGEN_ASM_COMMENT("end step of gebp micro kernel 1X4");
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq 0x58(%rsp), %r13
movq 0x50(%rsp), %rbp
movq 0x48(%rsp), %r15
movq 0x40(%rsp), %r12
movq %rsi, %rax
shlq $0x4, %rax
movaps (%rdx,%rax), %xmm0
movaps %xmm0, (%r8)
shlq $0x5, %rsi
addq %rcx, %rsi
leaq 0x7(%rsp), %rdi
movq %r9, %rdx
callq 0x1aac2
movapd (%r14), %xmm0
movapd %xmm0, (%r12)
mulpd (%rbx), %xmm0
movapd %xmm0, (%r12)
addpd (%r15), %xmm0
movapd %xmm0, (%r15)
movapd 0x10(%r14), %xmm0
movapd %xmm0, (%r12)
mulpd (%rbx), %xmm0
movapd %xmm0, (%r12)
addpd (%rbp), %xmm0
movapd %xmm0, (%rbp)
movapd 0x20(%r14), %xmm0
movapd %xmm0, (%r12)
mulpd (%rbx), %xmm0
movapd %xmm0, (%r12)
addpd (%r13), %xmm0
movapd %xmm0, (%r13)
movapd 0x30(%r14), %xmm0
movapd %xmm0, (%r12)
mulpd (%rbx), %xmm0
movapd %xmm0, (%r12)
movq 0x60(%rsp), %rax
addpd (%rax), %xmm0
movapd %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/products/SelfadjointProduct.h
// Function: Eigen::selfadjoint_product_selector<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, 1, false>::run(Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const&, double const&)
static void run(MatrixType& mat, const OtherType& other, const typename MatrixType::Scalar& alpha)
  {
    typedef typename MatrixType::Scalar Scalar;
    typedef internal::blas_traits<OtherType> OtherBlasTraits;
    typedef typename OtherBlasTraits::DirectLinearAccessType ActualOtherType;
    typedef typename internal::remove_all<ActualOtherType>::type _ActualOtherType;
    typename internal::add_const_on_value_type<ActualOtherType>::type actualOther = OtherBlasTraits::extract(other.derived());

    Scalar actualAlpha = alpha * OtherBlasTraits::extractScalarFactor(other.derived());

    enum {
      IsRowMajor = (internal::traits<MatrixType>::Flags&RowMajorBit) ? 1 : 0,
      OtherIsRowMajor = _ActualOtherType::Flags&RowMajorBit ? 1 : 0
    };

    Index size = mat.cols();
    Index depth = actualOther.cols();

    typedef internal::gemm_blocking_space<IsRowMajor ? RowMajor : ColMajor,Scalar,Scalar,
              MatrixType::MaxColsAtCompileTime, MatrixType::MaxColsAtCompileTime, _ActualOtherType::MaxColsAtCompileTime> BlockingType;

    BlockingType blocking(size, size, depth, 1, false);


    internal::general_matrix_matrix_triangular_product<Index,
      Scalar, OtherIsRowMajor ? RowMajor : ColMajor,   OtherBlasTraits::NeedToConjugate  && NumTraits<Scalar>::IsComplex,
      Scalar, OtherIsRowMajor ? ColMajor : RowMajor, (!OtherBlasTraits::NeedToConjugate) && NumTraits<Scalar>::IsComplex,
      IsRowMajor ? RowMajor : ColMajor, MatrixType::InnerStrideAtCompileTime, UpLo>
      ::run(size, depth,
            &actualOther.coeffRef(0,0), actualOther.outerStride(), &actualOther.coeffRef(0,0), actualOther.outerStride(),
            mat.data(), mat.innerStride(), mat.outerStride(), actualAlpha, blocking);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rdx), %xmm0
leaq 0x8(%rsp), %rbp
movsd %xmm0, (%rbp)
movq 0x10(%rdi), %r15
movq 0x10(%rsi), %r12
leaq 0x10(%rsp), %r13
pushq $0x1
popq %r8
movq %r13, %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r9d, %r9d
callq 0x1b428
movq (%r14), %rdx
movq 0x30(%r14), %rcx
subq $0x8, %rsp
movq %r15, %rdi
movq %r12, %rsi
movq %rdx, %r8
movq %rcx, %r9
pushq %r13
pushq %rbp
pushq 0x30(%rbx)
pushq $0x1
pushq (%rbx)
callq 0x1b48a
addq $0x30, %rsp
leaq 0x10(%rsp), %rdi
callq 0x1b920
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b920
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/TriangularMatrix.h
// Function: void Eigen::internal::call_triangular_assignment_loop<1, true, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u> const&, Eigen::internal::assign_op<double, double> const&)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
  typedef evaluator<DstXprType> DstEvaluatorType;
  typedef evaluator<SrcXprType> SrcEvaluatorType;

  SrcEvaluatorType srcEvaluator(src);

  Index dstRows = src.rows();
  Index dstCols = src.cols();
  if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
    dst.resize(dstRows, dstCols);
  DstEvaluatorType dstEvaluator(dst);
    
  typedef triangular_dense_assignment_kernel< Mode&(Lower|Upper),Mode&(UnitDiag|ZeroDiag|SelfAdjoint),SetOpposite,
                                              DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
  
  enum {
      unroll = DstXprType::SizeAtCompileTime != Dynamic
            && SrcEvaluatorType::CoeffReadCost < HugeCost
            && DstXprType::SizeAtCompileTime * (DstEvaluatorType::CoeffReadCost+SrcEvaluatorType::CoeffReadCost) / 2 <= EIGEN_UNROLLING_LIMIT
    };
  
  triangular_assignment_loop<Kernel, Mode, unroll ? int(DstXprType::SizeAtCompileTime) : Dynamic, SetOpposite>::run(kernel);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rsi
movq %rcx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rax), %rdx
cmpq %rsi, 0x8(%rdi)
jne 0x1c31d
cmpq %rdx, 0x10(%r14)
je 0x1c329
movq %r14, %rdi
callq 0x150a0
movq 0x8(%r14), %rsi
movq (%r14), %rax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
leaq 0x28(%rsp), %rdi
movq %rcx, (%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rbx, 0x10(%rdi)
movq %r14, 0x18(%rdi)
callq 0x1c35e
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/TriangularMatrix.h
// Function: Eigen::internal::triangular_assignment_loop<Eigen::internal::triangular_dense_assignment_kernel<1, 0, 1, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>, Eigen::internal::assign_op<double, double>, 0>, 1u, -1, true>::run(Eigen::internal::triangular_dense_assignment_kernel<1, 0, 1, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, 1u>>, Eigen::internal::assign_op<double, double>, 0>&)
EIGEN_DEVICE_FUNC
  static inline void run(Kernel &kernel)
  {
    for(Index j = 0; j < kernel.cols(); ++j)
    {
      Index maxi = numext::mini(j, kernel.rows());
      Index i = 0;
      if (((Mode&Lower) && SetOpposite) || (Mode&Upper))
      {
        for(; i < maxi; ++i)
          if(Mode&Upper) kernel.assignCoeff(i, j);
          else           kernel.assignOppositeCoeff(i, j);
      }
      else
        i = maxi;
      
      if(i<kernel.rows()) // then i==j
        kernel.assignDiagonalCoeff(i++);
      
      if (((Mode&Upper) && SetOpposite) || (Mode&Lower))
      {
        for(; i < kernel.rows(); ++i)
          if(Mode&Lower) kernel.assignCoeff(i, j);
          else           kernel.assignOppositeCoeff(i, j);
      }
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq 0x10(%rax), %r14
jge 0x1c3f0
movq 0x8(%rax), %rax
movq (%rbx), %rcx
cmpq %r14, %rax
movq %r14, %r15
cmovlq %rax, %r15
testq %r15, %r15
cmovleq %r12, %r15
xorl %edx, %edx
cmpq %rdx, %r15
je 0x1c3b3
movq 0x8(%rcx), %rsi
imulq %r13, %rsi
addq (%rcx), %rsi
andq $0x0, (%rsi,%rdx,8)
incq %rdx
jmp 0x1c399
cmpq %rax, %r15
jge 0x1c3dd
leaq 0x1(%r15), %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c400
movq %rbp, %r15
jmp 0x1c3dd
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c408
incq %r15
movq 0x18(%rbx), %rax
cmpq 0x8(%rax), %r15
jl 0x1c3cc
incq %r14
addq $0x8, %r13
jmp 0x1c379
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/Solve.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Solve<Eigen::LLT<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&, Eigen::internal::assign_op<double, double> const&)
static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
  {
    Index dstRows = src.rows();
    Index dstCols = src.cols();
    if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
      dst.resize(dstRows, dstCols);

    src.dec()._solve_impl(src.rhs(), dst);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x10(%rdi), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x1c515
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1524c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1c528
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/SolveTriangular.h
// Function: Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 1, 1, 0, 1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&)
static void run(const Lhs& lhs, Rhs& rhs)
  {
    ActualLhsType actualLhs = LhsProductTraits::extract(lhs);

    // FIXME find a way to allow an inner stride if packet_traits<Scalar>::size==1

    bool useRhsDirectly = Rhs::InnerStrideAtCompileTime==1 || rhs.innerStride()==1;

    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhs,rhs.size(),
                                                  (useRhsDirectly ? rhs.data() : 0));
                                                  
    if(!useRhsDirectly)
      MappedRhs(actualRhs,rhs.size()) = rhs;

    triangular_solve_vector<LhsScalar, RhsScalar, Index, Side, Mode, LhsProductTraits::NeedToConjugate,
                            (int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor>
      ::run(actualLhs.cols(), actualLhs.data(), actualLhs.outerStride(), actualRhs);

    if(!useRhsDirectly)
      rhs = MappedRhs(actualRhs, rhs.size());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
je 0x1c715
callq 0x14fa3
movq 0x8(%r14), %rax
movq (%r14), %rcx
testq %rcx, %rcx
je 0x1c721
xorl %edx, %edx
jmp 0x1c75e
leaq (,%rax,8), %rdi
cmpq $0x20000, %rdi          # imm = 0x20000
ja 0x1c748
movq %rsp, %rdx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rdx
movq %rdx, %rsp
movq %rdx, %rcx
jmp 0x1c75e
callq 0x14fd0
movq %rax, %rcx
movq 0x8(%r14), %rax
xorl %edx, %edx
cmpq $0x0, (%r14)
cmoveq %rcx, %rdx
leaq (,%rax,8), %rsi
cmpq $0x20001, %rsi          # imm = 0x20001
movq %rdx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
setae -0x18(%rbp)
movq 0x10(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1c7b0
leaq -0x28(%rbp), %rdi
callq 0x1aab2
leaq -0x10(%rbp), %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1aab2
movq %rbx, %rdi
callq 0x66e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/CwiseBinaryOp.h
// Function: Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, 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>::CwiseBinaryOp(Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const&, 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::internal::scalar_product_op<double, double> const&)
CwiseBinaryOp(const Lhs& aLhs, const Rhs& aRhs, const BinaryOp& func = BinaryOp())
      : m_lhs(aLhs), m_rhs(aRhs), m_functor(func)
    {
      EIGEN_CHECK_BINARY_COMPATIBILIY(BinaryOp,typename Lhs::Scalar,typename Rhs::Scalar);
      // require the sizes to match
      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
      eigen_assert(aLhs.rows() == aRhs.rows() && aLhs.cols() == aRhs.cols());
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x20, %rdi
movq %rdx, %rsi
callq 0x1d110
movq (%r14), %rax
cmpq 0x8(%rbx), %rax
jne 0x1d0f2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x24cae(%rip), %rdi     # 0x41da7
leaq 0x2a21d(%rip), %rsi     # 0x4731d
leaq 0x24cd9(%rip), %rcx     # 0x41de0
pushq $0x74
popq %rdx
callq 0x62b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/j-faria[P]kima/eigen/Eigen/src/Core/ProductEvaluators.h
// Function: double vector[2] Eigen::internal::diagonal_product_evaluator_base<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const> const>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const, Eigen::Product<Eigen::DiagonalWrapper<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const> const>, 1>, 1>::packet_impl<0, double vector[2]>(long, long, long, Eigen::internal::false_type) const
EIGEN_STRONG_INLINE PacketType packet_impl(Index row, Index col, Index id, internal::false_type) const
  {
    enum {
      InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
      DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!!
    };
    return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col),
                          m_diagImpl.template packet<DiagonalPacketLoadMode,PacketType>(id));
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0x207c0
movq (%r14), %rax
movupd (%rax,%rbx,8), %xmm1
mulpd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop