// File: Kingsford-Group[P]ghost2/include/Eigen/src/Core/products/TriangularSolverVector.h
// Function: Eigen::internal::triangular_solve_vector<double, double, long, 1, 6, false, 1>::run(long, double const*, long, double*)
static void run(Index size, const LhsScalar* _lhs, Index lhsStride, RhsScalar* rhs)
  {
    typedef Map<const Matrix<LhsScalar,Dynamic,Dynamic,RowMajor>, 0, OuterStride<> > LhsMap;
    const LhsMap lhs(_lhs,size,size,OuterStride<>(lhsStride));
    typename internal::conditional<
                          Conjugate,
                          const CwiseUnaryOp<typename internal::scalar_conjugate_op<LhsScalar>,LhsMap>,
                          const LhsMap&>
                        ::type cjLhs(lhs);
    static const Index PanelWidth = EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH;
    for(Index pi=IsLower ? 0 : size;
        IsLower ? pi<size : pi>0;
        IsLower ? pi+=PanelWidth : pi-=PanelWidth)
    {
      Index actualPanelWidth = (std::min)(IsLower ? size - pi : pi, PanelWidth);

      Index r = IsLower ? pi : size - pi; // remaining size
      if (r > 0)
      {
        // let's directly call the low level product function because:
        // 1 - it is faster to compile
        // 2 - it is slighlty faster at runtime
        Index startRow = IsLower ? pi : pi-actualPanelWidth;
        Index startCol = IsLower ? 0 : pi;

        general_matrix_vector_product<Index,LhsScalar,RowMajor,Conjugate,RhsScalar,false>::run(
          actualPanelWidth, r,
          &lhs.coeffRef(startRow,startCol), lhsStride,
          rhs + startCol, 1,
          rhs + startRow, 1,
          RhsScalar(-1));
      }

      for(Index k=0; k<actualPanelWidth; ++k)
      {
        Index i = IsLower ? pi+k : pi-k-1;
        Index s = IsLower ? pi   : i+1;
        if (k>0)
          rhs[i] -= (cjLhs.row(i).segment(s,k).transpose().cwiseProduct(Map<const Matrix<RhsScalar,Dynamic,1> >(rhs+s,k))).sum();
        
        if(!(Mode & UnitDiag))
          rhs[i] /= cjLhs(i,i);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x278(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x5a7a0
movq -0x280(%rbp), %rsi
movq -0x278(%rbp), %rdx
movq -0x270(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %r8
callq 0x5edc0
leaq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jle 0x5ed2b
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
leaq 0x7940f(%rip), %rsi     # 0xd7f18
callq 0x37360
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
subq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jle 0x5ebcc
movq -0x68(%rbp), %rax
subq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x288(%rbp)
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x602c0
movq -0x290(%rbp), %rdi
movq -0x288(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x90(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r8
movq -0x20(%rbp), %rax
movq -0x88(%rbp), %r9
shlq $0x3, %r9
addq %r9, %rax
movl $0x1, %r9d
movsd 0x5d4be(%rip), %xmm0    # 0xbc078
movq %rax, (%rsp)
movq $0x1, 0x8(%rsp)
callq 0x5ee20
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x70(%rbp), %rax
jge 0x5ed18
movq -0x68(%rbp), %rax
subq -0x98(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x98(%rbp)
jle 0x5ecff
movq -0x60(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x248(%rbp), %rdi
callq 0x60340
movq -0xa8(%rbp), %rdx
movq -0x98(%rbp), %rcx
leaq -0x200(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x60390
leaq -0x198(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x603e0
movq -0x20(%rbp), %rax
movq -0xa8(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x2a0(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x298(%rbp)
leaq -0x262(%rbp), %rdi
callq 0x54230
movq -0x2a0(%rbp), %rsi
movq -0x298(%rbp), %rdx
leaq -0x260(%rbp), %rdi
leaq -0x262(%rbp), %rcx
callq 0x60490
leaq -0x130(%rbp), %rdi
leaq -0x198(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0x60420
leaq -0x130(%rbp), %rdi
callq 0x604f0
movaps %xmm0, %xmm1
movq -0x20(%rbp), %rax
movq -0xa0(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x5ed01
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x5ebd7
jmp 0x5ed1a
movq -0x68(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x5eaeb
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop