// File: /workspace/github_cpp_makefile_star2_O1/Pyboon[P]sage/./Eigen/src/Core/GeneralProduct.h
// Function: void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1> const>, Eigen::Transpose<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const> const> const>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>>>(Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, -1, 0, -1, -1> const> const&, Eigen::Transpose<Eigen::CwiseUnaryOp<Eigen::internal::scalar_conjugate_op<std::complex<double>>, Eigen::Transpose<Eigen::Matrix<std::complex<double>, -1, 1, 0, -1, 1> const> const> const> const&, Eigen::Transpose<Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>>&, Eigen::Transpose<Eigen::Matrix<std::complex<double>, 1, -1, 1, 1, -1>>::Scalar const&)
static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
  {
    typedef typename Lhs::Scalar   LhsScalar;
    typedef typename Rhs::Scalar   RhsScalar;
    typedef typename Dest::Scalar  ResScalar;
    
    typedef internal::blas_traits<Lhs> LhsBlasTraits;
    typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
    typedef internal::blas_traits<Rhs> RhsBlasTraits;
    typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
    typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;

    typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
    typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);

    ResScalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(lhs)
                                  * RhsBlasTraits::extractScalarFactor(rhs);

    enum {
      // FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
      // on, the other hand it is good for the cache to pack the vector anyways...
      DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1
    };

    gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;

    ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
        DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());

    if(!DirectlyUseRhs)
    {
      #ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
      Index size = actualRhs.size();
      EIGEN_DENSE_STORAGE_CTOR_PLUGIN
      #endif
      Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
    }

    typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
    typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
    general_matrix_vector_product
        <Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
        actualLhs.rows(), actualLhs.cols(),
        LhsMapper(actualLhs.data(), actualLhs.outerStride()),
        RhsMapper(actualRhsPtr, 1),
        dest.data(), dest.col(0).innerStride(), //NOTE  if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
        actualAlpha);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq (%rdi), %r12
movq (%rsi), %r13
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
leaq -0x60(%rbp), %rsi
movq %r15, (%rsi)
movq $0x0, 0x8(%rsi)
movups (%rcx), %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
callq 0xfe6c
movaps (%r14), %xmm0
leaq -0x70(%rbp), %rsi
movq %r15, (%rsi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x8(%rsi)
movups %xmm0, (%r14)
leaq -0x40(%rbp), %rdi
callq 0xfe6c
movq 0x8(%r13), %r15
movq %r15, %rax
shrq $0x3c, %rax
jne 0x10c3b
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movq (%r13), %rax
testq %rax, %rax
je 0x10b83
xorl %r14d, %r14d
jmp 0x10bd7
movq %r15, %rdi
shlq $0x4, %rdi
cmpq $0x2000, %r15           # imm = 0x2000
ja 0x10ba9
movq %rsp, %r14
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r14
movq %r14, %rsp
movq %r14, %rax
jmp 0x10bd7
movsd %xmm1, -0x48(%rbp)
movsd %xmm0, -0x50(%rbp)
callq 0x3370
movq %rax, %r14
testb $0xf, %r14b
jne 0x10c88
movq %r14, %rax
testq %r14, %r14
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
je 0x10c3b
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdi
movups (%r12), %xmm2
movups %xmm2, -0x40(%rbp)
movq %rax, -0x60(%rbp)
movq $0x1, -0x58(%rbp)
movq (%rbx), %rax
movq (%rax), %r8
testq %r8, %r8
je 0x10c08
cmpq $0x0, 0x8(%rax)
js 0x10c69
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movl $0x1, %r9d
callq 0x10cc4
cmpq $0x2001, %r15           # imm = 0x2001
jb 0x10c2c
movq %r14, %rdi
callq 0x3320
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x3130
movq 0x1e374(%rip), %rcx     # 0x2efc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x1e376(%rip), %rsi     # 0x2efd0
movq 0x1e347(%rip), %rdx     # 0x2efa8
movq %rax, %rdi
callq 0x3440
leaq 0xd412(%rip), %rdi      # 0x1e082
leaq 0xd4b5(%rip), %rsi      # 0x1e12c
leaq 0x10935(%rip), %rcx     # 0x215b3
movl $0xaf, %edx
callq 0x31b0
leaq 0xbc4c(%rip), %rdi      # 0x1c8db
leaq 0xbcff(%rip), %rsi      # 0x1c995
leaq 0xbd17(%rip), %rcx      # 0x1c9b4
movl $0xa1, %edx
callq 0x31b0
movq %rax, %rbx
cmpq $0x2001, %r15           # imm = 0x2001
jb 0x10cbb
movq %r14, %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x3460
nop