LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: j-faria[P]kima/eigen/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, 1, 0>::resize(long, long, long)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index rows, Index)
    {
      if(size != m_rows*_Cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Cols*m_rows);
        if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
      }
      m_rows = rows;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
cmpq %rcx, %rax
je 0x2f51e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x2c010
cmpq $0x0, -0x10(%rbp)
jle 0x2f511
movq -0x10(%rbp), %rdi
callq 0x2f530
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2f51c
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x2f51e
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_new_auto<double, true>(unsigned long)
EIGEN_DEVICE_FUNC inline T* conditional_aligned_new_auto(std::size_t size)
{
  if(size==0)
    return 0; // short-cut. Also fixes Bug 884
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  if(NumTraits<T>::RequireInitialization)
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result, size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f54d
movq $0x0, -0x10(%rbp)
jmp 0x2f583
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x8(%rbp)
jbe 0x2f56a
callq 0x2f5b0
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2f590
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2f6e0
movq -0x8(%rbp), %rdi
callq 0x6640
movq %rax, -0x10(%rbp)
cmpq $0x10, -0x8(%rbp)
jb 0x2f688
movq -0x10(%rbp), %rcx
andq $0xf, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0x2f68f
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x2f68f
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2f698
jmp 0x2f69a
jmp 0x2f6b9
leaq 0x88983(%rip), %rdi     # 0xb8024
leaq 0x96343(%rip), %rsi     # 0xc59eb
movl $0xb8, %edx
leaq 0x88a2b(%rip), %rcx     # 0xb80df
callq 0x6340
cmpq $0x0, -0x10(%rbp)
jne 0x2f6cc
cmpq $0x0, -0x8(%rbp)
je 0x2f6cc
callq 0x2f5b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/CommaInitializer.h
// Function: Eigen::CommaInitializer<Eigen::Matrix<double, -1, 1, 0, -1, 1>>::finished()
EIGEN_DEVICE_FUNC
  inline XprType& finished() {
      eigen_assert(((m_row+m_currentBlockRows) == m_xpr.rows() || m_xpr.cols() == 0)
           && m_col == m_xpr.cols()
           && "Too few coefficients passed to comma initializer (operator<<)");
      return m_xpr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
addq 0x18(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0x2f8d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
je 0x2f85e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2f8f0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x19(%rbp)
jne 0x2f88a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
callq 0x2f8f0
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jne 0x2f88a
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x2f88a
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2f893
jmp 0x2f895
jmp 0x2f8b4
leaq 0x888b4(%rip), %rdi     # 0xb8150
leaq 0x8894b(%rip), %rsi     # 0xb81ee
movl $0x78, %edx
leaq 0x88967(%rip), %rcx     # 0xb8216
callq 0x6340
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x39(%rbp)
jl 0x2fdfb
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jl 0x2fdfb
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x2fdfb
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2fe04
jmp 0x2fe06
jmp 0x2fe25
leaq 0x88720(%rip), %rdi     # 0xb852d
leaq 0x95baa(%rip), %rsi     # 0xc59be
movl $0x11d, %edx            # imm = 0x11D
leaq 0x8889c(%rip), %rcx     # 0xb86bc
callq 0x6340
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2fe51
cmpq $0x0, -0x10(%rbp)
jne 0x2fe58
xorl %eax, %eax
movb %al, -0x49(%rbp)
jmp 0x2fe7a
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
cqto
idivq -0x10(%rbp)
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
setg %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x2fe8d
callq 0x2f5b0
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
imulq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x2feb0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rdx), %rcx
imulq 0x10(%rdx), %rcx
cmpq %rcx, %rax
je 0x2ff20
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
imulq 0x10(%rax), %rsi
callq 0x2c010
cmpq $0x0, -0x10(%rbp)
jle 0x2ff13
movq -0x10(%rbp), %rdi
callq 0x2f530
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2ff1e
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x2ff20
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2f060
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2f070
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2f0b0
movq -0x48(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x30023
cmpq $0x0, -0x10(%rbp)
jne 0x3002a
xorl %eax, %eax
movb %al, -0x51(%rbp)
jmp 0x3004c
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
cqto
idivq -0x10(%rbp)
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x3005f
callq 0x2f5b0
movq -0x38(%rbp), %rdi
callq 0x2f070
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2f0b0
movq %rax, %rcx
movq -0x70(%rbp), %rax
imulq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2f070
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
movb %al, -0x61(%rbp)
je 0x300ae
movq -0x38(%rbp), %rdi
callq 0x2f0b0
cmpq $0x1, %rax
sete %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x300b7
jmp 0x300b9
jmp 0x300d8
leaq 0x88677(%rip), %rdi     # 0xb8737
leaq 0x958f7(%rip), %rsi     # 0xc59be
movl $0x176, %edx            # imm = 0x176
leaq 0x8868b(%rip), %rcx     # 0xb875e
callq 0x6340
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x1, %edx
callq 0x30150
addq $0x70, %rsp
popq %rbp
retq
// File: j-faria[P]kima/eigen/Eigen/src/Core/AssignEvaluator.h
// Function: void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::assign_op<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 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2f100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x303c0
jmp 0x30324
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2fa90
jmp 0x30333
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30480
movq %rax, -0x68(%rbp)
jmp 0x3034a
movq -0x68(%rbp), %r8
movq -0x70(%rbp), %rcx
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x30490
jmp 0x30365
leaq -0x60(%rbp), %rdi
callq 0x304d0
jmp 0x30370
leaq -0x40(%rbp), %rdi
callq 0x2fae0
leaq -0x28(%rbp), %rdi
callq 0x2f190
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x303ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fae0
leaq -0x28(%rbp), %rdi
callq 0x2f190
movq -0x30(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f070
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f0b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2f8d0
cmpq -0x20(%rbp), %rax
jne 0x3040c
movq -0x8(%rbp), %rdi
callq 0x2f8f0
cmpq -0x28(%rbp), %rax
je 0x3041d
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x30150
movq -0x8(%rbp), %rdi
callq 0x2f8d0
movq %rax, %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
jne 0x30447
movq -0x8(%rbp), %rdi
callq 0x2f8f0
cmpq -0x28(%rbp), %rax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x30450
jmp 0x30452
jmp 0x30471
leaq 0x8843c(%rip), %rdi     # 0xb8895
leaq 0x955b4(%rip), %rsi     # 0xc5a14
movl $0x2eb, %edx            # imm = 0x2EB
leaq 0x88458(%rip), %rcx     # 0xb88c4
callq 0x6340
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<double, double>, 0>, 3, 0>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30570
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
subq $0x0, %rax
movl $0x2, %ecx
cqto
idivq %rcx
shlq %rax
addq $0x0, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x30590
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x3054b
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x305b0
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x30526
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x30610
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb27b0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvttsd2si -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x3144e
movq -0x10(%rbp), %rdi
callq 0xb26f0
movaps %xmm0, %xmm1
movsd 0x85d62(%rip), %xmm0    # 0xb7198
ucomisd %xmm1, %xmm0
jb 0x31445
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x3144c
movl $0x1, -0x24(%rbp)
jmp 0x3144e
movq -0x40(%rbp), %rax
movl 0xb4(%rax), %edi
addl -0x24(%rbp), %edi
movl 0x8(%rax), %esi
addl $0x1, %esi
callq 0xb3430
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl -0x28(%rbp), %ecx
subl 0xb4(%rax), %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x1, (%rax)
jne 0x314c0
movq -0x40(%rbp), %rax
movl 0xb4(%rax), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x6430
movsd %xmm0, -0x48(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x6430
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x314f9
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x314f7
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ebb0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x314cd
jmp 0x31530
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
xorl %ecx, %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3152e
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x31c60
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x31500
jmp 0x31530
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, 0xb4(%rax)
jg 0x31cc6
movq 0xe835d(%rip), %rdi     # 0x119fe8
leaq 0x86d13(%rip), %rsi     # 0xb89a5
callq 0x64f0
movq 0xe834a(%rip), %rdi     # 0x119fe8
leaq 0x86d27(%rip), %rsi     # 0xb89cc
callq 0x64f0
movq %rax, %rdi
movq 0xe8264(%rip), %rsi     # 0x119f18
callq 0x6530
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x31dc7
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0xb4(%rax), %esi
callq 0xb28c0
movq -0x68(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movq %rdi, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x80(%rbp)
addq $0xb8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x15d30
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x15770
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0xd0, %rax
movq %rax, -0x78(%rbp)
addq $0xd0, %rdi
callq 0x15dd0
movq %rax, -0x38(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x31e50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31e90
movq -0x78(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x31de0
movq -0x68(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdi, %rax
addq $0xb8, %rax
movq %rax, -0x70(%rbp)
addq $0xb8, %rdi
callq 0x15dd0
movq %rax, -0x58(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x31e50
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x31e90
movq -0x70(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x31de0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x60(%rbp)
movl 0xb4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb4(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x361c0
xorl %eax, %eax
movl $0x1, %ecx
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
jne 0x360e4
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x360e4
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x360ed
jmp 0x360ef
jmp 0x3610e
leaq 0x82df1(%rip), %rdi     # 0xb8ee7
leaq 0x9168b(%rip), %rsi     # 0xc7788
movl $0x91, %edx
leaq 0x83662(%rip), %rcx     # 0xb976b
callq 0x6340
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x32(%rbp)
jl 0x36189
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x32(%rbp)
jl 0x36189
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36210
movq -0x40(%rbp), %rcx
movq %rax, %rdx
subq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x32(%rbp)
jg 0x36189
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x32(%rbp)
jl 0x36189
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x32(%rbp)
jl 0x36189
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36230
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq -0x30(%rbp), %rcx
cmpq %rcx, %rax
setle %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x36192
jmp 0x36194
jmp 0x361b3
leaq 0x82ebd(%rip), %rdi     # 0xb9058
leaq 0x915e6(%rip), %rsi     # 0xc7788
movl $0x93, %edx
leaq 0x835bd(%rip), %rcx     # 0xb976b
callq 0x6340
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/Redux.h
// Function: double Eigen::DenseBase<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs_op<double>, Eigen::Block<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, 1, true>, -1, 1, false> 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x350b0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x35(%rbp)
jle 0x34ff9
movq -0x40(%rbp), %rdi
callq 0x350e0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x35(%rbp)
jle 0x34ff9
movb $0x1, %al
movb %al, -0x35(%rbp)
jmp 0x34ff9
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x35002
jmp 0x35004
jmp 0x35023
leaq 0x84240(%rip), %rdi     # 0xb924b
leaq 0x90e03(%rip), %rsi     # 0xc5e15
movl $0x19b, %edx            # imm = 0x19B
leaq 0x84271(%rip), %rcx     # 0xb928f
callq 0x6340
movq -0x40(%rbp), %rdi
callq 0x34fa0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x35190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x34fa0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x351c0
movsd %xmm0, -0x48(%rbp)
jmp 0x35064
leaq -0x28(%rbp), %rdi
callq 0x35520
movsd -0x48(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35520
movq -0x30(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/SolveTriangular.h
// Function: void Eigen::TriangularViewImpl<Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const> const, 2u, Eigen::Dense>::solveInPlace<2, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>>(Eigen::MatrixBase<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>> const&) const
EIGEN_DEVICE_FUNC void TriangularViewImpl<MatrixType,Mode,Dense>::solveInPlace(const MatrixBase<OtherDerived>& _other) const
{
  OtherDerived& other = _other.const_cast_derived();
  eigen_assert( derived().cols() == derived().rows() && ((Side==OnTheLeft && derived().cols() == other.rows()) || (Side==OnTheRight && derived().cols() == other.cols())) );
  eigen_assert((!(Mode & ZeroDiag)) && bool(Mode & (Upper|Lower)));
  // If solving for a 0x0 matrix, nothing to do, simply return.
  if (derived().cols() == 0)
    return;

  enum { copy = (internal::traits<OtherDerived>::Flags & RowMajorBit)  && OtherDerived::IsVectorAtCompileTime && OtherDerived::SizeAtCompileTime!=1};
  typedef typename internal::conditional<copy,
    typename internal::plain_matrix_type_column_major<OtherDerived>::type, OtherDerived&>::type OtherCopy;
  OtherCopy otherCopy(other);

  internal::triangular_solver_selector<MatrixType, typename internal::remove_reference<OtherCopy>::type,
    Side, Mode>::run(derived().nestedExpression(), otherCopy);

  if (copy)
    other = otherCopy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f990
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3f9a0
movq %rax, %rdi
callq 0x3f9b0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x3f9a0
movq %rax, %rdi
callq 0x3f9d0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jne 0x37bba
movq -0x38(%rbp), %rdi
callq 0x3f9a0
movq %rax, %rdi
callq 0x3f9b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39210
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x37bc3
jmp 0x37bc5
jmp 0x37be4
leaq 0x848af(%rip), %rdi     # 0xbc47b
leaq 0x84942(%rip), %rsi     # 0xbc515
movl $0xaa, %edx
leaq 0x8495d(%rip), %rcx     # 0xbc53c
callq 0x6340
movq -0x38(%rbp), %rdi
callq 0x3f9a0
movq %rax, %rdi
callq 0x3f9b0
cmpq $0x0, %rax
jne 0x37bfd
jmp 0x37c22
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3f9a0
movq %rax, %rdi
callq 0x3fb80
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3f9f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/ProductEvaluators.h
// Function: void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false>, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false> const>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<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>&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, -1, -1, false> const&, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movl $0x38, %edx
callq 0x6450
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x391e0
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x58(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x39680
addq $0x90, %rsp
popq %rbp
retq
nop
// File: j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: long Eigen::internal::first_aligned<16, double, long>(double const*, long)
EIGEN_DEVICE_FUNC inline Index first_aligned(const Scalar* array, Index size)
{
  const Index ScalarSize = sizeof(Scalar);
  const Index AlignmentSize = Alignment / ScalarSize;
  const Index AlignmentMask = AlignmentSize-1;

  if(AlignmentSize<=1)
  {
    // Either the requested alignment if smaller than a scalar, or it exactly match a 1 scalar
    // so that all elements of the array have the same alignment.
    return 0;
  }
  else if( (UIntPtr(array) & (sizeof(Scalar)-1)) || (Alignment%ScalarSize)!=0)
  {
    // The array is not aligned to the size of a single scalar, or the requested alignment is not a multiple of the scalar size.
    // Consequently, no element of the array is well aligned.
    return size;
  }
  else
  {
    Index first = (AlignmentSize - (Index((UIntPtr(array)/sizeof(Scalar))) & AlignmentMask)) & AlignmentMask;
    return (first < size) ? first : size;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
movq $0x2, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x3c37c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c3bc
movq -0x10(%rbp), %rcx
shrq $0x3, %rcx
andq $0x1, %rcx
movl $0x2, %eax
subq %rcx, %rax
andq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x3c3ac
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x3c3b4
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3fbd0
movq -0x8(%rbp), %rdi
callq 0x3fbb0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x395a0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x395a0
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39210
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
movq -0x50(%rbp), %rcx
leaq -0x90(%rbp), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r9d, -0xc4(%rbp)
callq 0x3fc10
movl -0xc4(%rbp), %eax
movq -0xc0(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movl %eax, %edx
movq %rdx, %rsi
callq 0x41100
movq %rax, -0xa8(%rbp)
jmp 0x3faaa
leaq -0x48(%rbp), %rdi
callq 0x41140
movq %rax, -0xd8(%rbp)
jmp 0x3fabc
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x3cf60
movq %rax, -0xe0(%rbp)
jmp 0x3fad5
movq -0x10(%rbp), %rdi
callq 0x3d2b0
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b900
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xd8(%rbp), %rcx
movq -0xe0(%rbp), %r8
movq -0xe8(%rbp), %r9
movq %rax, %r10
movq %rsp, %rax
leaq -0x90(%rbp), %r11
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x3fcd0
jmp 0x3fb33
leaq -0x90(%rbp), %rdi
callq 0x41170
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x41170
movq -0x98(%rbp), %rdi
callq 0x6830
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x411d0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
testb $0x1, -0x29(%rbp)
je 0x3fc84
movq -0x40(%rbp), %rdx
movq %rdx, %rdi
addq $0x20, %rdi
movq %rdx, %rsi
addq $0x10, %rsi
addq $0x18, %rdx
movq -0x28(%rbp), %rcx
callq 0x41210
jmp 0x3fca8
movq -0x40(%rbp), %rsi
movq 0x18(%rsi), %rax
movq %rax, -0x38(%rbp)
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x10, %rsi
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq 0x41210
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
imulq 0x20(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x20(%rax), %rcx
imulq 0x18(%rax), %rcx
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: bool Eigen::internal::useSpecificBlockingSizes<long>(long&, long&, long&)
inline bool useSpecificBlockingSizes(Index& k, Index& m, Index& n)
{
#ifdef EIGEN_TEST_SPECIFIC_BLOCKING_SIZES
  if (EIGEN_TEST_SPECIFIC_BLOCKING_SIZES) {
    k = numext::mini<Index>(k, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K);
    m = numext::mini<Index>(m, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M);
    n = numext::mini<Index>(n, EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N);
    return true;
  }
#else
  EIGEN_UNUSED_VARIABLE(k)
  EIGEN_UNUSED_VARIABLE(m)
  EIGEN_UNUSED_VARIABLE(n)
#endif
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fc00
movq -0x10(%rbp), %rdi
callq 0x2fc00
movq -0x18(%rbp), %rdi
callq 0x2fc00
xorl %eax, %eax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpb $0x0, 0xd8c4a(%rip)     # 0x11a7a8
jne 0x41b8b
leaq 0xd8c41(%rip), %rdi     # 0x11a7a8
callq 0x6890
cmpl $0x0, %eax
je 0x41b8b
leaq 0xd8c18(%rip), %rdi     # 0x11a790
callq 0x41c50
jmp 0x41b7f
leaq 0xd8c22(%rip), %rdi     # 0x11a7a8
callq 0x6330
cmpl $0x1, -0x4(%rbp)
jne 0x41bd7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xd8bf1(%rip)     # 0x11a790
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xd8beb(%rip)     # 0x11a798
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xd8be5(%rip)     # 0x11a7a0
jmp 0x41c0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq 0xd8bd8(%rip), %rdi     # 0x11a7a8
callq 0x6300
jmp 0x41c13
cmpl $0x0, -0x4(%rbp)
jne 0x41c09
movq 0xd8bac(%rip), %rcx     # 0x11a790
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0xd8ba6(%rip), %rcx     # 0x11a798
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0xd8ba0(%rip), %rcx     # 0x11a7a0
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x41c0b
jmp 0x41c0b
jmp 0x41c0d
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6830
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
// Function: Eigen::internal::CacheSizes::CacheSizes()
CacheSizes(): m_l1(-1),m_l2(-1),m_l3(-1) {
    int l1CacheSize, l2CacheSize, l3CacheSize;
    queryCacheSizes(l1CacheSize, l2CacheSize, l3CacheSize);
    m_l1 = manage_caching_sizes_helper(l1CacheSize, defaultL1CacheSize);
    m_l2 = manage_caching_sizes_helper(l2CacheSize, defaultL2CacheSize);
    m_l3 = manage_caching_sizes_helper(l3CacheSize, defaultL3CacheSize);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $-0x1, (%rax)
movq $-0x1, 0x8(%rax)
movq $-0x1, 0x10(%rax)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x41ce0
movslq -0xc(%rbp), %rdi
movl $0x8000, %esi           # imm = 0x8000
callq 0x41de0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0x10(%rbp), %rdi
movl $0x40000, %esi          # imm = 0x40000
callq 0x41de0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x14(%rbp), %rdi
movl $0x200000, %esi         # imm = 0x200000
callq 0x41de0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: j-faria[P]kima/eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::queryCacheSizes(int&, int&, int&)
inline void queryCacheSizes(int& l1, int& l2, int& l3)
{
  #ifdef EIGEN_CPUID
  int abcd[4];
  const int GenuineIntel[] = {0x756e6547, 0x49656e69, 0x6c65746e};
  const int AuthenticAMD[] = {0x68747541, 0x69746e65, 0x444d4163};
  const int AMDisbetter_[] = {0x69444d41, 0x74656273, 0x21726574}; // "AMDisbetter!"

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x83b85(%rip), %rax     # 0xc5880
movq %rax, -0x3c(%rbp)
movl 0x83b83(%rip), %eax     # 0xc5888
movl %eax, -0x34(%rbp)
movq 0x83b7d(%rip), %rax     # 0xc588c
movq %rax, -0x48(%rbp)
movl 0x83b7b(%rip), %eax     # 0xc5894
movl %eax, -0x40(%rbp)
movq 0x83b75(%rip), %rax     # 0xc5898
movq %rax, -0x54(%rbp)
movl 0x83b73(%rip), %eax     # 0xc58a0
movl %eax, -0x4c(%rbp)
xorl %ecx, %ecx
movl %ecx, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x5c(%rbp)
movl %eax, %esi
movl -0x5c(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movl %ecx, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x41e10
testb $0x1, %al
jne 0x41d69
jmp 0x41d7f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x58(%rbp), %ecx
callq 0x41e60
jmp 0x41dcc
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x41e10
testb $0x1, %al
jne 0x41da3
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x41e10
testb $0x1, %al
jne 0x41da3
jmp 0x41db6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x41eb0
jmp 0x41dca
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x58(%rbp), %ecx
callq 0x41e60
jmp 0x41dcc
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x80000005, %eax       # imm = 0x80000005
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x38(%rbp)
movl %eax, %esi
movl -0x38(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movl %ecx, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl -0x28(%rbp), %ecx
sarl $0x18, %ecx
shll $0xa, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x80000006, %eax       # imm = 0x80000006
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x34(%rbp)
movl %eax, %esi
movl -0x34(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
movl %ecx, -0x28(%rbp)
movl %edx, -0x24(%rbp)
movl -0x28(%rbp), %ecx
sarl $0x10, %ecx
shll $0xa, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
andl $0xfffc000, %ecx        # imm = 0xFFFC000
sarl $0x12, %ecx
shll $0x9, %ecx
shll $0xa, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)