core.hpp

Go to the documentation of this file.

 
#ifndef _FLAMES_CORE_HPP_
#define _FLAMES_CORE_HPP_
 
#include <ap_fixed.h>
#include <ap_int.h>
#include <cassert>
#include <complex>
#include <cstddef>
#include <fstream>
#include <hls_vector.h>
#include <initializer_list>
#include <iostream>
#include <type_traits>
#include <vector>
 
#ifndef __VITIS_HLS__
#    error "FLAMES library can only be used for Vitis HLS."
#endif
 
/*
 * There are some unwanted warning messages, including:
 *   WARNING: [HLS 207-1462] template template parameter using 'typename' is a C++17 extension
 *   WARNING: [HLS 207-5292] unused parameter '...'
 * They are safe to ignore, so all warnings of the FLAMES library are suppressed.
 * You can restore them by defining `FLAMES_PRESERVE_WARNING`
 */
#ifndef FLAMES_KEEP_WARNING
#    ifdef __SYNTHESIS__
#        pragma GCC diagnostic push
#        pragma GCC diagnostic ignored "-Weverything"
#    endif
#endif
 
#ifndef PRAGMA_SUB
#    define PRAGMA_SUB(x) _Pragma(#    x)
#endif
#ifndef FLAMES_PRAGMA
// Alias for #pragma HLS with support for macro expansion.
#    define FLAMES_PRAGMA(x) PRAGMA_SUB(HLS x)
#endif
 
#ifndef FLAMES_MAT_PLUS_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_PLUS_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_PLUS_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_MINUS_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_MINUS_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_MINUS_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_SET_VALUE_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_SET_VALUE_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_SET_VALUE_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_POWER_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_POWER_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_POWER_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_COPY_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_COPY_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_COPY_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR
#    ifdef FLAMES_MAT_TIMES_UNROLL_FACTOR
#        define FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR FLAMES_MAT_TIMES_UNROLL_FACTOR
#    else
#        ifdef FLAMES_UNROLL_FACTOR
#            define FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#        else
#            define FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR 32
#        endif
#    endif
#endif
#ifndef FLAMES_MAT_TIMES_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_TIMES_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_TIMES_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_EMUL_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_EMUL_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_EMUL_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_ABS_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_ABS_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_ABS_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_INV_UNROLL_FACTOR
#    ifdef FLAMES_UNROLL_FACTOR
#        define FLAMES_MAT_INV_UNROLL_FACTOR FLAMES_UNROLL_FACTOR
#    else
#        define FLAMES_MAT_INV_UNROLL_FACTOR 32
#    endif
#endif
#ifndef FLAMES_MAT_PARTITION_COMPLETE
#    ifndef FLAMES_MAT_PARTITION_FACTOR
#        define FLAMES_MAT_PARTITION_FACTOR 8
#    endif
#endif
#ifndef FLAMES_SORT_PARTITION_COMPLETE
#    ifndef FLAMES_SORT_PARTITION_FACTOR
#        define FLAMES_SORT_PARTITION_FACTOR 32
#    endif
#endif
 
#if defined __SYNTHESIS__ && defined FLAMES_PRINT_PER_MAT_COPY
#    undef FLAMES_PRINT_PER_MAT_COPY
#endif
 
#ifdef INLINE
#    define DEFINED_INLINE
#    undef INLINE
#endif
 
namespace flames {
 
enum MatType {
    NORMAL,   
    DIAGONAL, 
    SCALAR,   
    UPPER,    
    LOWER,    
    SUPPER,   
    SLOWER,   
    SYM,      
    ASYM      
};
 
using MATTYPE_NORMAL = std::integral_constant<int, MatType::NORMAL>;
using MATTYPE_DIAGONAL = std::integral_constant<int, MatType::DIAGONAL>;
using MATTYPE_SCALAR = std::integral_constant<int, MatType::SCALAR>;
using MATTYPE_UPPER = std::integral_constant<int, MatType::UPPER>;
using MATTYPE_LOWER = std::integral_constant<int, MatType::LOWER>;
using MATTYPE_SUPPER = std::integral_constant<int, MatType::SUPPER>;
using MATTYPE_SLOWER = std::integral_constant<int, MatType::SLOWER>;
using MATTYPE_SYM = std::integral_constant<int, MatType::SYM>;
using MATTYPE_ASYM = std::integral_constant<int, MatType::ASYM>;
 
template <typename T>
inline constexpr MatType matType() {
    return MatType(T::value);
}
 
template <int type>
using MType = std::integral_constant<int, type>;
 
inline constexpr MatType sumType(MatType type1, MatType type2) noexcept {
    if (type1 == type2) return type1;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::SCALAR) ||
             (type1 == MatType::SCALAR && type2 == MatType::DIAGONAL))
        return MatType::DIAGONAL;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::UPPER) ||
             (type1 == MatType::UPPER && type2 == MatType::DIAGONAL))
        return MatType::UPPER;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::LOWER) ||
             (type1 == MatType::LOWER && type2 == MatType::DIAGONAL))
        return MatType::LOWER;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::SUPPER) ||
             (type1 == MatType::SUPPER && type2 == MatType::DIAGONAL))
        return MatType::UPPER;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::SLOWER) ||
             (type1 == MatType::SLOWER && type2 == MatType::DIAGONAL))
        return MatType::LOWER;
    else if ((type1 == MatType::SCALAR && type2 == MatType::SUPPER) ||
             (type1 == MatType::SUPPER && type2 == MatType::SCALAR))
        return MatType::UPPER;
    else if ((type1 == MatType::SCALAR && type2 == MatType::SLOWER) ||
             (type1 == MatType::SLOWER && type2 == MatType::SCALAR))
        return MatType::LOWER;
    else if ((type1 == MatType::SUPPER && type2 == MatType::UPPER) ||
             (type1 == MatType::UPPER && type2 == MatType::SUPPER))
        return MatType::UPPER;
    else if ((type1 == MatType::SLOWER && type2 == MatType::LOWER) ||
             (type1 == MatType::LOWER && type2 == MatType::SLOWER))
        return MatType::LOWER;
    else if ((type1 == MatType::DIAGONAL && type2 == MatType::SYM) ||
             (type1 == MatType::SYM && type2 == MatType::DIAGONAL))
        return MatType::SYM;
    else if ((type1 == MatType::SCALAR && type2 == MatType::SYM) || (type1 == MatType::SYM && type2 == MatType::SCALAR))
        return MatType::SYM;
    else return MatType::NORMAL;
}
 
inline constexpr MatType mulType(MatType type1, MatType type2, size_t n_rows, size_t comm, size_t n_cols) noexcept {
    if (n_rows == comm && comm == n_cols) {
        if (type1 == type2) {
            if (type1 != SYM && type1 != ASYM) return type1;
        }
        if (type1 == MatType::SCALAR) return type2;
        else if (type2 == MatType::SCALAR) return type1;
        else if (type1 == MatType::DIAGONAL && (type2 == MatType::SUPPER || type2 == MatType::UPPER ||
                                                type2 == MatType::SLOWER || type2 == MatType::LOWER))
            return type2;
        else if (type2 == MatType::DIAGONAL && (type1 == MatType::SUPPER || type1 == MatType::UPPER ||
                                                type1 == MatType::SLOWER || type1 == MatType::LOWER))
            return type1;
        else if (type1 == MatType::SUPPER && type2 == MatType::UPPER) return type1;
        else if (type1 == MatType::SLOWER && type2 == MatType::LOWER) return type1;
        else if (type1 == MatType::UPPER && type2 == MatType::SUPPER) return type2;
        else if (type1 == MatType::LOWER && type2 == MatType::SLOWER) return type2;
    }
    return MatType::NORMAL;
}
 
inline constexpr MatType tType(MatType type) noexcept {
    if (type == MatType::SUPPER) return MatType::SLOWER;
    else if (type == MatType::SLOWER) return MatType::SUPPER;
    else if (type == MatType::UPPER) return MatType::LOWER;
    else if (type == MatType::LOWER) return MatType::UPPER;
    else return type;
}
 
inline constexpr size_t upperRow(size_t index, size_t N) {
    size_t r = 0;
    while (index >= N - r) {
        index -= N - r;
        ++r;
    }
    return r;
}
 
inline constexpr size_t lowerRow(size_t index, size_t N) {
    size_t r = 0;
    while (index >= r + 1) {
        index -= r + 1;
        ++r;
    }
    return r;
}
 
inline constexpr size_t supperRow(size_t index, size_t N) {
    size_t r = 0;
    while (index >= N - 1 - r) {
        index -= N - 1 - r;
        ++r;
    }
    return r;
}
 
inline constexpr size_t slowerRow(size_t index, size_t N) {
    size_t r = 0;
    while (index >= r) {
        index -= r;
        ++r;
    }
    return r;
}
 
template <typename T, size_t n_rows, size_t n_cols, MatType type = MatType::NORMAL>
class Mat;
 
template <typename T, size_t n_rows, size_t n_cols, size_t n_slices, MatType type = MatType::NORMAL>
class Tensor;
 
template <typename T, size_t N>
using Vec = Mat<T, N, 1>;
 
template <typename T, size_t N>
using RowVec = Mat<T, 1, N>;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type = MatType::NORMAL>
class MatView;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type = MatType::NORMAL>
class MatRef;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatViewOpp;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatViewT;
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewDiagMat;
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewDiagVec;
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewDiagRowVec;
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewOffDiag;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewCol;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatRefCol;
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent = MATTYPE_NORMAL>
class MatViewRow;
 
template <size_t first_col, size_t last_col, typename T, size_t n_rows, size_t n_cols, MatType type,
          typename type_parent = MATTYPE_NORMAL>
class MatViewCols;
 
template <size_t first_row, size_t last_row, typename T, size_t n_rows, size_t n_cols, MatType type,
          typename type_parent = MATTYPE_NORMAL>
class MatViewRows;
 
enum class InitAfterwards {
    NONE, 
    OPP,  
    TR    
};
 
