// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_SELFADJOINT_MATRIX_MATRIX_H
#define EIGEN_SELFADJOINT_MATRIX_MATRIX_H

// IWYU pragma: private
#include "../InternalHeaderCheck.h"

namespace Eigen {

namespace internal {

// pack a selfadjoint block diagonal for use with the gebp_kernel
template <typename Scalar, typename Index, int Pack1, int Pack2_dummy, int StorageOrder>
struct symm_pack_lhs {
  template <int BlockRows>
  inline void pack(Scalar* blockA, const const_blas_data_mapper<Scalar, Index, StorageOrder>& lhs, Index cols, Index i,
                   Index& count) {
    // normal copy
    for (Index k = 0; k < i; k++)
      for (Index w = 0; w < BlockRows; w++) blockA[count++] = lhs(i + w, k);  // normal
    // symmetric copy
    Index h = 0;
    for (Index k = i; k < i + BlockRows; k++) {
      for (Index w = 0; w < h; w++) blockA[count++] = numext::conj(lhs(k, i + w));  // transposed

      blockA[count++] = numext::real(lhs(k, k));  // real (diagonal)

      for (Index w = h + 1; w < BlockRows; w++) blockA[count++] = lhs(i + w, k);  // normal
      ++h;
    }
    // transposed copy
    for (Index k = i + BlockRows; k < cols; k++)
      for (Index w = 0; w < BlockRows; w++) blockA[count++] = numext::conj(lhs(k, i + w));  // transposed
  }
  void operator()(Scalar* blockA, const Scalar* lhs_, Index lhsStride, Index cols, Index rows) {
    typedef typename unpacket_traits<typename packet_traits<Scalar>::type>::half HalfPacket;
    typedef typename unpacket_traits<typename unpacket_traits<typename packet_traits<Scalar>::type>::half>::half
        QuarterPacket;
    enum {
      PacketSize = packet_traits<Scalar>::size,
      HalfPacketSize = unpacket_traits<HalfPacket>::size,
      QuarterPacketSize = unpacket_traits<QuarterPacket>::size,
      HasHalf = (int)HalfPacketSize < (int)PacketSize,
      HasQuarter = (int)QuarterPacketSize < (int)HalfPacketSize
    };

    const_blas_data_mapper<Scalar, Index, StorageOrder> lhs(lhs_, lhsStride);
    Index count = 0;
    // Index peeled_mc3 = (rows/Pack1)*Pack1;

    const Index peeled_mc3 = Pack1 >= 3 * PacketSize ? (rows / (3 * PacketSize)) * (3 * PacketSize) : 0;
    const Index peeled_mc2 =
        Pack1 >= 2 * PacketSize ? peeled_mc3 + ((rows - peeled_mc3) / (2 * PacketSize)) * (2 * PacketSize) : 0;
    const Index peeled_mc1 =
        Pack1 >= 1 * PacketSize ? peeled_mc2 + ((rows - peeled_mc2) / (1 * PacketSize)) * (1 * PacketSize) : 0;
    const Index peeled_mc_half =
        Pack1 >= HalfPacketSize ? peeled_mc1 + ((rows - peeled_mc1) / (HalfPacketSize)) * (HalfPacketSize) : 0;
    const Index peeled_mc_quarter =
        Pack1 >= QuarterPacketSize
            ? peeled_mc_half + ((rows - peeled_mc_half) / (QuarterPacketSize)) * (QuarterPacketSize)
            : 0;

    if (Pack1 >= 3 * PacketSize)
      for (Index i = 0; i < peeled_mc3; i += 3 * PacketSize) pack<3 * PacketSize>(blockA, lhs, cols, i, count);

    if (Pack1 >= 2 * PacketSize)
      for (Index i = peeled_mc3; i < peeled_mc2; i += 2 * PacketSize) pack<2 * PacketSize>(blockA, lhs, cols, i, count);

    if (Pack1 >= 1 * PacketSize)
      for (Index i = peeled_mc2; i < peeled_mc1; i += 1 * PacketSize) pack<1 * PacketSize>(blockA, lhs, cols, i, count);

    if (HasHalf && Pack1 >= HalfPacketSize)
      for (Index i = peeled_mc1; i < peeled_mc_half; i += HalfPacketSize)
        pack<HalfPacketSize>(blockA, lhs, cols, i, count);

    if (HasQuarter && Pack1 >= QuarterPacketSize)
      for (Index i = peeled_mc_half; i < peeled_mc_quarter; i += QuarterPacketSize)
        pack<QuarterPacketSize>(blockA, lhs, cols, i, count);

    // do the same with mr==1
    for (Index i = peeled_mc_quarter; i < rows; i++) {
      for (Index k = 0; k < i; k++) blockA[count++] = lhs(i, k);  // normal

      blockA[count++] = numext::real(lhs(i, i));  // real (diagonal)

      for (Index k = i + 1; k < cols; k++) blockA[count++] = numext::conj(lhs(k, i));  // transposed
    }
  }
};

template <typename Scalar, typename Index, int nr, int StorageOrder>
struct symm_pack_rhs {
  enum { PacketSize = packet_traits<Scalar>::size };
  void operator()(Scalar* blockB, const Scalar* rhs_, Index rhsStride, Index rows, Index cols, Index k2) {
    Index end_k = k2 + rows;
    Index count = 0;
    const_blas_data_mapper<Scalar, Index, StorageOrder> rhs(rhs_, rhsStride);
    Index packet_cols8 = nr >= 8 ? (cols / 8) * 8 : 0;
    Index packet_cols4 = nr >= 4 ? (cols / 4) * 4 : 0;

    // first part: normal case
    for (Index j2 = 0; j2 < k2; j2 += nr) {
      for (Index k = k2; k < end_k; k++) {
        blockB[count + 0] = rhs(k, j2 + 0);
        blockB[count + 1] = rhs(k, j2 + 1);
        if (nr >= 4) {
          blockB[count + 2] = rhs(k, j2 + 2);
          blockB[count + 3] = rhs(k, j2 + 3);
        }
        if (nr >= 8) {
          blockB[count + 4] = rhs(k, j2 + 4);
          blockB[count + 5] = rhs(k, j2 + 5);
          blockB[count + 6] = rhs(k, j2 + 6);
          blockB[count + 7] = rhs(k, j2 + 7);
        }
        count += nr;
      }
    }

    // second part: diagonal block
    Index end8 = nr >= 8 ? (std::min)(k2 + rows, packet_cols8) : k2;
    if (nr >= 8) {
      for (Index j2 = k2; j2 < end8; j2 += 8) {
        // again we can split vertically in three different parts (transpose, symmetric, normal)
        // transpose
        for (Index k = k2; k < j2; k++) {
          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
          blockB[count + 4] = numext::conj(rhs(j2 + 4, k));
          blockB[count + 5] = numext::conj(rhs(j2 + 5, k));
          blockB[count + 6] = numext::conj(rhs(j2 + 6, k));
          blockB[count + 7] = numext::conj(rhs(j2 + 7, k));
          count += 8;
        }
        // symmetric
        Index h = 0;
        for (Index k = j2; k < j2 + 8; k++) {
          // normal
          for (Index w = 0; w < h; ++w) blockB[count + w] = rhs(k, j2 + w);

          blockB[count + h] = numext::real(rhs(k, k));

          // transpose
          for (Index w = h + 1; w < 8; ++w) blockB[count + w] = numext::conj(rhs(j2 + w, k));
          count += 8;
          ++h;
        }
        // normal
        for (Index k = j2 + 8; k < end_k; k++) {
          blockB[count + 0] = rhs(k, j2 + 0);
          blockB[count + 1] = rhs(k, j2 + 1);
          blockB[count + 2] = rhs(k, j2 + 2);
          blockB[count + 3] = rhs(k, j2 + 3);
          blockB[count + 4] = rhs(k, j2 + 4);
          blockB[count + 5] = rhs(k, j2 + 5);
          blockB[count + 6] = rhs(k, j2 + 6);
          blockB[count + 7] = rhs(k, j2 + 7);
          count += 8;
        }
      }
    }
    if (nr >= 4) {
      for (Index j2 = end8; j2 < (std::min)(k2 + rows, packet_cols4); j2 += 4) {
        // again we can split vertically in three different parts (transpose, symmetric, normal)
        // transpose
        for (Index k = k2; k < j2; k++) {
          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
          count += 4;
        }
        // symmetric
        Index h = 0;
        for (Index k = j2; k < j2 + 4; k++) {
          // normal
          for (Index w = 0; w < h; ++w) blockB[count + w] = rhs(k, j2 + w);

          blockB[count + h] = numext::real(rhs(k, k));

          // transpose
          for (Index w = h + 1; w < 4; ++w) blockB[count + w] = numext::conj(rhs(j2 + w, k));
          count += 4;
          ++h;
        }
        // normal
        for (Index k = j2 + 4; k < end_k; k++) {
          blockB[count + 0] = rhs(k, j2 + 0);
          blockB[count + 1] = rhs(k, j2 + 1);
          blockB[count + 2] = rhs(k, j2 + 2);
          blockB[count + 3] = rhs(k, j2 + 3);
          count += 4;
        }
      }
    }

    // third part: transposed
    if (nr >= 8) {
      for (Index j2 = k2 + rows; j2 < packet_cols8; j2 += 8) {
        for (Index k = k2; k < end_k; k++) {
          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
          blockB[count + 4] = numext::conj(rhs(j2 + 4, k));
          blockB[count + 5] = numext::conj(rhs(j2 + 5, k));
          blockB[count + 6] = numext::conj(rhs(j2 + 6, k));
          blockB[count + 7] = numext::conj(rhs(j2 + 7, k));
          count += 8;
        }
      }
    }
    if (nr >= 4) {
      for (Index j2 = (std::max)(packet_cols8, k2 + rows); j2 < packet_cols4; j2 += 4) {
        for (Index k = k2; k < end_k; k++) {
          blockB[count + 0] = numext::conj(rhs(j2 + 0, k));
          blockB[count + 1] = numext::conj(rhs(j2 + 1, k));
          blockB[count + 2] = numext::conj(rhs(j2 + 2, k));
          blockB[count + 3] = numext::conj(rhs(j2 + 3, k));
          count += 4;
        }
      }
    }

    // copy the remaining columns one at a time (=> the same with nr==1)
    for (Index j2 = packet_cols4; j2 < cols; ++j2) {
      // transpose
      Index half = (std::min)(end_k, j2);
      for (Index k = k2; k < half; k++) {
        blockB[count] = numext::conj(rhs(j2, k));
        count += 1;
      }

      if (half == j2 && half < k2 + rows) {
        blockB[count] = numext::real(rhs(j2, j2));
        count += 1;
      } else
        half--;

      // normal
      for (Index k = half + 1; k < k2 + rows; k++) {
        blockB[count] = rhs(k, j2);
        count += 1;
      }
    }
  }
};

/* Optimized selfadjoint matrix * matrix (_SYMM) product built on top of
 * the general matrix matrix product.
 */
template <typename Scalar, typename Index, int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs, int ResStorageOrder, int ResInnerStride>
struct product_selfadjoint_matrix;

template <typename Scalar, typename Index, int LhsStorageOrder, bool LhsSelfAdjoint, bool ConjugateLhs,
          int RhsStorageOrder, bool RhsSelfAdjoint, bool ConjugateRhs, int ResInnerStride>
struct product_selfadjoint_matrix<Scalar, Index, LhsStorageOrder, LhsSelfAdjoint, ConjugateLhs, RhsStorageOrder,
                                  RhsSelfAdjoint, ConjugateRhs, RowMajor, ResInnerStride> {
  static EIGEN_STRONG_INLINE void run(Index rows, Index cols, const Scalar* lhs, Index lhsStride, const Scalar* rhs,
                                      Index rhsStride, Scalar* res, Index resIncr, Index resStride, const Scalar& alpha,
                                      level3_blocking<Scalar, Scalar>& blocking) {
    product_selfadjoint_matrix<
        Scalar, Index, logical_xor(RhsSelfAdjoint, RhsStorageOrder == RowMajor) ? ColMajor : RowMajor, RhsSelfAdjoint,
        NumTraits<Scalar>::IsComplex && logical_xor(RhsSelfAdjoint, ConjugateRhs),
        logical_xor(LhsSelfAdjoint, LhsStorageOrder == RowMajor) ? ColMajor : RowMajor, LhsSelfAdjoint,
        NumTraits<Scalar>::IsComplex && logical_xor(LhsSelfAdjoint, ConjugateLhs), ColMajor,
        ResInnerStride>::run(cols, rows, rhs, rhsStride, lhs, lhsStride, res, resIncr, resStride, alpha, blocking);
  }
};

template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder,
          bool ConjugateRhs, int ResInnerStride>
struct product_selfadjoint_matrix<Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false,
                                  ConjugateRhs, ColMajor, ResInnerStride> {
  static EIGEN_DONT_INLINE void run(Index rows, Index cols, const Scalar* lhs_, Index lhsStride, const Scalar* rhs_,
                                    Index rhsStride, Scalar* res, Index resIncr, Index resStride, const Scalar& alpha,
                                    level3_blocking<Scalar, Scalar>& blocking);
};

template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder,
          bool ConjugateRhs, int ResInnerStride>
EIGEN_DONT_INLINE void
product_selfadjoint_matrix<Scalar, Index, LhsStorageOrder, true, ConjugateLhs, RhsStorageOrder, false, ConjugateRhs,
                           ColMajor, ResInnerStride>::run(Index rows, Index cols, const Scalar* lhs_, Index lhsStride,
                                                          const Scalar* rhs_, Index rhsStride, Scalar* res_,
                                                          Index resIncr, Index resStride, const Scalar& alpha,
                                                          level3_blocking<Scalar, Scalar>& blocking) {
  Index size = rows;

  typedef gebp_traits<Scalar, Scalar> Traits;

  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
  typedef const_blas_data_mapper<Scalar, Index, (LhsStorageOrder == RowMajor) ? ColMajor : RowMajor> LhsTransposeMapper;
  typedef const_blas_data_mapper<Scalar, Index, RhsStorageOrder> RhsMapper;
  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
  LhsMapper lhs(lhs_, lhsStride);
  LhsTransposeMapper lhs_transpose(lhs_, lhsStride);
  RhsMapper rhs(rhs_, rhsStride);
  ResMapper res(res_, resStride, resIncr);

  Index kc = blocking.kc();                    // cache block size along the K direction
  Index mc = (std::min)(rows, blocking.mc());  // cache block size along the M direction
  // kc must be smaller than mc
  kc = (std::min)(kc, mc);
  std::size_t sizeA = kc * mc;
  std::size_t sizeB = kc * cols;
  ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
  ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());

  gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
  symm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, LhsStorageOrder> pack_lhs;
  gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
  gemm_pack_lhs<Scalar, Index, LhsTransposeMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing,
                LhsStorageOrder == RowMajor ? ColMajor : RowMajor, true>
      pack_lhs_transposed;

  for (Index k2 = 0; k2 < size; k2 += kc) {
    const Index actual_kc = (std::min)(k2 + kc, size) - k2;

    // we have selected one row panel of rhs and one column panel of lhs
    // pack rhs's panel into a sequential chunk of memory
    // and expand each coeff to a constant packet for further reuse
    pack_rhs(blockB, rhs.getSubMapper(k2, 0), actual_kc, cols);

    // the select lhs's panel has to be split in three different parts:
    //  1 - the transposed panel above the diagonal block => transposed packed copy
    //  2 - the diagonal block => special packed copy
    //  3 - the panel below the diagonal block => generic packed copy
    for (Index i2 = 0; i2 < k2; i2 += mc) {
      const Index actual_mc = (std::min)(i2 + mc, k2) - i2;
      // transposed packed copy
      pack_lhs_transposed(blockA, lhs_transpose.getSubMapper(i2, k2), actual_kc, actual_mc);

      gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
    }
    // the block diagonal
    {
      const Index actual_mc = (std::min)(k2 + kc, size) - k2;
      // symmetric packed copy
      pack_lhs(blockA, &lhs(k2, k2), lhsStride, actual_kc, actual_mc);

      gebp_kernel(res.getSubMapper(k2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
    }

    for (Index i2 = k2 + kc; i2 < size; i2 += mc) {
      const Index actual_mc = (std::min)(i2 + mc, size) - i2;
      gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing,
                    LhsStorageOrder, false>()(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);

      gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
    }
  }
}

// matrix * selfadjoint product
template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder,
          bool ConjugateRhs, int ResInnerStride>
struct product_selfadjoint_matrix<Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true,
                                  ConjugateRhs, ColMajor, ResInnerStride> {
  static EIGEN_DONT_INLINE void run(Index rows, Index cols, const Scalar* lhs_, Index lhsStride, const Scalar* rhs_,
                                    Index rhsStride, Scalar* res, Index resIncr, Index resStride, const Scalar& alpha,
                                    level3_blocking<Scalar, Scalar>& blocking);
};

template <typename Scalar, typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder,
          bool ConjugateRhs, int ResInnerStride>
EIGEN_DONT_INLINE void
product_selfadjoint_matrix<Scalar, Index, LhsStorageOrder, false, ConjugateLhs, RhsStorageOrder, true, ConjugateRhs,
                           ColMajor, ResInnerStride>::run(Index rows, Index cols, const Scalar* lhs_, Index lhsStride,
                                                          const Scalar* rhs_, Index rhsStride, Scalar* res_,
                                                          Index resIncr, Index resStride, const Scalar& alpha,
                                                          level3_blocking<Scalar, Scalar>& blocking) {
  Index size = cols;

  typedef gebp_traits<Scalar, Scalar> Traits;

  typedef const_blas_data_mapper<Scalar, Index, LhsStorageOrder> LhsMapper;
  typedef blas_data_mapper<typename Traits::ResScalar, Index, ColMajor, Unaligned, ResInnerStride> ResMapper;
  LhsMapper lhs(lhs_, lhsStride);
  ResMapper res(res_, resStride, resIncr);

  Index kc = blocking.kc();                    // cache block size along the K direction
  Index mc = (std::min)(rows, blocking.mc());  // cache block size along the M direction
  std::size_t sizeA = kc * mc;
  std::size_t sizeB = kc * cols;
  ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
  ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());

  gebp_kernel<Scalar, Scalar, Index, ResMapper, Traits::mr, Traits::nr, ConjugateLhs, ConjugateRhs> gebp_kernel;
  gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing,
                LhsStorageOrder>
      pack_lhs;
  symm_pack_rhs<Scalar, Index, Traits::nr, RhsStorageOrder> pack_rhs;

  for (Index k2 = 0; k2 < size; k2 += kc) {
    const Index actual_kc = (std::min)(k2 + kc, size) - k2;

    pack_rhs(blockB, rhs_, rhsStride, actual_kc, cols, k2);

    // => GEPP
    for (Index i2 = 0; i2 < rows; i2 += mc) {
      const Index actual_mc = (std::min)(i2 + mc, rows) - i2;
      pack_lhs(blockA, lhs.getSubMapper(i2, k2), actual_kc, actual_mc);

      gebp_kernel(res.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, alpha);
    }
  }
}

}  // end namespace internal

/***************************************************************************
 * Wrapper to product_selfadjoint_matrix
 ***************************************************************************/

namespace internal {

template <typename Lhs, int LhsMode, typename Rhs, int RhsMode>
struct selfadjoint_product_impl<Lhs, LhsMode, false, Rhs, RhsMode, false> {
  typedef typename Product<Lhs, Rhs>::Scalar Scalar;