enum class Init { NONE, ZEROS, ONES };
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class Mat {
    friend class MatView<T, n_rows, n_cols, type>;
    friend class MatViewOpp<T, n_rows, n_cols, type>;
    friend class MatViewT<T, n_cols, n_rows, type>;
    friend class MatViewT<T, n_rows, n_cols, type>;
    template <typename View_T, size_t View_N, size_t View_N_, MatType View_type, typename type_parent>
    friend class MatViewDiagMat;
    template <typename View_T, size_t View_N, size_t View_N_, MatType View_type, typename type_parent>
    friend class MatViewDiagVec;
    template <typename View_T, size_t View_N, size_t View_N_, MatType View_type, typename type_parent>
    friend class MatViewDiagRowVec;
    template <typename View_T, size_t View_N, size_t View_N_, MatType View_type, typename type_parent>
    friend class MatViewOffDiag;
    template <typename View_T, size_t View_n_rows, size_t View_n_cols, MatType View_type, typename type_parent>
    friend class MatViewCol;
    template <typename View_T, size_t View_n_rows, size_t View_n_cols, MatType View_type, typename type_parent>
    friend class MatViewRow;
    template <size_t first_col, size_t last_col, typename View_T, size_t View_n_rows, size_t View_n_cols,
              MatType View_type, typename type_parent>
    friend class MatViewCols;
    template <size_t first_row, size_t last_row, typename View_T, size_t View_n_rows, size_t View_n_cols,
              MatType View_type, typename type_parent>
    friend class MatViewRows;
    template <typename View_T_T, size_t T_n_rows, size_t T_n_cols, size_t T_n_slices, MatType T_type>
    friend class Tensor;
 
  public:
    using element_type = T;
    using value_type   = T;
 
    Mat() {
        static_assert(n_rows != 0, "'rows' should be no smaller than 1.");
        static_assert(n_cols != 0, "'n_cols' should be no smaller than 1.");
        static_assert(type == MatType::NORMAL || n_rows == n_cols, "Square matrix 'rows' should be equal to 'n_cols'.");
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
    }
 
    Mat(T val) {
        static_assert(n_rows != 0, "'n_rows' should be no smaller than 1.");
        static_assert(n_cols != 0, "'n_cols' should be no smaller than 1.");
        static_assert(type == MatType::NORMAL || n_rows == n_cols, "Square matrix 'rows' should be equal to 'n_cols'.");
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
        setValue(val);
    }
 
    Mat(const Mat& mat) {
    MAT_COPY:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat[i];
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    template <typename T2, size_t _rows, size_t _cols, MatType _type,
              std::enable_if_t<!std::is_same<T, T2>::value && type == _type && n_rows == _rows && n_cols == _cols,
                               bool> = true>
    Mat(const Mat<T2, _rows, _cols, _type>& mat) {
    MAT_COPY:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat[i];
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    template <typename T2, size_t _rows, size_t _cols, MatType _type,
              std::enable_if_t<type != _type && n_rows == _rows && n_cols == _cols, bool> = true>
    Mat(const Mat<T2, _rows, _cols, _type>& mat) {
    MAT_COPY:
        for (size_t r = 0; r != n_rows; ++r) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t c = 0; c != n_cols; ++c) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                _tryAssign(r, c, mat(r, c));
            }
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    Mat(const std::vector<T>& vec) {
        assert(vec.size() == size() && "Initialization vector size disagrees.");
    MAT_COPY_FROM_STD_VEC:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = vec[i];
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    template <typename T2>
    Mat(std::initializer_list<T2> list) {
        auto list_size = list.size();
        assert(list_size <= size() && "Initializer list size should not exceed size().");
    MAT_COPY_FROM_INIT_LIST:
        for (size_t i = 0; i != list_size; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = *(list.begin() + i);
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    Mat(Init init) {}
 
    //   public: // original private
  public:
    explicit Mat(const T* ptr, InitAfterwards opt = InitAfterwards::NONE) {
        if (opt == InitAfterwards::NONE) {
        MAT_COPY:
            for (size_t i = 0; i != size(); ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
                _data[i] = ptr[i];
            }
        } else if (opt == InitAfterwards::OPP) {
        MAT_COPY_OPP:
            for (size_t i = 0; i != size(); ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
                _data[i] = -ptr[i];
            }
        } else if (opt == InitAfterwards::TR) {
            Mat<T, n_cols, n_rows, type> tmp(ptr, InitAfterwards::NONE);
            this->t(tmp);
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
    explicit Mat(T* const ptr, InitAfterwards opt = InitAfterwards::NONE) {
        if (opt == InitAfterwards::NONE) {
        MAT_COPY:
            for (size_t i = 0; i != size(); ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
                _data[i] = ptr[i];
            }
        } else if (opt == InitAfterwards::OPP) {
        MAT_COPY_OPP:
            for (size_t i = 0; i != size(); ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
                _data[i] = -ptr[i];
            }
        } else if (opt == InitAfterwards::TR) {
            Mat<T, n_cols, n_rows, type> tmp(ptr, InitAfterwards::NONE);
            this->t(tmp);
        }
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = _data type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
#ifdef FLAMES_PRINT_PER_MAT_COPY
        std::cout << "Mat copy!" << std::endl;
#endif
    }
 
  public:
    ~Mat() {
        // so far nothing to do
    }
 
    // template <typename... _unused, MatType _type = type,
    //           typename std::enable_if_t<_type == MatType::NORMAL, bool> = true>
    // inline constexpr size_t size_const() noexcept {
    //     static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::size()!");
    //     return n_rows * n_cols;
    // }
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    T operator[](size_t index) const {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "Matrix index should be within range");
        return _data[index];
    }
 
    T& operator[](size_t index) {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "Matrix index should be within range");
        return _data[index];
    }
 
    T operator()(size_t r, size_t c) const {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return _data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r > c) return _data[(1 + r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else if (r > c) return -_data[(2 * n_cols + 1 - c) * c / 2 + r - 1 - 2 * c];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T& operator()(size_t r, size_t c) {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else assert(!"This element cannot be modified (DIAGONAL).");
        } else if (type == MatType::SCALAR) {
            assert(!"This element cannot be modified (SCALAR).");
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else assert(!"This element cannot be modified (UPPER).");
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else assert(!"This element cannot be modified (LOWER).");
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else assert(!"This element cannot be modified (SUPPER).");
        } else if (type == MatType::SLOWER) {
            if (r > c) return _data[(1 + r) * r / 2 + c - r];
            else assert(!"This element cannot be modified (SLOWER).");
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else if (r > c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - 1 - 2 * c];
 
            // ATTENTION  This part needs to be perfected , missing a minus sign.
            // Because a minus sign will result in a error about reference.
 
            else assert(!"This element cannot be modified (ASYM).");
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        // Just to make the compiler happy.
        return _data[0];
    }
 
    void setValue(T val) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SET_VALUE_UNROLL_FACTOR)
            _data[i] = val;
        }
    }
 
    void setZero() { setValue(static_cast<T>(0)); }
 
    bool read(const std::string& file_name) {
#ifndef __SYNTHESIS__
        std::ifstream f(file_name);
        if (f.is_open()) {
            size_t in_rows, in_cols;
            f >> in_rows >> in_cols;
            if (n_rows != in_rows || n_cols != in_cols) return false; // dimension does not match
            std::string complex_real, mat_type;
            f >> complex_real >> mat_type;
            if (type == MatType::NORMAL && mat_type != "normal") return false;
            if (type == MatType::DIAGONAL && mat_type != "diagonal") return false;
            if (type == MatType::SCALAR && mat_type != "scalar") return false;
            if (type == MatType::UPPER && mat_type != "upper") return false;
            if (type == MatType::LOWER && mat_type != "lower") return false;
            if (type == MatType::SUPPER && mat_type != "supper") return false;
            if (type == MatType::SYM && mat_type != "sym") return false;
            if (type == MatType::ASYM && mat_type != "asym") return false;
            if (complex_real == "complex") {
                // std::string real_part, imag_part;
                // for (size_t i = 0; i != size(); ++i) {
                //     std::getline(f, real_part, ',');
                //     std::getline(f, imag_part, ',');
                //     _data[i].real(std::stod(real_part));
                //     _data[i].imag(std::stod(imag_part));
                // }
                assert(!"Read from a complex matrix is not currently supported.");
                return false;
            } else {
                std::string buf;
                for (size_t i = 0; i != size(); ++i) {
                    std::getline(f, buf, ',');
                    _data[i] = std::stod(buf);
                }
                return true;
            }
        } else {
            return false;
        }
#else
        return true;
#endif
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2>
    Mat& add(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    MAT_PLUS_MAT_SAME:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            this->_data[i] = mat_L[i] + mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::NORMAL && (type1 != MatType::NORMAL || type2 != MatType::NORMAL),
                               bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_NORMAL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[i * n_cols + j] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::DIAGONAL && (type1 != MatType::DIAGONAL || type2 != MatType::DIAGONAL),
                               bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_LOWER:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            this->_data[i] = mat_L(i, i) + mat_R(i, i);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SCALAR && (type1 != MatType::SCALAR || type2 != MatType::SCALAR),
                               bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_SCALAR:
        this->_data[0] = mat_L(0, 0) + mat_R(0, 0);
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::UPPER && (type1 != MatType::UPPER || type2 != MatType::UPPER), bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_UPPER:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::LOWER && (type1 != MatType::LOWER || type2 != MatType::LOWER), bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_LOWER:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(1 + i) * i / 2 + j] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SUPPER && (type1 != MatType::SUPPER || type2 != MatType::SUPPER),
                               bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_SUPPER:
        for (size_t i = 0; i != n_rows - 1; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - 2 * i - 1] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SLOWER && (type1 != MatType::SLOWER || type2 != MatType::SLOWER),
                               bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_SLOWER:
        for (size_t i = 1; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols - 1; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(1 + i) * i / 2 + j - i] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SYM && (type1 != MatType::SYM || type2 != MatType::SYM), bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_SYM:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::ASYM && (type1 != MatType::ASYM || type2 != MatType::ASYM), bool> = true>
    Mat& add(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_PLUS_MAT_ASYM:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_PLUS_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i * 2 - 1] = mat_L(i, j) + mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& add(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        return this->add(*this, mat_R);
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2>
    Mat& sub(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    MAT_MINUS_MAT_SAME:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            this->_data[i] = mat_L[i] - mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::NORMAL && (type1 != MatType::NORMAL || type2 != MatType::NORMAL),
                               bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_NORMAL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[i * n_cols + j] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::DIAGONAL && (type1 != MatType::DIAGONAL || type2 != MatType::DIAGONAL),
                               bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_DIAGONAL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            this->_data[i] = mat_L(i, i) - mat_R(i, i);
        }
        return *this;
    }
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SCALAR && (type1 != MatType::SCALAR || type2 != MatType::SCALAR),
                               bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_SCALAR:
        this->_data[0] = mat_L(0, 0) - mat_R(0, 0);
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::UPPER && (type1 != MatType::UPPER || type2 != MatType::UPPER), bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_UPPER:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::LOWER && (type1 != MatType::LOWER || type2 != MatType::LOWER), bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_LOWER:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(1 + i) * i / 2 + j] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SUPPER && (type1 != MatType::SUPPER || type2 != MatType::SUPPER),
                               bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_SUPPER:
        for (size_t i = 0; i != n_rows - 1; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - 2 * i - 1] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SLOWER && (type1 != MatType::SLOWER || type2 != MatType::SLOWER),
                               bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_SLOWER:
        for (size_t i = 1; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols - 1; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(1 + i) * i / 2 + j - i] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2,
              std::enable_if_t<type == MatType::SYM && (type1 != MatType::SYM || type2 != MatType::SYM), bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_SYM:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = i; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2,
        std::enable_if_t<type == MatType::ASYM && (type1 != MatType::ASYM || type2 != MatType::ASYM), bool> = true>
    Mat& sub(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
             const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    MAT_MINUS_MAT_ASYM:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                this->_data[(2 * n_cols + 1 - i) * i / 2 + j - i * 2 - 1] = mat_L(i, j) - mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& sub(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        // return this->sub(*this, mat_R);
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            _data[i] -= mat_R[i];
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename ScalarT,
        typename T2,
        std::enable_if_t<std::is_arithmetic<std::remove_cv_t<std::remove_reference_t<ScalarT>>>::value, bool> = true>
    Mat& mul(const M<T2, n_rows, n_cols, type, _unused...>& mat, ScalarT s) {
    MAT_SCALAR_TIMES:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] = mat[i] * s;
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename ScalarT,
        typename T2,
        std::enable_if_t<std::is_arithmetic<std::remove_cv_t<std::remove_reference_t<ScalarT>>>::value, bool> = true>
    Mat& mul(const M<T2, n_rows, n_cols, type, _unused...>& mat, std::complex<ScalarT> s) {
    MAT_SCALAR_TIMES:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] = mat[i] * s;
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, int AP_W,
              typename T2>
    Mat& mul(const M<T2, n_rows, n_cols, type, _unused...>& mat, ap_int<AP_W> s) {
    MAT_SCALAR_TIMES:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] = mat[i] * s;
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, int AP_W, int AP_I,
              ap_q_mode AP_Q, ap_o_mode AP_O, int AP_N, typename T2>
    Mat& mul(const M<T2, n_rows, n_cols, type, _unused...>& mat, ap_fixed<AP_W, AP_I, AP_Q, AP_O, AP_N> s) {
    MAT_SCALAR_TIMES:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] = mat[i] * s;
        }
        return *this;
    }
 
    template <
        typename ScalarT,
        std::enable_if_t<std::is_arithmetic<std::remove_cv_t<std::remove_reference_t<ScalarT>>>::value, bool> = true>
    Mat& mul(ScalarT s) {
    MAT_SCALAR_TIMES_SELF:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] *= s;
        }
        return *this;
    }
 
    template <
        typename ScalarT,
        std::enable_if_t<std::is_arithmetic<std::remove_cv_t<std::remove_reference_t<ScalarT>>>::value, bool> = true>
    Mat& mul(std::complex<ScalarT> s) {
    MAT_SCALAR_TIMES_SELF:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] *= s;
        }
        return *this;
    }
 
    template <int AP_W>
    Mat& mul(ap_int<AP_W> s) {
    MAT_SCALAR_TIMES_SELF:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] *= s;
        }
        return *this;
    }
 
    template <int AP_W, int AP_I, ap_q_mode AP_Q, ap_o_mode AP_O, int AP_N>
    Mat& mul(ap_fixed<AP_W, AP_I, AP_Q, AP_O, AP_N> s) {
    MAT_SCALAR_TIMES_SELF:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            _data[i] *= s;
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(!(std::is_same<T1, bool>::value) && !(std::is_same<T2, bool>::value)) &&
                                   ((type1 == MatType::NORMAL && type2 == MatType::NORMAL) ||
                                    (type1 == MatType::NORMAL && type2 == MatType::SYM) ||
                                    (type1 == MatType::SYM && type2 == MatType::NORMAL) ||
                                    (type1 == MatType::SYM && type2 == MatType::SYM)),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    GEMM:
        for (size_t i = 0; i != comm; ++i) {
        GEMM_r:
            for (size_t r = 0; r != n_rows; ++r) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            // FLAMES_PRAGMA(DEPENDENCE variable=mat_L inter false)
            // FLAMES_PRAGMA(DEPENDENCE variable=mat_L intra false)
            // FLAMES_PRAGMA(DEPENDENCE variable=mat_R inter false)
            // FLAMES_PRAGMA(DEPENDENCE variable=mat_R intra false
            GEMM_c:
                for (size_t c = 0; c != n_cols; ++c) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    if (i == 0) (*this)(r, c) = T(0); // initialize
                    (*this)(r, c) += mat_L(r, i) * mat_R(i, c);
                }
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_NORAML_OR_SYM_TIMES_MAT_ASYM:
        for (size_t i = 0; i != comm; ++i) {
        GEMM_r:
            for (size_t r = 0; r != n_rows; ++r) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            GEMM_c:
                for (size_t c = 0; c != n_cols; ++c) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    if (i == 0) (*this)(r, c) = T(0); // initialize
                    if (i != c) (*this)(r, c) += mat_L(r, i) * mat_R(i, c);
                }
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::DIAGONAL),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_NORAML_OR_SYM_TIMES_DIAG:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat_L(i, j) * mat_R[j];
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::SCALAR),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_NORAML_OR_MAT_SYM_TIMES_SCAL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = 0; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat_L(i, j) * mat_R[0];
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
        };
        static const size_t i[288] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7
        };
        static const size_t c[288] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7
        };
    MAT_NORAML_OR_MAT_SYM_TIMES_UPPER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
        };
        static const size_t i[288] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7
        };
        static const size_t c[288] = {
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0
        };
    MAT_NORAML_OR_MAT_SYM_TIMES_LOWER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::SUPPER),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0,
            1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1,
            2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0,
            1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,
            5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2,
            3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t c[224] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3,
            3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4,
            4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5,
            5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
            6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7,
            7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_NORAML_OR_MAT_SYM_TIMES_SUPPER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t i = 0; i != n_rows; i++) { (*this)(i, 0) = 0; }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<((type1 == MatType::NORMAL || type1 == MatType::SYM) && type2 == MatType::SLOWER),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5,
            6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5,
            6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2,
            3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6,
            7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3,
            4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[224] = {
            6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4,
            4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3,
            3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2,
            2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1,
            1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
            1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0,
            0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_NORAML_OR_MAT_SYM_TIMES_SLOWER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n] + 1) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t i = 0; i != n_rows; i++) { (*this)(i, n_rows - 1) = 0; }
        return *this;
    }
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_DIAG_TIMES_MAT_DIAG:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(i, i) = mat_L[i] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_DIAG_TIMES_MAT_SCAL:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[0];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[36] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t i[36] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[36] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_DIAG_TIMES_UPPER:
        for (size_t n = 0; n != n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[36] = {
            0, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7,
        };
        static const size_t i[36] = {
            0, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7,
        };
        static const size_t c[36] = {
            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7,
        };
    MAT_DIAG_TIMES_LOWER:
        for (size_t n = 0; n != n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[28] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6
        };
        static const size_t i[28] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6
        };
        static const size_t c[28] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7
        };
    MAT_DIAG_TIMES_SUPPER:
        for (size_t n = 0; n != n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::SLOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[28] = {
            1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7
        };
        static const size_t i[28] = {
            1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7
        };
        static const size_t c[28] = {
            0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6
        };
    MAT_DIAG_TIMES_SLOWER:
        for (size_t n = 0; n != n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && (type2 == MatType::NORMAL || type2 == MatType::SYM)),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_DIAG_TIMES_MAT_NORMAL_or_SYM:
        for (size_t j = 0; j != n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t i = 0; i != n_rows; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat_L(i, i) * mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::DIAGONAL && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_DIAG_TIMES_MAT_ASYM:
        for (size_t j = 0; j != n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t i = 0; i != n_rows; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) (*this)(i, j) = mat_L(i, i) * mat_R(i, j);
                else (*this)(i, j) = T(0);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SCALAR && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_SCAL:
        _data[0] = mat_L[0] * mat_R[0];
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SCALAR && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_DIAG:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[0] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type2 == MatType::UPPER && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_UPPER:
        for (size_t i = 0; i != (1 + n_rows) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[0] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type2 == MatType::LOWER && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_LOWER:
        for (size_t i = 0; i != (1 + n_rows) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[0] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type2 == MatType::SUPPER && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_SUPPER:
        for (size_t i = 0; i != (n_rows - 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[0] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type2 == MatType::SLOWER && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_SLOWER:
        for (size_t i = 0; i != (n_rows - 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[0] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type2 == MatType::ASYM && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_SLOWER:
        for (size_t i = 1; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) (*this)(i, j) = mat_L[0] * mat_R(i, j);
                else (*this)(i, j) = T(0);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<((type2 == MatType::SYM || type2 == NORMAL) && type1 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SCAL_TIMES_MAT_NORMAL_OR_MAT_SYM:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat_L[0] * mat_R(i, j);
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_UPPER_TIMES_MAT_SCALAR:
        for (size_t i = 0; i != (n_rows + 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[0];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[36] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
                                      2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 7 };
        static const size_t i[36] = { 0, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 2, 3, 4,
                                      5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7 };
        static const size_t c[36] = { 0, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 2, 3, 4,
                                      5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7 };
    MAT_UPPER_TIMES_DIAG:
        for (size_t n = 0; n != n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[120] = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 0, 0,
                                       0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 1,
                                       2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2,
                                       2, 2, 2, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
                                       2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
        static const size_t i[120] = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 0, 1,
                                       2, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 0, 1, 2, 3, 1, 2, 3, 4,
                                       2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3,
                                       4, 5, 6, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 2, 3, 4, 5,
                                       6, 7, 0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7 };
        static const size_t c[120] = { 0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 2, 2,
                                       2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 3, 3, 3, 3, 4, 4, 4, 4,
                                       5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6,
                                       6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7,
                                       7, 7, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };
    MAT_UPPER_TIMES_UPPER:
        for (size_t n = 0; n != n_rows * (n_rows + 1) * (n_rows + 2) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 0, 0, 0, 1, 1, 1, 2, 2,
            2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4,
            0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 0, 1, 2, 1, 2, 3, 2, 3,
            4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7,
            0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4,
            5, 6, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 2, 2, 2, 3, 3, 3, 4, 4,
            4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
            4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,
            6, 6, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_UPPER_TIMES_MAT_LOWER:
        for (size_t n = 0; n != n_rows * (n_rows + 1) * (n_rows + 2) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2,
            3, 3, 3, 4, 4, 4, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1,
            1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 1, 2, 1, 2, 3, 2, 3, 4,
            3, 4, 5, 4, 5, 6, 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 0, 1, 2, 3, 4, 1,
            2, 3, 4, 5, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[84] = {
            1, 2, 3, 4, 5, 6, 7, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 3, 3, 3, 4, 4, 4, 5, 5, 5,
            6, 6, 6, 7, 7, 7, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_UPPER_TIMES_MAT_SUPPER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::SLOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[168] = {
            7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2,
            1, 1, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[168] = {
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7,
            6, 7, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7,
            4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7,
            2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[168] = {
            0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
            0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_UPPER_TIMES_MAT_SLOWER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 3; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n] || i[n] == (c[n] + 1)) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::UPPER && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t c[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
        };
    MAT_UPPER_TIMES_MAT_ASYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n]) (*this)(r[n], c[n]) = 0; // initialize
            if (i[n] != c[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<(type1 == MatType::UPPER && (type2 == MatType::SYM || type2 == MatType::NORMAL)), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t c[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
        };
    MAT_LOWER_TIMES_NORAML_OR_MAT_SYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_LOWER_TIMES_MAT_SCALAR:
        for (size_t i = 0; i != (n_rows + 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[0];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[36] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[36] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[36] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
    MAT_LOWER_TIMES_DIAG:
        for (size_t n = 0; n != n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[204] = {
            7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 7, 7, 7, 6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 7, 7, 7, 7, 6, 6, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[204] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
            1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2,
            0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,
            0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0,
            1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0,
            1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[204] = {
            0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4,
            4, 5, 5, 6, 6, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5,
            6, 6, 6, 7, 7, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
            6, 6, 6, 6, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7,
            7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_UPPER:
        for (size_t n = 0; n != (2 * n_rows * n_rows * n_rows + 3 * n_rows * n_rows + n_rows) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 0, 0, 0, 1, 1, 1, 2, 2,
            2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4,
            0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 0, 1, 2, 1, 2, 3, 2, 3,
            4, 3, 4, 5, 4, 5, 6, 5, 6, 7, 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7,
            0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4,
            5, 6, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[120] = {
            0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 2, 2, 2, 3, 3, 3, 4, 4,
            4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
            4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,
            6, 6, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_LOWER:
        for (size_t n = 0; n != n_rows * (n_rows + 1) * (n_rows + 2) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[168] = {
            0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5,
            6, 6, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[168] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
            0, 1, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2,
            0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5,
            0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t c[168] = {
            7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 7, 7, 7, 6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            7, 7, 7, 7, 6, 6, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7,
            7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_SUPPER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 3; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t r = 0; r != n_cols; r++) { (*this)(r, 0) = T(0); }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::SLOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2,
            3, 3, 3, 4, 4, 4, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1,
            1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[84] = {
            1, 2, 3, 4, 5, 6, 7, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 1, 2, 3, 2, 3, 4, 3, 4, 5,
            4, 5, 6, 5, 6, 7, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 1, 2, 3, 4, 5, 2,
            3, 4, 5, 6, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[84] = {
            1, 2, 3, 4, 5, 6, 7, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 3, 3, 3, 4, 4, 4, 5, 5, 5,
            6, 6, 6, 7, 7, 7, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_SLOWER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n] + 1) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::LOWER && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[288] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_ASYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            if (i[n] != c[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<(type1 == MatType::LOWER && (type2 == MatType::SYM || type2 == MatType::NORMAL)), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[288] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_LOWER_TIMES_MAT_NORMAL_OR_MAT_SYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SUPPER_TIMES_MAT_SCALAR:
        for (size_t i = 0; i != (n_rows - 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[0];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[28] = {
            1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7,
        };
        static const size_t i[28] = {
            1, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 4, 5, 6, 7, 5, 6, 7, 6, 7, 7,
        };
        static const size_t r[28] = {
            0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6,
        };
    MAT_SUPPER_TIMES_MAT_DIAG:
        for (size_t n = 0; n != n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2,
            3, 3, 3, 4, 4, 4, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1,
            1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[84] = {
            1, 2, 3, 4, 5, 6, 7, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 1, 2, 3, 2, 3, 4, 3, 4, 5,
            4, 5, 6, 5, 6, 7, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 4, 5, 6, 7, 1, 2, 3, 4, 5, 2,
            3, 4, 5, 6, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[84] = {
            1, 2, 3, 4, 5, 6, 7, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 3, 3, 3, 4, 4, 4, 5, 5, 5,
            6, 6, 6, 7, 7, 7, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SUPPER_TIMES_MAT_UPPER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n] + 1) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[168] = {
            7, 7, 7, 7, 7, 7, 7, 6, 5, 4, 3, 2, 1, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2,
            1, 1, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[168] = {
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7,
            6, 7, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7,
            4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7,
            2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[168] = {
            0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
            0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_UPPER_TIMES_MAT_SLOWER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 3; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n] || i[n] == (r[n] + 1)) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; c++) { (*this)(n_rows - 1, c) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[56] = {
            0, 1, 2, 3, 4, 5, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3,
            0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[56] = {
            1, 2, 3, 4, 5, 6, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6,
            1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6,
        };
        static const size_t c[56] = {
            2, 3, 4, 5, 6, 7, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7,
            5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SUPPER_TIMES_MAT_SUPPER:
        for (size_t n = 0; n != ((n_rows - 1) * (n_rows - 1) * (n_rows - 1) - (n_rows - 1)) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 1 + r[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t i = 0; i != n_rows - 1; i++) { (*this)(i, i + 1) = T(0); }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<!(type1 == MatType::SUPPER && n_rows == 1) && !(type2 == MatType::SLOWER && cols_ == 1) &&
                             (type1 == MatType::SUPPER && type2 == MatType::SLOWER),
                         bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[140] = {
            6, 6, 6, 6, 6, 6, 6, 5, 4, 3, 2, 1, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[140] = {
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7,
            5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7,
            4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7,
            3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[140] = {
            0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 1, 1, 1, 1,
            2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_SUPPER_TIMES_MAT_SLOWER:
        for (size_t n = 0;
             n != (2 * (n_rows - 1) * (n_rows - 1) * (n_rows - 1) + 3 * (n_rows - 1) * (n_rows - 1) + (n_rows - 1)) / 6;
             n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n] + 1 || i[n] == c[n] + 1) (*this)(r[n], c[n]) = T(0); // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t r = 0; r != n_rows; r++) { (*this)(r, n_cols - 1) = T(0); }
        for (size_t c = 0; c != n_cols - 1; c++) { (*this)(n_rows - 1, c) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5,
            6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5,
            6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2,
            3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6,
            7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3,
            4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[224] = {
            6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4,
            4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3,
            3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2,
            2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1,
            1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
            1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0,
            0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_SUPPER_TIMES_MAT_ASYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n] + 1) (*this)(r[n], c[n]) = T(0); // initialize
            if (i[n] != c[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; c++) { (*this)(n_rows - 1, c) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SUPPER && (type2 == MatType::SYM || type2 == MatType::NORMAL)),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5,
            6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5,
            6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2,
            3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6,
            7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3,
            4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t r[224] = {
            6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4,
            4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3,
            3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2,
            2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1,
            1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
            1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0,
            0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_SUPPER_TIMES_MAT_NORMAL_OR_SYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == r[n] + 1) (*this)(r[n], c[n]) = T(0); // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; c++) { (*this)(n_rows - 1, c) = T(0); }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_SLOWER_TIMES_MAT_SCALAR:
        for (size_t i = 0; i != (n_rows - 1) * n_rows / 2; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[0];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[28] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t i[28] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[28] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_DIAG:
        for (size_t n = 0; n != n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            (*this)(r[n], c[n]) = mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[168] = {
            0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5,
            6, 6, 7, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[168] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
            0, 1, 0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2,
            0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5,
            0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[168] = {
            7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 7, 7, 7, 6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            7, 7, 7, 7, 6, 6, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7,
            7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_UPPER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 3; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; c++) { (*this)(0, c) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 0, 0, 0, 1, 1, 1, 2, 2, 2,
            3, 3, 3, 4, 4, 4, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 0, 0, 0, 0, 0, 1,
            1, 1, 1, 1, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[84] = {
            0, 1, 2, 3, 4, 5, 6, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 0, 1, 2, 1, 2, 3, 2, 3, 4,
            3, 4, 5, 4, 5, 6, 0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 0, 1, 2, 3, 4, 1,
            2, 3, 4, 5, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[84] = {
            1, 2, 3, 4, 5, 6, 7, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 3, 3, 3, 4, 4, 4, 5, 5, 5,
            6, 6, 6, 7, 7, 7, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_LOWER:
        for (size_t n = 0; n != (n_rows * n_rows * n_rows - n_rows) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[140] = {
            1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[140] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
            0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3,
            0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,
            0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[140] = {
            7, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            7, 7, 7, 6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 7, 7, 6, 6, 6, 6,
            5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_SUPPER:
        for (size_t n = 0;
             n != (2 * (n_rows - 1) * (n_rows - 1) * (n_rows - 1) + 3 * (n_rows - 1) * (n_rows - 1) + (n_rows - 1)) / 6;
             n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t r = 0; r != n_rows; r++) { (*this)(r, 0) = T(0); }
        for (size_t c = 1; c != n_cols; c++) { (*this)(0, c) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::SLOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[56] = {
            0, 1, 2, 3, 4, 5, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3,
            0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
        };
        static const size_t i[56] = {
            1, 2, 3, 4, 5, 6, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 1, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 6,
            1, 2, 3, 4, 2, 3, 4, 5, 3, 4, 5, 6, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[56] = {
            2, 3, 4, 5, 6, 7, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7,
            5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_SLOWER:
        for (size_t n = 0; n != ((n_rows - 1) * (n_rows - 1) * (n_rows - 1) - (n_rows - 1)) / 6; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 1 + c[n]) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t i = 0; i != n_rows - 1; i++) { (*this)(i, i - 1) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0,
            1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1,
            2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0,
            1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,
            5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2,
            3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[224] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3,
            3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4,
            4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5,
            5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
            6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7,
            7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_ASYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            if (i[n] != c[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; ++c) { (*this)(0, c) = T(0); }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::SLOWER && (type2 == MatType::SYM || type2 == MatType::NORMAL)),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t c[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0,
            1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1,
            2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0,
            1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,
            5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2,
            3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t r[224] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3,
            3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4,
            4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5,
            5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
            6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7,
            7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_SLOWER_TIMES_MAT_NORMAL_OR_MAT_SYM:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t c = 0; c != n_cols; ++c) { (*this)(0, c) = T(0); }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::DIAGONAL), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_ASYM_TIMES_MAT_DIAG:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = 0; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) (*this)(i, j) = mat_L(i, j) * mat_R[j];
            }
        }
        for (size_t c = 0; c != n_cols; ++c) { (*this)(c, c) = T(0); }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::SCALAR), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_ASYM_TIMES_MAT_SCAL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) (*this)(i, j) = mat_L(i, j) * mat_R[0];
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::UPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[288] = {
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
            0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_ASYM_TIMES_MAT_UPPER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            if (r[n] != i[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::LOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[288] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[288] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[288] = {
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
            7, 6, 6, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_ASYM_TIMES_MAT_LOWER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows + 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n]) (*this)(r[n], c[n]) = 0; // initialize
            if (r[n] != i[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::SUPPER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0,
            1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1,
            2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1,
            2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0,
            1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4,
            5, 0, 1, 2, 3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2,
            3, 4, 5, 6, 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6,
        };
        static const size_t c[224] = {
            1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3,
            3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4,
            4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5,
            5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6,
            6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6,
            6, 7, 7, 7, 7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7,
            7, 7, 7, 7, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
        };
    MAT_ASYM_TIMES_SUPPER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == 0) (*this)(r[n], c[n]) = 0; // initialize
            if (r[n] != i[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t r = 0; r != n_rows; r++) { (*this)(r, 0) = T(0); }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::SLOWER), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        static const size_t r[224] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
            5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
        };
        static const size_t i[224] = {
            7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5,
            6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5,
            6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4,
            5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2,
            3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6,
            7, 1, 2, 3, 4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3,
            4, 5, 6, 7, 7, 6, 7, 5, 6, 7, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7,
        };
        static const size_t c[224] = {
            6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4,
            4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3,
            3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2,
            2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1,
            1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
            1, 0, 0, 0, 0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0,
            0, 0, 0, 0, 6, 5, 5, 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
        };
    MAT_ASYM_TIMES_SLOWER:
        for (size_t n = 0; n != n_rows * n_rows * (n_rows - 1) / 2; n++) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
            if (i[n] == c[n] + 1) (*this)(r[n], c[n]) = 0; // initialize
            if (r[n] != i[n]) (*this)(r[n], c[n]) += mat_L(r[n], i[n]) * mat_R(i[n], c[n]);
        }
        for (size_t r = 0; r != n_rows; r++) { (*this)(r, n_cols - 1) = T(0); }
 
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<(type1 == MatType::ASYM && (type2 == MatType::NORMAL || type2 == MatType::SYM)), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_ASYM_TIMES_MAT_NORMAL:
        for (size_t i = 0; i != comm; ++i) {
        GEMM_r:
            for (size_t r = 0; r != n_rows; ++r) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            GEMM_c:
                for (size_t c = 0; c != n_cols; ++c) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    if (i == 0) (*this)(r, c) = T(0); // initialize
                    if (r != i) (*this)(r, c) += mat_L(r, i) * mat_R(i, c);
                }
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(type1 == MatType::ASYM && type2 == MatType::ASYM), bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    MAT_ASYM_TIMES_MAT_ASYM:
    GEMM_r:
        for (size_t r = 0; r != n_rows; ++r) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
        GEMM_c:
            for (size_t c = 0; c != n_cols; ++c) {
                for (size_t i = 0; i != comm; ++i) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    if (i == 0) (*this)(r, c) = T(0); // initialize
                    if (i != c && i != r) (*this)(r, c) += mat_L(r, i) * mat_R(i, c);
                }
            }
        }
        return *this;
    }
 
    template <
        template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
        template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1, typename T2,
        MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
        std::enable_if_t<(std::is_same<T1, bool>::value) && ((type1 == MatType::NORMAL && type2 == MatType::NORMAL) ||
                                                             (type1 == MatType::NORMAL && type2 == MatType::SYM) ||
                                                             (type1 == MatType::SYM && type2 == MatType::NORMAL) ||
                                                             (type1 == MatType::SYM && type2 == MatType::SYM)),
                         bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
        this->setZero();
        for (size_t c = 0; c < n_cols; ++c) {
            for (size_t i = 0; i < comm; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TIMES_UNROLL_FACTOR)
                for (size_t r = 0; r < n_rows; ++r) {
                    FLAMES_PRAGMA(UNROLL)
                    (*this)(r, c) += mat_L(r, i) * mat_R(i, c);
                }
            }
        }
 
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t rows_, size_t cols_, size_t comm,
              std::enable_if_t<(std::is_same<T2, bool>::value && !std::is_same<T1, bool>::value) &&
                                   ((type1 == MatType::NORMAL && type2 == MatType::NORMAL) ||
                                    (type1 == MatType::NORMAL && type2 == MatType::SYM) ||
                                    (type1 == MatType::SYM && type2 == MatType::NORMAL) ||
                                    (type1 == MatType::SYM && type2 == MatType::SYM)),
                               bool> = true>
    Mat& mul(const M1<T1, rows_, comm, type1, _unused1...>& mat_L,
             const M2<T2, comm, cols_, type2, _unused2...>& mat_R) {
        FLAMES_PRAGMA(INLINE off)
        static_assert(n_rows == rows_, "Matrix dimension should meet.");
        static_assert(n_cols == cols_, "Matrix dimension should meet.");
    GEMM_r:
        for (size_t r = 0; r != n_rows; ++r) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
        GEMM_c:
            for (size_t c = 0; c != n_cols; ++c) {
            GEMM:
                for (size_t i = 0; i != comm; ++i) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    if (i == 0) (*this)(r, c) = T(0); // initialize
                    if (mat_R(i, c) != 0) (*this)(r, c) += mat_L(r, i);
                }
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, size_t rows_, size_t cols_, MatType type1, MatType type2,
              std::enable_if_t<rows_ == n_rows && cols_ == n_cols && type1 == type && type2 == type, bool> = true>
    Mat& emul(const M1<T1, rows_, cols_, type1, _unused1...>& mat_L,
              const M2<T2, rows_, cols_, type2, _unused2...>& mat_R) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_EMUL_UNROLL_FACTOR)
            _data[i] = mat_L[i] * mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    Mat& col(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t c) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        static_assert(size() == rows_, "Element number should be rows_ in Mat::col(mat, index).");
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat(i, c);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    [[deprecated("Use .col_ to create a MatRefCol to write a column instead.")]] void
    col(size_t c, const M<T2, rows_, cols_, type2, _unused...>& mat) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        assert(mat.size() == n_rows && "Element number should be n_rows in Mat::col(index, mat).");
        for (int i = 0; i != mat.size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            (*this)(i, c) = mat[i];
        }
    }
 
    Mat<T, n_rows, 1, MatType::NORMAL> col(size_t c) const {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        Mat<T, n_rows, 1, MatType::NORMAL> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat(i, 0) = (*this)(i, c);
        }
        return mat;
    }
 
    MatViewCol<T, n_rows, n_cols, MatType::NORMAL, MType<type>> col_(size_t index) const {
        assert(index < n_cols && "Take the specific col by index requires 'The index should be smaller than the number "
                                 "of the matrix's columns.'.");
        return { *this, index };
    }
 
    MatRefCol<T, n_rows, n_cols, MatType::NORMAL, MType<type>> col_(size_t index) {
        assert(index < n_cols && "Take the specific col by index requires 'The index should be smaller than the number "
                                 "of the matrix's columns.'.");
        return { *this, index };
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    Mat& row(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t r) {
        assert(r < rows_ && "row should be smaller than rows_ of mat in Mat::row.");
        static_assert(size() == cols_, "The number of the Matrices' n_cols should meet.");
        for (size_t j = 0; j != size(); ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[j] = mat(r, j);
        }
        return *this;
    }
 
    Mat<T, 1, n_cols, MatType::NORMAL> row(size_t r) const {
        assert(r < n_rows && "Take the specific row by index requires 'The index should be smaller than the number of "
                             "the matrix's rows.'.");
        Mat<T, 1, n_cols, MatType::NORMAL> mat;
        for (size_t j = 0; j != n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat(0, j) = (*this)(r, j);
        }
        return mat;
    }
 
    // /**
    //  * @brief Take a row of a matrix by index as a read only view.
    //  *
    //  * @return (MatViewRow<Index, T, n_rows, n_cols, MatType::NORMAL, MType<type>>) The read only a row vector view.
    //  */
    // MatViewRow<T, n_rows, n_cols, MatType::NORMAL, MType<type>> Row_() const {
    //     static_assert(Index > int(0), "Take the specific row by index requires 'The index can't be smaller than
    //     0'."); static_assert(Index < n_rows, "Take the specific row by index requires 'The index should be smaller
    //     than the "
    //                                   "number of the matrix's rows.'.");
    //     return *this;
    // }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    Mat& cols(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t first_col) {
        assert(first_col < n_cols && "Take the successive n_cols by index requires 'The indexes should be smaller than "
                                     "the number of the matrix's columns.'.");
        assert(first_col > int(0) &&
               "Take the successive n_cols by index requires 'The indexes can't be smaller than 0'.");
        static_assert(n_rows == rows_, "The number of the Matrices' rows should meet.");
        for (size_t j = 0; j != n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t i = 0; i != n_rows; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat(i, j + first_col);
            }
        }
        return *this;
    }
 
    template <size_t _cols>
    Mat<T, n_rows, _cols, MatType::NORMAL> cols(size_t first_col) {
        assert(first_col < n_cols && "Take the successive n_cols by index requires 'The indexes should be smaller than "
                                     "the number of the matrix's columns.'.");
        assert(first_col > int(0) &&
               "Take the successive n_cols by index requires 'The indexes can't be smaller than 0'.");
        static_assert(_cols > int(1),
                      "Take the successive n_cols by index requires 'The total number can't be smaller than 1'.");
 
        Mat<T, n_rows, _cols, MatType::NORMAL> mat;
        for (size_t j = 0; j != _cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t i = 0; i != n_rows; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(i, j + first_col);
            }
        }
        return mat;
    }
    template <size_t first_col, size_t last_col>
    MatViewCols<first_col, last_col, T, n_rows, n_cols, MatType::NORMAL, MType<type>> Cols_() const {
        static_assert(first_col > int(0),
                      "Take the successive cols by index requires 'The first index can't be smaller than 0'.");
        static_assert(
            first_col < last_col,
            "Take the successive cols by index requires 'The first index should be smaller than the last index'.");
        static_assert(last_col < n_cols, "Take the successive cols by index requires 'The last index should be smaller "
                                         "than the number of the matrix's cols.'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    Mat& rows(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t first_row) {
        assert(first_row < n_rows && "Take the successive n_rows by index requires 'The indexes should be smaller than "
                                     "the number of the matrix's rows.'.");
        assert(first_row > int(0) &&
               "Take the successive n_rows by index requires 'The indexes can't be smaller than 0'.");
        static_assert(n_cols == cols_, "The number of the Matrices' cols should meet.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat(i + first_row, j);
            }
        }
        return *this;
    }
 
    template <size_t _rows>
    Mat<T, _rows, n_cols, MatType::NORMAL> rows(size_t first_row) {
        assert(first_row < n_rows && "Take the successive n_rows by index requires 'The indexes should be smaller than "
                                     "the number of the matrix's rows.'.");
        assert(first_row > int(0) &&
               "Take the successive n_rows by index requires 'The indexes can't be smaller than 0'.");
        static_assert(_rows > int(1),
                      "Take the successive n_rows by index requires 'The total number can't be smaller than 1'.");
 
        Mat<T, _rows, n_cols, MatType::NORMAL> mat;
        for (size_t i = 0; i != _rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(i + first_row, j);
            }
        }
        return mat;
    }
 
    template <size_t first_row, size_t last_row>
    MatViewRows<first_row, last_row, T, n_rows, n_cols, MatType::NORMAL, MType<type>> Rows_() const {
        static_assert(
            first_row < last_row,
            "Take the successive rows by index requires 'The first index should be smaller than the last index'.");
        static_assert(last_row < n_rows, "Take the successive rows by index requires 'The last index should be smaller "
                                         "than the number of the matrix's rows.'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1, typename M2,
              typename T1, MatType type1, size_t rows_, size_t cols_>
    Mat& rows(const M1<T1, rows_, cols_, type1, _unused1...>& mat, M2 vector) {
        static_assert(n_cols == cols_, "The number of the Matrices' cols should meet.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            assert(vector[i] > int(0) &&
                   "Take the discrete n_rows by index requires 'The indexes can't be smaller than 0'.");
            assert(vector[i] < n_rows && "Take the discrete n_rows by index requires 'The indexes should be smaller "
                                         "than the number of the matrix's rows.'.");
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat(vector[i], j);
            }
        }
        return *this;
    }
 
    template <size_t _rows, typename M2>
    Mat<T, _rows, n_cols, MatType::NORMAL> rows(M2 vector) {
        Mat<T, _rows, n_cols, MatType::NORMAL> mat;
        for (size_t i = 0; i != _rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            assert(vector[i] >= int(0) &&
                   "Take the discrete n_rows by index requires 'The indexes can't be smaller than 0'.");
            assert(vector[i] < n_rows && "Take the discrete n_rows by index requires 'The indexes should be smaller "
                                         "than the number of the matrix's rows.'.");
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(vector[i], j);
            }
        }
        return mat;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1, typename M2,
              typename T1, MatType type1, size_t rows_, size_t cols_>
    Mat& cols(const M1<T1, rows_, cols_, type1, _unused1...>& mat, M2 vector) {
        static_assert(n_rows == rows_, "The number of the Matrices' rows should meet.");
        for (size_t j = 0; j != n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            assert(vector[j] >= int(0) &&
                   "Take the discrete n_cols by index requires 'The indexes can't be smaller than 0'.");
            assert(vector[j] < n_cols && "Take the discrete n_cols by index requires 'The indexes should be smaller "
                                         "than the number of the matrix's cols.'.");
            for (size_t i = 0; i != n_rows; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                (*this)(i, j) = mat(i, vector[j]);
            }
        }
        return *this;
    }
 
    template <size_t _cols, typename M2>
    Mat<T, n_rows, _cols, MatType::NORMAL> cols(M2 vector) {
        Mat<T, n_rows, _cols, MatType::NORMAL> mat;
        for (size_t j = 0; j != _cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            assert(vector[j] >= int(0) &&
                   "Take the discrete n_cols by index requires 'The indexes can't be smaller than 0'.");
            assert(vector[j] < n_cols && "Take the discrete n_cols by index requires 'The indexes should be smaller "
                                         "than the number of the matrix's cols.'.");
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(i, vector[j]);
            }
        }
        return mat;
    }
 
    Mat& abs_() {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_ABS_UNROLL_FACTOR)
            if (_data[i] < 0) _data[i] = -_data[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& t(const M<T2, n_cols, n_rows, type2, _unused...>& mat) {
        if (type == MatType::DIAGONAL || type == MatType::SCALAR || type == MatType::SYM) {
            // do nothing
        } else if (type == MatType::NORMAL) {
        MAT_TRANSPOSE_NORMAL:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = 0; j != n_rows; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    _data[n_rows * i + j] = mat._data[n_rows * j + i];
                }
            }
        } else if (type == MatType::UPPER) {
        MAT_TRANSPOSE_UPPER:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = i; j != n_rows; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    (*this)(i, j) = mat(j, i);
                }
            }
        } else if (type == MatType::LOWER) {
        MAT_TRANSPOSE_LOWER:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = 0; j <= i; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    (*this)(i, j) = mat(j, i);
                }
            }
        } else if (type == MatType::SUPPER) {
        MAT_TRANSPOSE_SUPPER:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = i; j != n_rows; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    (*this)(i, j) = mat(j, i);
                }
            }
        } else if (type == MatType::SLOWER) {
        MAT_TRANSPOSE_SLOWER:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = i; j != n_rows; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    (*this)(i, j) = mat(j, i);
                }
            }
        } else if (type == MatType::ASYM) {
        MAT_TRANSPOSE_ASYM:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = i + 1; j != n_rows; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    (*this)(i, j) = mat(j, i);
                }
            }
        } else {
            assert(!"Impossible");
        }
        return *this;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<_type == MatType::NORMAL, bool> = true>
    Mat<T, n_cols, n_rows, type> t() const {
        // Ref: https://stackoverflow.com/a/13401982/15080514
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat<T, n_cols, n_rows, type> mat;
    MAT_TRANSPOSE_NORMAL:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = 0; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(j, i);
            }
        }
        return mat;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<
                  (_type == MatType::DIAGONAL || _type == MatType::SCALAR || _type == MatType::SYM), bool> = true>
    Mat t() const {
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        return *this;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<_type == MatType::UPPER, bool> = true>
    Mat<T, n_rows, n_cols, MatType::LOWER> t() const {
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat<T, n_rows, n_cols, MatType::LOWER> mat;
    MAT_TRANSPOSE_NORMAL:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = 0; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(i, j) = (*this)(j, i);
            }
        }
        return mat;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<_type == MatType::LOWER, bool> = true>
    Mat<T, n_rows, n_cols, MatType::UPPER> t() const {
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat<T, n_rows, n_cols, MatType::UPPER> mat;
    MAT_TRANSPOSE_LOWER:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = i; j <= i; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(j, i) = (*this)(i, j);
            }
        }
        return mat;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<_type == MatType::SUPPER, bool> = true>
    Mat<T, n_rows, n_cols, MatType::SLOWER> t() const {
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat<T, n_rows, n_cols, MatType::SLOWER> mat;
    MAT_TRANSPOSE_SUPPER:
        for (size_t i = 0; i != n_cols - 1; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_rows; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(j, i) = (*this)(i, j);
            }
        }
        return mat;
    }
 
    template <typename... _unused, MatType _type = type,
              typename std::enable_if_t<_type == MatType::SLOWER, bool> = true>
    Mat<T, n_rows, n_cols, MatType::SLOWER> t() const {
        static_assert(sizeof...(_unused) == 0, "Do not specify template arguments for Mat::t()!");
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat<T, n_rows, n_cols, MatType::SUPPER> mat;
    MAT_TRANSPOSE_SLOWER:
        for (size_t i = 1; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_rows - 1; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(j, i) = (*this)(i, j);
            }
        }
        return mat;
    }
 
    template <typename... _unused, MatType _type = type, typename std::enable_if_t<_type == MatType::ASYM, bool> = true>
    Mat t() const {
        static_assert(n_cols > 0 && n_rows > 0, "The matrix should have size when transposing.");
        Mat mat;
    MAT_TRANSPOSE_ASYM:
        for (size_t i = 1; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
            for (size_t j = i + 1; j != n_rows - 1; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                mat(j, i) = (*this)(i, j);
            }
        }
        return mat;
    }
 
    MatViewT<T, n_cols, n_rows, tType(type)> t_() { return const_cast<T*>(_data); }
 
    MatViewT<T, n_cols, n_rows, tType(type)> t_() const { return const_cast<T*>(_data); }
 
    Mat& tSelf() {
        static_assert(type != MatType::UPPER, "Upper matrix cannot perform in place transpose.");
        static_assert(type != MatType::LOWER, "Lower matrix cannot perform in place transpose.");
        static_assert(type != MatType::SUPPER, "Strict upper matrix cannot perform in place transpose.");
        static_assert(type != MatType::SLOWER, "Strict lower matrix cannot perform in place transpose.");
        static_assert(n_rows == n_cols, "In-place transpose requires a square matrix.");
        if (type == MatType::NORMAL) {
        MAT_NORMAL_TRANSPOSE_SELF:
            for (size_t i = 0; i != n_cols; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                for (size_t j = i; j != n_cols; ++j) {
                    FLAMES_PRAGMA(LOOP_FLATTEN)
                    std::swap(_data[n_cols * i + j], _data[n_cols * j + i]);
                }
            }
        } else if (type == MatType::ASYM) {
        MAT_AYSM_TRANSPOSE_SELF:
            for (size_t i = 0; i != n_cols * (n_cols - 1) / 2; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_TRANSPOSE_UNROLL_FACTOR)
                _data[i] = -_data[i];
            }
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2>
    Mat& opp(const M<T2, n_rows, n_cols, type, _unused...>& mat) {
    MAT_OPP:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = -mat[i];
        }
        return *this;
    }
 
    Mat opp() const {
        Mat mat;
    MAT_OPP:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = -_data[i];
        }
        return mat;
    }
 
    MatViewOpp<T, n_rows, n_cols, type> opp_() const {
        FLAMES_PRAGMA(INLINE)
        return *this;
    }
 
    Mat& oppSelf() {
    MAT_OPP_SELF:
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = -_data[i];
        }
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& diagMat(const M<T2, n_rows, n_cols, type2, _unused...>& mat) {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            (*this)(i, i) = mat(i, i);
        }
        return *this;
    }
 
    Mat<T, n_rows, n_cols, MatType::DIAGONAL> diagMat() const {
        Mat<T, n_rows, n_cols, MatType::DIAGONAL> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat(i, i) = (*this)(i, i);
        }
        return mat;
    }
 
    MatViewDiagMat<T, n_rows, n_cols, MatType::DIAGONAL, MType<type>> diagMat_() const {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& diagVec(const M<T2, n_rows, n_rows, type2, _unused...>& mat) {
        static_assert(n_cols == 1, "Diagonal vector has column number as 1.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat(i, i);
        }
        return *this;
    }
 
    Vec<T, n_rows> diagVec() const {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        Vec<T, n_rows> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat._data[i] = (*this)(i, i);
        }
        return mat;
    }
 
    MatViewDiagVec<T, n_rows, 1, MatType::NORMAL, MType<type>> diagVec_() const {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& diagRowVec(const M<T2, n_cols, n_cols, type2, _unused...>& mat) {
        static_assert(n_rows == 1, "Diagonal vector has column number as 1.");
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat(i, i);
        }
        return *this;
    }
 
    RowVec<T, n_cols> diagRowVec() const {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        RowVec<T, n_cols> mat;
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat._data[i] = (*this)(i, i);
        }
        return mat;
    }
 
    MatViewDiagRowVec<T, 1, n_cols, MatType::NORMAL, MType<type>> diagRowVec_() const {
        static_assert(n_rows == n_cols, "Take the diagonal requires 'n_rows == n_cols'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& offDiag(const M<T2, n_cols, n_rows, type2, _unused...>& mat) {
        static_assert(n_rows == n_cols, "Take the off diagonal requires 'n_rows == n_cols'.");
        static_assert(type == MatType::NORMAL, "Take the off diagonal requires the matrix to be NORMAL.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) (*this)(i, j) = mat(i, j);
                else (*this)(i, j) = T(0);
            }
        }
        return *this;
    }
 
    Mat<T, n_rows, n_cols, MatType::NORMAL> offDiag() const {
        static_assert(n_rows == n_cols, "Take the off diagonal requires 'n_rows == n_cols'.");
        static_assert(type == MatType::NORMAL, "Take the off diagonal requires the matrix to be NORMAL.");
        Mat<T, n_rows, n_cols, MatType::NORMAL> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            for (size_t j = 0; j != n_cols; ++j) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                if (i != j) mat(i, j) = (*this)(i, j);
                else mat(i, j) = T(0);
            }
        }
        return mat;
    }
 
    MatViewOffDiag<T, n_rows, n_cols, MatType::NORMAL, MType<type>> offDiag_() const {
        static_assert(n_rows == n_cols, "Take the off diagonal requires 'n_rows == n_cols'.");
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& invDiag(const M<T2, n_cols, n_rows, type2, _unused...>& mat) {
        static_assert(type == MatType::DIAGONAL, "'invDiag' is only used for diagonal matrix.");
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = T(1.0) / mat(i, i);
        }
        return *this;
    }
 
    Mat invDiag() const {
        static_assert(type == MatType::DIAGONAL, "'invDiag' is only used for diagonal matrix.");
        Mat mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_INV_UNROLL_FACTOR)
            mat._data[i] = T(1.0) / _data[i];
        }
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    Mat& invNSA(const M<T2, n_rows, n_cols, type2, _unused...>& mat, size_t iter = 4) {
        static_assert(n_rows == n_cols, "Calculate inverse needs to be a square matrix.");
        assert(iter >= 1 && "At least one iteration is needed.");
        const auto D = mat.diagMat_(); // diagonal part
        const auto E = mat.offDiag_(); // off-diagonal part
        Mat<T, n_rows, n_cols, MatType::DIAGONAL> D_inv;
        D_inv.invDiag(D); // inverse of diagonal part
        // D_inv.print("D_inv:\n");
        // E.asMat().print("E:\n");
        auto D_inv_opp                                  = -D_inv;
        Mat<T, n_rows, n_cols, MatType::NORMAL> product = D_inv_opp * E;
        Mat<T, n_rows, n_cols, MatType::NORMAL> sum_tmp = *this = product; // the first iteration
        Mat<T, n_rows, n_cols, MatType::NORMAL> tmp;
    MAT_INV_NSA:
        for (size_t i = 1; i < iter; ++i) {
            tmp.mul(*this, product);
            *this = tmp;
            sum_tmp += tmp;
        }
        this->mul(sum_tmp, D_inv);
        return *this += D_inv;
    }
 
    Mat invNSA(size_t iter = 4) const {
        static_assert(n_rows == n_cols, "Calculate inverse needs to be a square matrix.");
        Mat mat;
        mat.invNSA(*this, iter);
        return mat;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, typename coeff_type>
    Mat& invINSA(const M<T2, n_rows, n_cols, type2, _unused...>& mat, size_t iter = 3, coeff_type beta = 2) {
        static_assert(n_rows == n_cols, "Calculate inverse needs to be a square matrix.");
        assert(iter >= 1 && "At least one iteration is needed.");
        return *this;
    }
 
    template <typename coeff_type>
    Mat invINSA(size_t iter = 3, coeff_type beta = 1.0) const {
        static_assert(n_rows == n_cols, "Calculate inverse needs to be a square matrix.");
        Mat mat;
        mat.invINSA(*this, iter);
        return mat;
    }
 
    // Does not support complex number now.
    template <typename Tp = T>
    Tp power() const {
        Tp p = 0;
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_POWER_UNROLL_FACTOR)
            p += static_cast<Tp>(_data[i] * _data[i]);
        }
        return p;
    }
 
    T value() const {
        static_assert(n_rows == 1 && n_cols == 1, "This only applies to matrix of size 1x1.");
        return _data[0];
    }
 
    T& value() {
        static_assert(n_rows == 1 && n_cols == 1, "This only applies to matrix of size 1x1.");
        return _data[0];
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const {
#ifndef __SYNTHESIS__
        static_assert(n_rows > 0 && n_cols > 0, "Print requires this matrix be of valid size.");
        os << str << "[";
        for (size_t i = 0; i + 1 < n_rows; ++i) {
            os << "[";
            for (size_t j = 0; j + 1 < n_cols; ++j) os << static_cast<T>((*this)(i, j)) << ", ";
            os << static_cast<T>((*this)(i, n_cols - 1)) << "]," << std::endl;
        }
        os << "[";
        for (size_t j = 0; j + 1 < n_cols; ++j) os << static_cast<T>((*this)(n_rows - 1, j)) << ", ";
        os << static_cast<T>((*this)(n_rows - 1, n_cols - 1)) << "]]" << std::endl;
#endif
    }
 
    MatView<T, n_rows, n_cols, type> operator+() const {
        FLAMES_PRAGMA(INLINE)
        return *this;
    }
 
    MatViewOpp<T, n_rows, n_cols, type> operator-() const {
        FLAMES_PRAGMA(INLINE)
        return *this;
    }
 
    //   public: // original private
  public:
    T* rawDataPtr() { return _data; }
 
    const T* rawDataPtr() const { return _data; }
 
    inline void _tryAssign(size_t r, size_t c, T value) {
        FLAMES_PRAGMA(INLINE)
        if (type == MatType::DIAGONAL) {
            if (r == c) (*this)(r, c) = value;
        } else if (type == MatType::UPPER) {
            if (r <= c) (*this)(r, c) = value;
        } else if (type == MatType::LOWER) {
            if (r >= c) (*this)(r, c) = value;
        } else if (type == MatType::SUPPER) {
            if (r < c) (*this)(r, c) = value;
        } else if (type == MatType::SLOWER) {
            if (r > c) (*this)(r, c) = value;
        } else if (type == MatType::SYM) {
            if (r <= c) (*this)(r, c) = value;
        } else if (type == MatType::ASYM) {
            if (r < c) (*this)(r, c) = value;
        } else if (type == MatType::NORMAL) {
            (*this)(r, c) = value;
        } else {
            assert(!"Impossible! Unknown type!");
        }
    }
 
    inline void _tryAssignOutRange(size_t r, size_t c, T value) {
        FLAMES_PRAGMA(INLINE)
        if (r >= n_rows || c >= n_cols) return;
        else _tryAssign(r, c, value);
    }
 
    inline void _tryPlus(size_t r, size_t c, T value) {
        FLAMES_PRAGMA(INLINE)
        if (type == MatType::DIAGONAL) {
            if (r == c) (*this)(r, c) += value;
        } else if (type == MatType::UPPER) {
            if (r <= c) (*this)(r, c) += value;
        } else if (type == MatType::LOWER) {
            if (r >= c) (*this)(r, c) += value;
        } else if (type == MatType::SUPPER) {
            if (r < c) (*this)(r, c) += value;
        } else if (type == MatType::SLOWER) {
            if (r > c) (*this)(r, c) += value;
        } else if (type == MatType::ASYM) {
            if (r != c) (*this)(r, c) += value;
        } else if (type == MatType::SYM) {
            (*this)(r, c) += value;
        } else if (type == MatType::NORMAL) {
            (*this)(r, c) += value;
        } else {
            assert(!"Impossible! Unknown type!");
        }
    }
 
    template <typename Tmp, typename M, typename Comm, typename Zero>
    inline void _sa_read_first_col_L(size_t i, Tmp& tmp_L, const M& mat_L, size_t begin_shift,
                                     Comm __attribute__((unused)) _comm_foo, Zero zero) const {
        FLAMES_PRAGMA(INLINE)
        constexpr size_t comm = Comm::value;
    read_first_col_L:
        for (size_t j = 0; j < n_rows; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            tmp_L[j][0] = ((j <= i + begin_shift) && (i + begin_shift - j < comm))
                              ? mat_L(j, comm - 1 - (i + begin_shift - j))
                              : zero;
        }
    }
 
    template <typename Tmp, typename M, typename Comm, typename Zero>
    inline void _sa_read_first_row_R(size_t i, Tmp& tmp_R, const M& mat_R, size_t begin_shift,
                                     Comm __attribute__((unused)) _comm_foo, Zero zero) const {
        FLAMES_PRAGMA(INLINE)
        constexpr size_t comm = Comm::value;
    read_first_row_R:
        for (size_t j = 0; j < n_cols; ++j) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            tmp_R[0][j] = ((j <= i + begin_shift) && (i + begin_shift - j < comm))
                              ? mat_R(comm - 1 - (i + begin_shift - j), j)
                              : zero;
        }
    }
 
    template <typename T1, typename T2, typename HLSVec>
    inline void _sa_multiply(const T1& tmp_L, const T2& tmp_R, const HLSVec& use_assign) {
        FLAMES_PRAGMA(INLINE)
    multiply:
        for (size_t r = 0; r != n_rows; ++r) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
            for (size_t c = 0; c != n_cols; ++c) {
                FLAMES_PRAGMA(LOOP_FLATTEN)
                T result = tmp_L[r][c] * tmp_R[r][c];
                if (use_assign[r * n_cols + c]) {
                    _tryAssign(r, c, result);
                    // std::cout << "assign " << r << ' ' << c << " (" << tmp_L[r][c] << "x" << tmp_R[r][c] << "=" <<
                    // result << ")\n";
                } else {
                    _tryPlus(r, c, result);
                    // std::cout << "plus " << r << ' ' << c << " (" << tmp_L[r][c] << "x" << tmp_R[r][c] << "=" <<
                    // result << ")\n";
                }
            }
        }
    };
 
    template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
              template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
              typename T2, MatType type1, MatType type2, size_t comm>
    Mat& _systolicArrayMul(const M1<T1, n_rows, comm, type1, _unused1...>& mat_L,
                           const M2<T2, comm, n_cols, type2, _unused2...>& mat_R, size_t begin_shift = 0,
                           size_t end_shift = 0) {
        // constexpr size_t begin_shift = BeginShift::value;
        // constexpr size_t end_shift = EndShift::value;
        T1 tmp_L[n_rows][n_cols];
        T2 tmp_R[n_rows][n_cols];
        std::vector<bool> use_assign(n_rows * n_cols, true);
// hls::vector<bool, n_rows * n_cols> use_assign = true;
#ifdef FLAMES_MAT_PARTITION_COMPLETE
        FLAMES_PRAGMA(ARRAY_PARTITION variable = tmp_L type = complete)
        FLAMES_PRAGMA(ARRAY_PARTITION variable = tmp_R type = complete)
#else
        FLAMES_PRAGMA(ARRAY_PARTITION variable = tmp_L type = block factor = FLAMES_MAT_PARTITION_FACTOR)
        FLAMES_PRAGMA(ARRAY_PARTITION variable = tmp_R type = block factor = FLAMES_MAT_PARTITION_FACTOR)
#endif
        auto write_L = [&](size_t i) {
            if (i + 1 != n_rows + comm + n_cols - 2 - begin_shift - end_shift) {
            write_L:
                for (size_t c = n_cols; c > 1; --c) {
                    FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
                    for (size_t r = 0; r < n_rows; ++r) {
                        FLAMES_PRAGMA(LOOP_FLATTEN)
                        if (c <= i + 2 && r + c <= i + begin_shift + 2 && r <= i) { tmp_L[r][c - 1] = tmp_L[r][c - 2]; }
                    }
                }
            }
        };
        // systolic array passes data down (data from the right matrix)
        auto write_R = [&](size_t i) {
            if (i + 1 != n_rows + comm + n_cols - 2 - begin_shift - end_shift) {
            write_R:
                for (size_t r = n_rows; r > 1; --r) {
                    FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
                    for (size_t c = 0; c < n_cols; ++c) {
                        FLAMES_PRAGMA(LOOP_FLATTEN)
                        if (r <= i + 2 && c + r <= i + begin_shift + 2 && c <= i) { tmp_R[r - 1][c] = tmp_R[r - 2][c]; }
                    }
                }
            }
        };
        // systolic array passes data right (data from the left matrix)
        auto set_assign_ctl = [&](size_t i) {
            FLAMES_PRAGMA(LATENCY max = 0)
        set_assign_ctl:
            for (size_t r = 0; r < n_rows; ++r) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SCALAR_TIMES_UNROLL_FACTOR)
                size_t c = i - r; // note this is unsigned so there can be overflow
                if (c < n_cols) { use_assign[r * n_cols + c] = false; }
            }
        };
        std::integral_constant<int, comm> _comm_foo = {};
    SYSTOLIC_ARRAY_MAT_MUL:
        for (size_t i = 0; i < n_rows + comm + n_cols - 2 - begin_shift - end_shift; ++i) {
            FLAMES_PRAGMA(PIPELINE)
            // std::cout << "ITER " << i << "\n";
            // read
            _sa_read_first_col_L(i, tmp_L, mat_L, begin_shift, _comm_foo, T1(0));
            _sa_read_first_row_R(i, tmp_R, mat_R, begin_shift, _comm_foo, T2(0));
            // multiply
            _sa_multiply(tmp_L, tmp_R, use_assign);
            set_assign_ctl(i);
            // write
            write_L(i);
            write_R(i);
        }
        return *this;
    }
 
  public: // original private
    T _data[type == MatType::NORMAL     ? n_rows * n_cols
            : type == MatType::DIAGONAL ? n_rows
            : type == MatType::SCALAR   ? 1
            : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
            : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
            : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                        : (1 + n_rows) * n_rows / 2];
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatView {
  public:
    MatView(const Mat<T, n_rows, n_cols, type>& m) : _data(m.rawDataPtr()) {}
    MatView(Mat<T, n_rows, n_cols, type>& m) : _data(m.rawDataPtr()) {}
 
    MatView(const T* const ptr) : _data(ptr) {}
 
    MatView(const MatView& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    MatView& operator=(const Mat<T, n_rows, n_cols, type>& m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
        return *this;
    }
 
    template <typename M>
    void assign(M m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
    }
 
    T operator()(size_t r, size_t c) const {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return _data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 2 * r - 1];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r * 2 - 1];
            else if (r > c) return -_data[(2 * n_cols + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
            return T(0);
        }
    }
 
    T operator[](size_t index) const {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "[index] should be in range in MatView");
        return _data[index];
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    MatView& col(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t c) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        static_assert(size() == rows_, "Element number should be rows_ in Mat::col(mat, index).");
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat(i, c);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    void col(size_t c, const M<T2, rows_, cols_, type2, _unused...>& mat) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        assert(mat.size() == n_rows && "Element number should be n_rows in Mat::col(index, mat).");
        for (int i = 0; i != mat.size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            (*this)(i, c) = mat[i];
        }
    }
 
    Mat<T, n_rows, 1, MatType::NORMAL> col(size_t c) const {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        Mat<T, n_rows, 1, MatType::NORMAL> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat(i, 0) = (*this)(i, c);
        }
        return mat;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    MatView& add(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        // return this->sub(*this, mat_R);
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            _data[i] += mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    MatView& sub(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        // return this->sub(*this, mat_R);
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            _data[i] -= mat_R[i];
        }
        return *this;
    }
 
    MatViewT<T, n_cols, n_rows, type> t_() const { return _data; }
 
    template <typename Tp = T>
    Tp power() const {
        Tp p = 0;
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_POWER_UNROLL_FACTOR)
            p += static_cast<Tp>(_data[i] * _data[i]);
        }
        return p;
    }
 
    template <typename Tp = T>
    Tp abssum() const {
        Tp p = 0;
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_POWER_UNROLL_FACTOR)
            auto d = _data[i];
            if (d > 0) p += static_cast<Tp>(d);
        }
        return p;
    }
 
    operator Mat<T, n_rows, n_cols, type>() const {
        FLAMES_PRAGMA(INLINE);
        return Mat<T, n_rows, n_cols, type>(const_cast<const T*>(_data), InitAfterwards::NONE);
    }
 
    Mat<T, n_rows, n_cols, type> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, n_rows, n_cols, type>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
    //   public: // original private
  public:
    const T* const _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatRef {
  public:
    MatRef(Mat<T, n_rows, n_cols, type>& m) : _data(m.rawDataPtr()) {}
 
    MatRef(const T* const ptr) : _data(ptr) {}
 
    MatRef(const MatRef& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    MatRef& operator=(const Mat<T, n_rows, n_cols, type>& m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
        return *this;
    }
 
    template <typename M>
    void assign(M m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
    }
 
    T operator()(size_t r, size_t c) const {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return _data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 2 * r - 1];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r * 2 - 1];
            else if (r > c) return -_data[(2 * n_cols + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
            return T(0);
        }
    }
 
    T& operator()(size_t r, size_t c) {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else assert(!"This element cannot be modified (DIAGONAL).");
        } else if (type == MatType::SCALAR) {
            assert(!"This element cannot be modified (SCALAR).");
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else assert(!"This element cannot be modified (UPPER).");
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else assert(!"This element cannot be modified (LOWER).");
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else assert(!"This element cannot be modified (SUPPER).");
        } else if (type == MatType::SLOWER) {
            if (r > c) return _data[(1 + r) * r / 2 + c - r];
            else assert(!"This element cannot be modified (SLOWER).");
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * n_cols + 1 - r) * r / 2 + c - 1 - 2 * r];
            else if (r > c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - 1 - 2 * c];
 
            // ATTENTION  This part needs to be perfected , missing a minus sign.
            // Because a minus sign will result in a error about reference.
 
            else assert(!"This element cannot be modified (ASYM).");
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        // Just to make the compiler happy.
        return _data[0];
    }
 
    T operator[](size_t index) const {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "[index] should be in range in MatView");
        return _data[index];
    }
 
    T& operator[](size_t index) {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "[index] should be in range in MatView");
        return _data[index];
    }
 
    void setValue(T val) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_SET_VALUE_UNROLL_FACTOR)
            _data[i] = val;
        }
    }
 
    void setZero() { setValue(static_cast<T>(0)); }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    MatRef& col(const M<T2, rows_, cols_, type2, _unused...>& mat, size_t c) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        static_assert(size() == rows_, "Element number should be rows_ in Mat::col(mat, index).");
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = mat(i, c);
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2, size_t rows_, size_t cols_>
    void col(size_t c, const M<T2, rows_, cols_, type2, _unused...>& mat) {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        assert(mat.size() == n_rows && "Element number should be n_rows in Mat::col(index, mat).");
        for (int i = 0; i != mat.size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            (*this)(i, c) = mat[i];
        }
    }
 
    Mat<T, n_rows, 1, MatType::NORMAL> col(size_t c) const {
        assert(c < n_cols && "Take the specific col by index requires 'The index should be smaller than the number of "
                             "the matrix's columns.'.");
        Mat<T, n_rows, 1, MatType::NORMAL> mat;
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat(i, 0) = (*this)(i, c);
        }
        return mat;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    MatRef& add(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        // return this->sub(*this, mat_R);
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            _data[i] += mat_R[i];
        }
        return *this;
    }
 
    template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T2,
              MatType type2>
    MatRef& sub(const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
        FLAMES_PRAGMA(INLINE)
        // return this->sub(*this, mat_R);
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_MINUS_UNROLL_FACTOR)
            _data[i] -= mat_R[i];
        }
        return *this;
    }
 
    MatViewT<T, n_cols, n_rows, type> t_() const { return _data; }
 
    template <typename Tp = T>
    Tp power() const {
        Tp p = 0;
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_POWER_UNROLL_FACTOR)
            p += static_cast<Tp>(_data[i] * _data[i]);
        }
        return p;
    }
 
    template <typename Tp = T>
    Tp abssum() const {
        Tp p = 0;
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_POWER_UNROLL_FACTOR)
            auto d = _data[i];
            if (d > 0) p += static_cast<Tp>(d);
        }
        return p;
    }
 
    operator Mat<T, n_rows, n_cols, type>() const {
        FLAMES_PRAGMA(INLINE);
        return Mat<T, n_rows, n_cols, type>(const_cast<const T*>(_data), InitAfterwards::NONE);
    }
 
    Mat<T, n_rows, n_cols, type> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, n_rows, n_cols, type>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
    //   public: // original private
  public:
    T* const _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatViewOpp {
  public:
    MatViewOpp(const Mat<T, n_cols, n_rows, type>& m) : _data(m.rawDataPtr()) {}
 
    MatViewOpp(const MatViewOpp& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    T operator()(size_t r, size_t c) const {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return -_data[r * n_cols + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return -_data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return -_data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return -_data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return -_data[(1 + r) * r / 2 + c];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return -_data[(2 * n_cols + 1 - r) * r / 2 + c - 2 * r - 1];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r >= c) return -_data[(1 + r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return -_data[(2 * n_cols + 1 - r) * r / 2 + c - r];
            else return -_data[(2 * n_cols + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return -_data[(2 * n_cols + 1 - r) * r / 2 + c - r * 2 - 1];
            else if (r > c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const {
        FLAMES_PRAGMA(INLINE)
        assert(index < size() && "[index] should be in range in MatViewOpp");
        return -_data[index];
    }
 
    operator Mat<T, n_rows, n_cols, type>() const {
        FLAMES_PRAGMA(INLINE);
        return Mat<T, n_rows, n_cols, type>(_data, InitAfterwards::OPP);
    }
 
    Mat<T, n_rows, n_cols, type> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, n_rows, n_cols, type>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
class MatViewT {
  public:
    MatViewT(const Mat<T, n_cols, n_rows, tType(type)>& m) : _data(m.rawDataPtr()) {}
    MatViewT(Mat<T, n_cols, n_rows, tType(type)>& m) : _data(m.rawDataPtr()) {}
 
    MatViewT(const MatViewT& m) : _data(m._data) {}
 
    // MatViewT(T* const ptr) : _data(ptr) {}
 
    MatViewT(T* ptr) : _data(ptr) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    T operator()(size_t r, size_t c) const {
        FLAMES_PRAGMA(INLINE)
        assert(r < n_rows && "Matrix row index should be within range");
        assert(c < n_cols && "Matrix col index should be within range");
        if (type == MatType::NORMAL) {
            return _data[c * n_rows + r];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return _data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + c) * c / 2 + r];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - 2 * c - 1];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r >= c) return _data[(1 + c) * c / 2 + r - c];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - c];
            else return _data[(2 * n_cols + 1 - r) * r / 2 + c - r];
        } else if (type == MatType::ASYM) {
            if (r < c) return -_data[(2 * n_cols + 1 - r) * r / 2 + c - r * 2 - 1];
            else if (r > c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const {
        FLAMES_PRAGMA(INLINE)
        size_t r, c; // of the original matrix
        if (type == MatType::DIAGONAL) {
            r = c = index;
        } else if (type == MatType::SCALAR) {
            r = c = index;
        } else if (type == MatType::NORMAL) {
            r = index / n_cols;
            c = index % n_cols;
        } else if (type == MatType::UPPER) {
            r = upperRow(index, n_cols);
            c = r + index - (2 * n_cols + 1 - r) * r / 2;
        } else if (type == MatType::LOWER) {
            r = lowerRow(index, n_cols);
            c = index - (r + 1) * r / 2;
        } else if (type == MatType::SUPPER) {
            r = supperRow(index, n_cols);
            c = 2 * r + 1 + index - c - (2 * n_cols + 1 - r) * r / 2;
        } else if (type == MatType::SLOWER) {
            r = slowerRow(index, n_cols);
            c = index - (1 + r) * r / 2 + r;
        } else if (type == MatType::SYM) {
            r = upperRow(index, n_cols);
            c = r + index - (2 * n_cols + 1 - r) * r / 2;
        } else if (type == MatType::ASYM) {
            r = supperRow(index, n_cols);
            c = 2 * r + 1 + index - c - (2 * n_cols + 1 - r) * r / 2;
        }
        return (*this)(r, c);
    }
 
    operator Mat<T, n_rows, n_cols, type>() const {
        FLAMES_PRAGMA(INLINE);
        return Mat<T, n_rows, n_cols, type>(const_cast<const T*>(_data), InitAfterwards::TR);
    }
 
    Mat<T, n_rows, n_cols, type> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, n_rows, n_cols, type>>(*this);
    }
 
    //   public: // original private
  public:
    T* const _data;
};
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent>
class MatViewDiagMat {
  public:
    MatViewDiagMat(const Mat<T, N, N, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(type == MatType::DIAGONAL && N == N_, "DiagMat is and comes from a square matrix.");
    }
 
    MatViewDiagMat(const MatViewDiagMat& m) : _data(m._data) {}
 
    Mat<T, N, N, MatType::DIAGONAL> inv() const {
        Mat<T, N, N, MatType::DIAGONAL> mat;
    MATVIEWDIAGMAT_INV:
        for (size_t i = 0; i != N; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = static_cast<T>(1) / (*this)[i];
        }
        return mat;
    }
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? N * N
               : type == MatType::DIAGONAL ? N
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (N - 1) * N / 2
               : type == MatType::SLOWER   ? (N - 1) * N / 2
               : type == MatType::ASYM     ? (N - 1) * N / 2
                                           : (1 + N) * N / 2;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        if (r != c) return T(0);
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * N + c];
        } else if (p_type == MatType::DIAGONAL) {
            return _data[r];
        } else if (p_type == MatType::SCALAR) {
            return _data[0];
        } else if (p_type == MatType::UPPER) {
            return _data[(2 * N + 1 - r) * r / 2];
        } else if (p_type == MatType::LOWER) {
            return _data[(1 + r) * r / 2 + r];
        } else if (p_type == MatType::SUPPER) {
            return T(0);
        } else if (p_type == MatType::SLOWER) {
            return T(0);
        } else if (p_type == MatType::SYM) {
            return _data[(2 * N + 1 - r) * r / 2];
        } else if (p_type == MatType::ASYM) {
            return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const { return (*this)(index, index); }
 
    operator Mat<T, N, N, MatType::DIAGONAL>() const {
        if (pType() == MatType::DIAGONAL) {
            return this->_data;
        } else {
            Mat<T, N, N, MatType::DIAGONAL> mat;
        MAT_COPY_DIAG:
            for (size_t i = 0; i != N; ++i) {
                FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
                mat[i] = (*this)[i];
            }
            return mat;
        }
    }
 
    Mat<T, N, N, MatType::DIAGONAL> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, N, N, MatType::DIAGONAL>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <typename T, size_t N, size_t n_cols, MatType type, typename type_parent>
class MatViewDiagVec {
  public:
    MatViewDiagVec(const Mat<T, N, N, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(n_cols == 1, "DiagVec is a column vector.");
    }
 
    MatViewDiagVec(const MatViewDiagVec& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? N * N
               : type == MatType::DIAGONAL ? N
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (N - 1) * N / 2
               : type == MatType::SLOWER   ? (N - 1) * N / 2
               : type == MatType::ASYM     ? (N - 1) * N / 2
                                           : (1 + N) * N / 2;
    }
 
    Vec<T, N> inv() const {
        Vec<T, N> mat;
    MATVIEWDIAGVEC_INV:
        for (size_t i = 0; i != N; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = static_cast<T>(1) / (*this)[i];
        }
        return mat;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(c == 0 && "Column vector's column index should always be 0.");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * N + r];
        } else if (p_type == MatType::DIAGONAL) {
            return _data[r];
        } else if (p_type == MatType::SCALAR) {
            return _data[0];
        } else if (p_type == MatType::UPPER) {
            return _data[(2 * N + 1 - r) * r / 2];
        } else if (p_type == MatType::LOWER) {
            return _data[(1 + r) * r / 2 + r];
        } else if (p_type == MatType::SUPPER) {
            return T(0);
        } else if (p_type == MatType::SLOWER) {
            return T(0);
        } else if (p_type == MatType::SYM) {
            return _data[(2 * N + 1 - r) * r / 2];
        } else if (p_type == MatType::ASYM) {
            return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const { return (*this)(index, 0); }
 
    operator Vec<T, N>() const {
        Vec<T, N> mat;
    MAT_COPY_DIAG:
        for (size_t i = 0; i != N; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    Vec<T, N> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, N>>(*this);
    }
 
    Vec<T, N> asVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, N>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <typename T, size_t n_rows, size_t N, MatType type, typename type_parent>
class MatViewDiagRowVec {
  public:
    MatViewDiagRowVec(const Mat<T, N, N, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(n_rows == 1, "DiagRowVec is a row vector.");
    }
 
    MatViewDiagRowVec(const MatViewDiagRowVec& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? N * N
               : type == MatType::DIAGONAL ? N
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (N - 1) * N / 2
               : type == MatType::SLOWER   ? (N - 1) * N / 2
               : type == MatType::ASYM     ? (N - 1) * N / 2
                                           : (1 + N) * N / 2;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(r == 0 && "Row vector's row index should always be 0.");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[c * N + c];
        } else if (p_type == MatType::DIAGONAL) {
            return _data[c];
        } else if (p_type == MatType::SCALAR) {
            return _data[0];
        } else if (p_type == MatType::UPPER) {
            return _data[(2 * N + 1 - c) * c / 2];
        } else if (p_type == MatType::LOWER) {
            return _data[(1 + c) * c / 2 + c];
        } else if (p_type == MatType::SUPPER) {
            return T(0);
        } else if (p_type == MatType::SLOWER) {
            return T(0);
        } else if (p_type == MatType::SYM) {
            return _data[(2 * N + 1 - c) * c / 2];
        } else if (p_type == MatType::ASYM) {
            return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const { return (*this)(0, index); }
 
    operator RowVec<T, N>() const {
        RowVec<T, N> mat;
    MAT_COPY_DIAG:
        for (size_t i = 0; i != N; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    RowVec<T, N> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<RowVec<T, N>>(*this);
    }
 
    RowVec<T, N> asRowVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<RowVec<T, N>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <typename T, size_t N, size_t N_, MatType type, typename type_parent>
class MatViewOffDiag {
  public:
    MatViewOffDiag(const Mat<T, N, N, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(type == MatType::NORMAL && N == N_, "OffDiag is and comes from a square and normal matrix.");
    }
 
    MatViewOffDiag(const MatViewOffDiag& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? N * N
               : type == MatType::DIAGONAL ? N
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (N - 1) * N / 2
               : type == MatType::SLOWER   ? (N - 1) * N / 2
               : type == MatType::ASYM     ? (N - 1) * N / 2
                                           : (1 + N) * N / 2;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        if (r == c) return T(0);
        constexpr MatType p_type = pType();
        if (type == MatType::NORMAL) {
            return _data[r * N + c];
        } else if (type == MatType::DIAGONAL) {
            if (r == c) return _data[r];
            else return T(0);
        } else if (type == MatType::SCALAR) {
            if (r == c) return _data[0];
            else return T(0);
        } else if (type == MatType::UPPER) {
            if (r <= c) return _data[(2 * N + 1 - r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::LOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c];
            else return T(0);
        } else if (type == MatType::SUPPER) {
            if (r < c) return _data[(2 * N + 1 - r) * r / 2 + c - 2 * r - 1];
            else return T(0);
        } else if (type == MatType::SLOWER) {
            if (r >= c) return _data[(1 + r) * r / 2 + c - r];
            else return T(0);
        } else if (type == MatType::SYM) {
            if (r <= c) return _data[(2 * N + 1 - r) * r / 2 + c - r];
            else return _data[(2 * N + 1 - c) * c / 2 + r - c];
        } else if (type == MatType::ASYM) {
            if (r < c) return _data[(2 * N + 1 - r) * r / 2 + c - r * 2 - 1];
            else if (r > c) return -_data[(2 * N + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
            return T(0);
        }
    }
 
    T operator[](size_t index) const {
        if (index % (N + 1) == 0) return T(0);
        else return this->_data[index];
    }
 
    operator Mat<T, N, N, MatType::NORMAL>() const {
        Mat<T, N, N, MatType::NORMAL> mat;
    MAT_COPY_OFFDIAG:
        for (size_t i = 0; i != N * N; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            if (i % (N + 1) == 0) mat[i] = 0;
            else mat[i] = this->_data[i];
        }
        return mat;
    }
 
    Mat<T, N, N, MatType::NORMAL> asMat() const {
        FLAMES_PRAGMA(INLINE)
        return static_cast<Mat<T, N, N, MatType::NORMAL>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent>
class MatViewCol {
  public:
    MatViewCol(const Mat<T, n_rows, n_cols, matType<type_parent>()>& m, size_t index) : _data(m.rawDataPtr() + index) {
        static_assert(type == MatType::NORMAL, "We only support limited matType.");
        assert(index < n_cols && "Take the specific col by index requires 'The index should be smaller than the number "
                                 "of the matrix's cols.'");
    }
 
    MatViewCol(const MatViewCol& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept { return n_rows; }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(c == 0 && "Column vector's column index should always be 0.");
        assert(r < n_rows && "Matrix row index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * n_cols];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T operator[](size_t index) const { return (*this)(index, 0); }
 
    operator Vec<T, n_rows>() const {
        Vec<T, n_rows> mat;
    MAT_COPY_COL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    Vec<T, n_rows> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, n_rows>>(*this);
    }
 
    Vec<T, n_rows> asVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, n_rows>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
  public: // original private
    const T* const _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent>
class MatViewRow {
  public:
    MatViewRow(const Mat<T, n_rows, n_cols, matType<type_parent>()>& m, size_t index)
        : _data(m.rawDataPtr() + index * n_cols) {
        static_assert(type == MatType::NORMAL, "We only support limited matType.");
        assert(index < n_rows && "Take the specific row by index requires 'The index should be smaller than the number "
                                 "of the matrix's rows.'");
    }
 
    MatViewRow(const MatViewRow& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept { return n_cols; }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(r == 0 && "Row vector's row index should always be 0.");
        assert(c < n_cols && "Matrix column index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[c];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T operator[](size_t index) const { return (*this)(0, index); }
 
    operator RowVec<T, n_rows>() const {
        RowVec<T, n_cols> mat;
    MAT_COPY_ROW:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    RowVec<T, n_cols> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<RowVec<T, n_cols>>(*this);
    }
 
    Vec<T, n_rows> asRowVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, n_cols>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
  public: // original private
    const T* const _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent>
class MatRefCol {
  public:
    MatRefCol(Mat<T, n_rows, n_cols, matType<type_parent>()>& m, size_t index) : _data(m.rawDataPtr() + index) {
        static_assert(type == MatType::NORMAL, "We only support limited matType.");
        assert(index < n_cols && "Take the specific col by index requires 'The index should be smaller than the number "
                                 "of the matrix's cols.'");
    }
 
    MatRefCol(const MatRefCol& m) : _data(m._data) {}
 
    template <typename T_, size_t n_rows_, size_t n_cols_, MatType type_>
    MatRefCol& operator=(const Mat<T_, n_rows_, n_cols_, type_>& m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i * n_rows] = m[i];
        }
        return *this;
    }
 
    template <typename M>
    void assign(M m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i * n_rows] = m[i];
        }
    }
 
    inline static constexpr size_t size() noexcept { return n_rows; }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(c == 0 && "Column vector's column index should always be 0.");
        assert(r < n_rows && "Matrix row index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * n_cols];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T& operator()(size_t r, size_t c) {
        assert(c == 0 && "Column vector's column index should always be 0.");
        assert(r < n_rows && "Matrix row index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * n_cols];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T operator[](size_t index) const { return (*this)(index, 0); }
 
    T& operator[](size_t index) { return (*this)(index, 0); }
 
    operator Vec<T, n_rows>() const {
        Vec<T, n_rows> mat;
    MAT_COPY_COL:
        for (size_t i = 0; i != n_rows; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    Vec<T, n_rows> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, n_rows>>(*this);
    }
 
    Vec<T, n_rows> asVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Vec<T, n_rows>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
  public: // original private
    T* const _data;
};
 
template <typename T, size_t n_rows, size_t n_cols, MatType type, typename type_parent>
class MatRefRow {
  public:
    MatRefRow(Mat<T, n_rows, n_cols, matType<type_parent>()>& m, size_t index)
        : _data(m.rawDataPtr() + index * n_cols) {
        static_assert(type == MatType::NORMAL, "We only support limited matType.");
        assert(index < n_rows && "Take the specific row by index requires 'The index should be smaller than the number "
                                 "of the matrix's rows.'");
    }
 
    MatRefRow(const MatRefRow& m) : _data(m._data) {}
 
    template <typename T_, size_t n_rows_, size_t n_cols_, MatType type_>
    MatRefRow& operator=(const Mat<T_, n_rows_, n_cols_, type_>& m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
        return *this;
    }
 
    template <typename M>
    void assign(M m) {
        for (size_t i = 0; i != size(); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            _data[i] = m[i];
        }
    }
 
    inline static constexpr size_t size() noexcept { return n_cols; }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(r == 0 && "Row vector's row index should always be 0.");
        assert(c < n_cols && "Matrix column index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[c];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T& operator()(size_t r, size_t c) {
        assert(r == 0 && "Row vector's row index should always be 0.");
        assert(c < n_cols && "Matrix column index should be within range");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[c];
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
        return _data[0];
    }
 
    T operator[](size_t index) const { return (*this)(0, index); }
 
    T& operator[](size_t index) { return (*this)(0, index); }
 
    operator RowVec<T, n_cols>() const {
        RowVec<T, n_cols> mat;
    MAT_COPY_ROW:
        for (size_t i = 0; i != n_cols; ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    RowVec<T, n_cols> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<RowVec<T, n_cols>>(*this);
    }
 
    RowVec<T, n_cols> asVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<RowVec<T, n_cols>>(*this);
    }
 
    void print(const std::string& str = "", std::ostream& os = std::cout) const { this->asMat().print(str, os); }
 
  public: // original private
    T* const _data;
};
 
template <size_t first_col, size_t last_col, typename T, size_t n_rows, size_t n_cols, MatType type,
          typename type_parent>
class MatViewCols {
  public:
    MatViewCols(const Mat<T, n_rows, n_cols, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(last_col < n_cols, "Take the successive cols by indexes requires 'The indexes should be smaller "
                                         "than the number of the matrix's cols.'");
        static_assert(first_col > 0, "Take the specific col by index requires 'The indexes can't be smaller than 0.'");
        static_assert(first_col <= last_col, "The first index should be smaller than the second one.");
    }
 
    MatViewCols(const MatViewCols& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(c < (last_col - first_col + 1) &&
               "The col index must be small than the number of the successive columns .");
        assert(r > 0 && "The row index can't be smaller than 0.");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[r * n_cols + c + first_col];
        } else if (p_type == MatType::DIAGONAL) {
            if (r == (c + first_col)) return _data[r];
            else return T(0);
        } else if (p_type == MatType::SCALAR) {
            if (r == (c + first_col)) return _data[0];
            else return T(0);
        } else if (p_type == MatType::UPPER) {
            if (r <= (c + first_col)) return _data[(2 * n_cols + 1 - r) * r / 2 + c + first_col - r];
            else return T(0);
        } else if (p_type == MatType::LOWER) {
            if (r >= (c + first_col)) return _data[(1 + r) * r / 2 + c + first_col - r];
            else return T(0);
        } else if (p_type == MatType::SUPPER) {
            if (r < (c + first_col)) return _data[(2 * n_cols + 1 - r) * r / 2 + c + first_col - 2 * r - 1];
            else return T(0);
        } else if (p_type == MatType::SLOWER) {
            if (r >= (c + first_col)) return _data[(1 + r) * r / 2 + c + first_col - r];
            else return T(0);
        } else if (p_type == MatType::SYM) {
            if (r <= (c + first_col)) return _data[(2 * n_cols + 1 - r) * r / 2 + c + first_col - r];
            else return _data[(2 * n_cols + 1 - (c + first_col)) * (c + first_col) / 2 + r - (c + first_col)];
        } else if (p_type == MatType::ASYM) {
            if (r < (c + first_col)) return -_data[(2 * n_cols + 1 - r) * r / 2 + (c + first_col) - r * 2 - 1];
            else if (r > (c + first_col))
                return _data[(2 * n_cols + 1 - (c + first_col)) * (c + first_col) / 2 + r - (c + first_col) * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const {
        return (*this)(index / (last_col - first_col + 1), index % (last_col - first_col + 1));
    }
 
    operator Mat<T, n_rows, last_col - first_col + 1, MatType::NORMAL>() const {
        Mat<T, n_rows, last_col - first_col + 1, MatType::NORMAL> mat;
    MAT_COPY_COLS:
        for (size_t i = 0; i != n_rows * (last_col - first_col + 1); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    Mat<T, n_rows, last_col - first_col + 1, MatType::NORMAL> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, n_rows, last_col - first_col + 1, MatType::NORMAL>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <size_t first_row, size_t last_row, typename T, size_t n_rows, size_t n_cols, MatType type,
          typename type_parent>
class MatViewRows {
  public:
    MatViewRows(const Mat<T, n_cols, n_rows, matType<type_parent>()>& m) : _data(m.rawDataPtr()) {
        static_assert(last_row < n_rows, "Take the successive rows by indexes requires 'The indexes should be smaller "
                                         "than the number of the matrix's rows.'");
        static_assert(first_row > 0, "Take the specific row by index requires 'The indexes can't be smaller than 0.'");
        static_assert(first_row <= last_row, "The first index should be smaller than the second one.");
    }
 
    MatViewRows(const MatViewRows& m) : _data(m._data) {}
 
    inline static constexpr size_t size() noexcept {
        return type == MatType::NORMAL     ? n_rows * n_cols
               : type == MatType::DIAGONAL ? n_rows
               : type == MatType::SCALAR   ? 1
               : type == MatType::SUPPER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::SLOWER   ? (n_rows - 1) * n_rows / 2
               : type == MatType::ASYM     ? (n_rows - 1) * n_rows / 2
                                           : (1 + n_rows) * n_rows / 2;
    }
 
    inline static constexpr MatType pType() noexcept { return matType<type_parent>(); }
 
    T operator()(size_t r, size_t c) const {
        assert(r < last_row - first_row && "The row index must be small than the number of the successive rows .");
        assert(c > 0 && "The row index can't be smaller than 0.");
        constexpr MatType p_type = pType();
        if (p_type == MatType::NORMAL) {
            return _data[(r + first_row) * n_cols + c];
        } else if (p_type == MatType::DIAGONAL) {
            if ((r + first_row) == c) return _data[r];
            else return T(0);
        } else if (p_type == MatType::SCALAR) {
            if ((r + first_row) == c) return _data[0];
            else return T(0);
        } else if (p_type == MatType::UPPER) {
            if ((r + first_row) <= c)
                return _data[(2 * n_cols + 1 - (r + first_row)) * (r + first_row) / 2 + c - (r + first_row)];
            else return T(0);
        } else if (p_type == MatType::LOWER) {
            if ((r + first_row) >= c) return _data[(1 + (r + first_row)) * (r + first_row) / 2 + c];
            else return T(0);
        } else if (p_type == MatType::SUPPER) {
            if ((r + first_row) < c)
                return _data[(2 * n_cols + 1 - (r + first_row)) * (r + first_row) / 2 + c - 2 * (r + first_row) - 1];
            else return T(0);
        } else if (p_type == MatType::SLOWER) {
            if ((r + first_row) >= c) return _data[(1 + (r + first_row)) * (r + first_row) / 2 + c - (r + first_row)];
            else return T(0);
        } else if (p_type == MatType::SYM) {
            if ((r + first_row) <= c)
                return _data[(2 * n_cols + 1 - (r + first_row)) * (r + first_row) / 2 + c - (r + first_row)];
            else return _data[(2 * n_cols + 1 - c) * c / 2 + (r + first_row) - c];
        } else if (p_type == MatType::ASYM) {
            if ((r + first_row) < c)
                return -_data[(2 * n_cols + 1 - (r + first_row)) * (r + first_row) / 2 + c - (r + first_row) * 2 - 1];
            else if ((r + first_row) > c) return _data[(2 * n_cols + 1 - c) * c / 2 + r - c * 2 - 1];
            else return T(0);
        } else {
            // Normally it is impossible to reach here.
            assert(!"Impossible! Unknown MatType!");
        }
    }
 
    T operator[](size_t index) const { return (*this)(index / n_cols, index % n_cols); }
 
    operator Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL>() const {
        Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL> mat;
    MAT_COPY_ROWS:
        for (size_t i = 0; i != n_rows * (last_row - first_row + 1); ++i) {
            FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_COPY_UNROLL_FACTOR)
            mat[i] = (*this)[i];
        }
        return mat;
    }
 
    Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL> asMat() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL>>(*this);
    }
 
    Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL> asVec() const {
        FLAMES_PRAGMA(INLINE);
        return static_cast<Mat<T, last_row - first_row + 1, n_cols, MatType::NORMAL>>(*this);
    }
 
  public: // original private
    const T* _data;
};
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type1, MatType type2>
static inline Mat<T1, n_rows, n_cols, sumType(type1, type2)>
operator+(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
          const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T1, n_rows, n_cols, type1> mat;
    return mat.add(mat_L, mat_R);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T1, typename T2,
          size_t n_rows, size_t n_cols, MatType type1, MatType type2>
static inline Mat<T1, n_rows, n_cols, type1>& operator+=(Mat<T1, n_rows, n_cols, type1>& mat_L,
                                                         const M<T2, n_rows, n_cols, type2, _unused...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    return mat_L.add(mat_R);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type1, MatType type2>
static inline Mat<T1, n_rows, n_cols, sumType(type1, type2)>
operator-(const M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
          const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T1, n_rows, n_cols, type1> mat;
    return mat.sub(mat_L, mat_R);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type1, MatType type2>
static inline M1<T1, n_rows, n_cols, type1>& operator-=(M1<T1, n_rows, n_cols, type1, _unused1...>& mat_L,
                                                        const M2<T2, n_rows, n_cols, type2, _unused2...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    return mat_L.sub(mat_R);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T1, typename T2,
          size_t n_rows, size_t n_cols, MatType type1, MatType type2,
          std::enable_if_t<(std::is_same<T1, bool>::value), bool> = true>
static inline Mat<T1, n_rows, n_cols, mulType(type1, type2, n_rows, n_cols, n_cols)>
operator*=(Mat<T1, n_rows, n_cols, type1>& mat, const M<T2, n_cols, n_cols, type2, _unused...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T2, n_rows, n_cols, mulType(type1, type2, n_rows, n_cols, n_cols)> tmp;
    tmp.mul(mat, mat_R);
    return mat = tmp;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T1, typename T2,
          size_t n_rows, size_t n_cols, MatType type1, MatType type2,
          std::enable_if_t<!(std::is_same<T1, bool>::value), bool> = true>
static inline Mat<T1, n_rows, n_cols, mulType(type1, type2, n_rows, n_cols, n_cols)>
operator*=(Mat<T1, n_rows, n_cols, type1>& mat, const M<T2, n_cols, n_cols, type2, _unused...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T1, n_rows, n_cols, mulType(type1, type2, n_rows, n_cols, n_cols)> tmp;
    tmp.mul(mat, mat_R);
    return mat = tmp;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T,
          typename ScalarT, size_t n_rows, size_t n_cols, MatType type,
          std::enable_if_t<std::is_arithmetic<std::remove_reference_t<ScalarT>>::value, bool> = true>
static inline Mat<T, n_rows, n_cols, type>& operator*=(const M<T, n_rows, n_cols, type, _unused...>& mat, ScalarT s) {
    FLAMES_PRAGMA(INLINE)
    return mat.mul(s);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T,
          typename ScalarT, size_t n_rows, size_t n_cols, MatType type,
          std::enable_if_t<std::is_arithmetic<std::remove_reference_t<ScalarT>>::value, bool> = true>
static inline Mat<T, n_rows, n_cols, type> operator*(const M<T, n_rows, n_cols, type, _unused...>& mat_L, ScalarT s) {
    FLAMES_PRAGMA(INLINE)
    Mat<T, n_rows, n_cols, type> mat;
    return mat.mul(mat_L, s);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T,
          size_t n_rows, size_t n_cols, MatType type, int AP_W, int AP_I, ap_q_mode AP_Q, ap_o_mode AP_O, int AP_N>
static inline Mat<T, n_rows, n_cols, type> operator*(const M<T, n_rows, n_cols, type, _unused...>& mat_L,
                                                     ap_fixed<AP_W, AP_I, AP_Q, AP_O, AP_N> s) {
    FLAMES_PRAGMA(INLINE)
    Mat<T, n_rows, n_cols, type> mat;
    return mat.mul(mat_L, s);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T,
          typename ScalarT, size_t n_rows, size_t n_cols, MatType type,
          std::enable_if_t<std::is_arithmetic<std::remove_reference_t<ScalarT>>::value, bool> = true>
static inline Mat<T, n_rows, n_cols, type> operator*(ScalarT s, const M<T, n_rows, n_cols, type, _unused...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T, n_rows, n_cols, type> mat;
    return mat.mul(mat_R, s);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M, typename... _unused, typename T,
          size_t n_rows, size_t n_cols, MatType type, int AP_W, int AP_I, ap_q_mode AP_Q, ap_o_mode AP_O, int AP_N>
static inline Mat<T, n_rows, n_cols, type> operator*(ap_fixed<AP_W, AP_I, AP_Q, AP_O, AP_N> s,
                                                     const M<T, n_rows, n_cols, type, _unused...>& mat_R) {
    FLAMES_PRAGMA(INLINE)
    Mat<T, n_rows, n_cols, type> mat;
    return mat.mul(mat_R, s);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t comm, size_t n_cols, MatType type1, MatType type2,
          std::enable_if_t<(std::is_same<T1, bool>::value), bool> = true>
static inline Mat<T2, n_rows, n_cols, mulType(type1, type2, n_rows, comm, n_cols)>
operator*(const M1<T1, n_rows, comm, type1, _unused1...>& mat_L,
          const M2<T2, comm, n_cols, type2, _unused2...>& mat_R) {
    Mat<T2, n_rows, n_cols, mulType(type1, type2, n_rows, comm, n_cols)> mat;
    mat.mul(mat_L, mat_R);
    return mat;
    // if "return mat.mul(mat_L, mat_R);" , then there will be a error. But I don't know why.
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t comm, size_t n_cols, MatType type1, MatType type2,
          std::enable_if_t<!(std::is_same<T1, bool>::value), bool> = true>
static inline Mat<T1, n_rows, n_cols, mulType(type1, type2, n_rows, comm, n_cols)>
operator*(const M1<T1, n_rows, comm, type1, _unused1...>& mat_L,
          const M2<T2, comm, n_cols, type2, _unused2...>& mat_R) {
    Mat<T1, n_rows, n_cols, mulType(type1, type2, n_rows, comm, n_cols)> mat;
    mat.mul(mat_L, mat_R);
    return mat;
    // if "return mat.mul(mat_L, mat_R);" , then there will be a error. But I don't know why.
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<T1, n_rows, n_cols, type> operator%(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                        const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<T1, n_rows, n_cols, type> mat;
    return mat.emul(mat_L, mat_R);
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator==(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                           const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_EQUAL:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] == mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator!=(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                           const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_UNEQUAL:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] != mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator>(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                          const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_GREATER:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] > mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator<(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                          const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_LESS:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] < mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator>=(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                           const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_GEQ:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] >= mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<bool, n_rows, n_cols, type> operator<=(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                           const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<bool, n_rows, n_cols, type> mat;
OPERATOR_LEQ:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] <= mat_R[i];
    }
    return mat;
}
 
template <template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t n_rows, size_t n_cols, MatType type>
Mat<T1, n_rows, n_cols, type> mod(const M1<T1, n_rows, n_cols, type, _unused1...>& mat_L,
                                  const M2<T2, n_rows, n_cols, type, _unused2...>& mat_R) {
    Mat<T1, n_rows, n_cols, type> mat;
OPERATOR_LEQ:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_BOOL_OPER_UNROLL_FACTOR)
        mat[i] = mat_L[i] % mat_R[i]; // Operator % Should be defined, otherwise compilation error.
    }
    return mat;
}
 
template <typename Tp = double, template <class, size_t, size_t, MatType, class...> typename M1, typename... _unused1,
          template <class, size_t, size_t, MatType, class...> typename M2, typename... _unused2, typename T1,
          typename T2, size_t L_rows, size_t L_cols, size_t R_rows, size_t R_cols, MatType type,
          std::enable_if_t<L_rows * L_cols == R_rows * R_cols, bool> = true>
Tp innerProd(const M1<T1, L_rows, L_cols, type, _unused1...>& mat_L,
             const M2<T2, R_rows, R_cols, type, _unused2...>& mat_R) {
    assert(mat_L.size() == mat_R.size() && "Dimension should meet for innerProd.");
    Tp result = 0;
INNER_PROD:
    for (size_t i = 0; i != mat_L.size(); ++i) {
        FLAMES_PRAGMA(UNROLL factor = FLAMES_MAT_EMUL_UNROLL_FACTOR)
        result += static_cast<Tp>(mat_L[i] * mat_R[i]);
    }
    return result;
}
 
template <typename T, size_t n_rows, size_t n_cols, MatType type>
static inline std::ostream& operator<<(std::ostream& os, const Mat<T, n_rows, n_cols, type>& mat) {
    mat.print("", os);
    return os;
}
 
} // namespace flames
 
#ifndef FLAMES_PRESERVE_WARNING
#    ifdef __SYNTHESIS__
#        pragma GCC diagnostic pop
#    endif
#endif
 
#ifdef DEFINED_INLINE
#    define INLINE inline
#    undef DEFINED_INLINE
#endif
 
#endif