  typedef internal::blas_traits<Lhs> LhsBlasTraits;
  typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
  typedef internal::blas_traits<Rhs> RhsBlasTraits;
  typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;

  enum {
    LhsIsUpper = (LhsMode & (Upper | Lower)) == Upper,
    LhsIsSelfAdjoint = (LhsMode & SelfAdjoint) == SelfAdjoint,
    RhsIsUpper = (RhsMode & (Upper | Lower)) == Upper,
    RhsIsSelfAdjoint = (RhsMode & SelfAdjoint) == SelfAdjoint
  };

  template <typename Dest>
  static void run(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha) {
    eigen_assert(dst.rows() == a_lhs.rows() && dst.cols() == a_rhs.cols());

    add_const_on_value_type_t<ActualLhsType> lhs = LhsBlasTraits::extract(a_lhs);
    add_const_on_value_type_t<ActualRhsType> rhs = RhsBlasTraits::extract(a_rhs);

    Scalar actualAlpha = alpha * LhsBlasTraits::extractScalarFactor(a_lhs) * RhsBlasTraits::extractScalarFactor(a_rhs);

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

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

    internal::product_selfadjoint_matrix<
        Scalar, Index,
        internal::logical_xor(LhsIsUpper, internal::traits<Lhs>::Flags & RowMajorBit) ? RowMajor : ColMajor,
        LhsIsSelfAdjoint,
        NumTraits<Scalar>::IsComplex && internal::logical_xor(LhsIsUpper, bool(LhsBlasTraits::NeedToConjugate)),
        internal::logical_xor(RhsIsUpper, internal::traits<Rhs>::Flags & RowMajorBit) ? RowMajor : ColMajor,
        RhsIsSelfAdjoint,
        NumTraits<Scalar>::IsComplex && internal::logical_xor(RhsIsUpper, bool(RhsBlasTraits::NeedToConjugate)),
        internal::traits<Dest>::Flags & RowMajorBit ? RowMajor : ColMajor,
        Dest::InnerStrideAtCompileTime>::run(lhs.rows(), rhs.cols(),                                     // sizes
                                             &lhs.coeffRef(0, 0), lhs.outerStride(),                     // lhs info
                                             &rhs.coeffRef(0, 0), rhs.outerStride(),                     // rhs info
                                             &dst.coeffRef(0, 0), dst.innerStride(), dst.outerStride(),  // result info
                                             actualAlpha, blocking                                       // alpha
    );
  }
};

}  // end namespace internal

}  // end namespace Eigen

#endif  // EIGEN_SELFADJOINT_MATRIX_MATRIX_H