inline void moves64(board& U, board& R, board& D, board& L) const {
#if defined(__AVX2__) && !defined(PREFER_LUT_MOVES)
    __m256i dst, buf, rbf, rwd, chk;

    // use left for all 4 directions, transpose and mirror first
    u64 x = raw;
    raw_cast<board>(x).transpose64();
    dst = _mm256_set_epi64x(raw, 0, 0, x); // L, 0, 0, U
    buf = _mm256_set_epi64x(0, x, raw, 0); // 0, D, R, 0
    dst = _mm256_or_si256(dst, _mm256_slli_epi16(buf, 12));
    dst = _mm256_or_si256(dst, _mm256_slli_epi16(_mm256_and_si256(buf, _mm256_set1_epi16(0x00f0)), 4));
    dst = _mm256_or_si256(dst, _mm256_srli_epi16(_mm256_and_si256(buf, _mm256_set1_epi16(0x0f00)), 4));
    dst = _mm256_or_si256(dst, _mm256_srli_epi16(buf, 12));

    // slide to left most
    buf = _mm256_and_si256(dst, _mm256_set1_epi16(0x0f00));
    chk = _mm256_and_si256(_mm256_cmpeq_epi16(buf, _mm256_setzero_si256()), _mm256_set1_epi16(0xff00));
    dst = _mm256_or_si256(_mm256_and_si256(chk, _mm256_srli_epi16(dst, 4)), _mm256_andnot_si256(chk, dst));
    buf = _mm256_and_si256(dst, _mm256_set1_epi16(0x00f0));
    chk = _mm256_and_si256(_mm256_cmpeq_epi16(buf, _mm256_setzero_si256()), _mm256_set1_epi16(0xfff0));
    dst = _mm256_or_si256(_mm256_and_si256(chk, _mm256_srli_epi16(dst, 4)), _mm256_andnot_si256(chk, dst));
    buf = _mm256_and_si256(dst, _mm256_set1_epi16(0x000f));
    chk = _mm256_cmpeq_epi16(buf, _mm256_setzero_si256());
    dst = _mm256_or_si256(_mm256_and_si256(chk, _mm256_srli_epi16(dst, 4)), _mm256_andnot_si256(chk, dst));

    // merge same tiles, slide if necessary
    buf = _mm256_srli_epi16(_mm256_add_epi8(dst, _mm256_set1_epi16(0x0010)), 4);
    rbf = _mm256_and_si256(dst, _mm256_set1_epi16(0x000f));
    chk = _mm256_and_si256(_mm256_srli_epi16(dst, 4), _mm256_set1_epi16(0x000f));
    chk = _mm256_andnot_si256(_mm256_cmpeq_epi16(rbf, _mm256_setzero_si256()), _mm256_cmpeq_epi16(rbf, chk));
    dst = _mm256_or_si256(_mm256_and_si256(chk, buf), _mm256_andnot_si256(chk, dst));
    chk = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_and_si256(chk, _mm256_set1_epi16(0x0001)), 0));
    rbf = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_add_epi16(rbf, _mm256_set1_epi16(0x0001)), 0));
    rwd = _mm256_sllv_epi32(chk, rbf);

    buf = _mm256_add_epi8(_mm256_srli_epi16(dst, 4), _mm256_set1_epi16(0x0010));
    rbf = _mm256_and_si256(buf, _mm256_set1_epi16(0x000f));
    chk = _mm256_and_si256(_mm256_srli_epi16(dst, 8), _mm256_set1_epi16(0x000f));
    chk = _mm256_andnot_si256(_mm256_cmpeq_epi16(rbf, _mm256_setzero_si256()), _mm256_cmpeq_epi16(rbf, chk));
    chk = _mm256_and_si256(chk, _mm256_set1_epi16(0xfff0));
    dst = _mm256_or_si256(_mm256_and_si256(chk, buf), _mm256_andnot_si256(chk, dst));
    chk = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_srli_epi16(chk, 15), 0));
    rbf = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_add_epi16(rbf, _mm256_set1_epi16(0x0001)), 0));
    rwd = _mm256_add_epi32(rwd, _mm256_sllv_epi32(chk, rbf));

    buf = _mm256_srli_epi16(_mm256_add_epi16(dst, _mm256_set1_epi16(0x1000)), 4);
    rbf = _mm256_srli_epi16(dst, 12);
    chk = _mm256_and_si256(_mm256_srli_epi16(dst, 8), _mm256_set1_epi16(0x000f));
    chk = _mm256_andnot_si256(_mm256_cmpeq_epi16(rbf, _mm256_setzero_si256()), _mm256_cmpeq_epi16(rbf, chk));
    chk = _mm256_and_si256(chk, _mm256_set1_epi16(0xff00));
    dst = _mm256_or_si256(_mm256_and_si256(chk, buf), _mm256_andnot_si256(chk, dst));
    chk = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_srli_epi16(chk, 15), 0));
    rbf = _mm256_cvtepu16_epi32(_mm256_extracti128_si256(_mm256_add_epi16(rbf, _mm256_set1_epi16(0x0001)), 0));
    rwd = _mm256_add_epi32(rwd, _mm256_sllv_epi32(chk, rbf));

    // mirror and transpose back to original direction
    L = _mm256_extract_epi64(dst, 3); // L = left
    buf = _mm256_slli_epi16(dst, 12);
    buf = _mm256_or_si256(buf, _mm256_slli_epi16(_mm256_and_si256(dst, _mm256_set1_epi16(0x00f0)), 4));
    buf = _mm256_or_si256(buf, _mm256_srli_epi16(_mm256_and_si256(dst, _mm256_set1_epi16(0x0f00)), 4));
    buf = _mm256_or_si256(buf, _mm256_srli_epi16(dst, 12));
    R = _mm256_extract_epi64(buf, 1); // R = mirror left mirror

    buf = _mm256_blend_epi32(dst, buf, 0b11111100);
    rbf = _mm256_and_si256(_mm256_xor_si256(buf, _mm256_srli_epi64(buf, 12)), _mm256_set1_epi64x(0x0000f0f00000f0f0ull));
    buf = _mm256_xor_si256(buf, _mm256_xor_si256(rbf, _mm256_slli_epi64(rbf, 12)));
    rbf = _mm256_and_si256(_mm256_xor_si256(buf, _mm256_srli_epi64(buf, 24)), _mm256_set1_epi64x(0x00000000ff00ff00ull));
    buf = _mm256_xor_si256(buf, _mm256_xor_si256(rbf, _mm256_slli_epi64(rbf, 24)));
    U = _mm256_extract_epi64(buf, 0); // U = transpose left transpose
    D = _mm256_extract_epi64(buf, 2); // D = transpose mirror left mirror transpose

    // sum the final reward and check moved or not
    rwd = _mm256_add_epi64(rwd, _mm256_srli_si256(rwd, 8 /* bytes */));
    rwd = _mm256_add_epi64(rwd, _mm256_srli_epi64(rwd, 32));
    U.inf = _mm256_extract_epi32(rwd, 0);
    R.inf = _mm256_extract_epi32(rwd, 4);
    rwd = _mm256_set_epi64x(R.inf, U.inf, R.inf, U.inf);
    chk = _mm256_cmpeq_epi64(_mm256_set_epi64x(L, D, R, U), _mm256_set1_epi64x(raw));
    rwd = _mm256_or_si256(rwd, chk);
    U.inf = _mm256_extract_epi32(rwd, 0);
    R.inf = _mm256_extract_epi32(rwd, 2);
    D.inf = _mm256_extract_epi32(rwd, 4);
    L.inf = _mm256_extract_epi32(rwd, 6);

#else // if AVX2 is unavailable or disabled
    U = R = D = L = board();

    qrow16(0).moveh64<0>(L, R);
    qrow16(1).moveh64<1>(L, R);
    qrow16(2).moveh64<2>(L, R);
    qrow16(3).moveh64<3>(L, R);
    L.inf |= (L.raw ^ raw) ? 0 : -1;
    R.inf |= (R.raw ^ raw) ? 0 : -1;

    qcol16(0).movev64<0>(U, D);
    qcol16(1).movev64<1>(U, D);
    qcol16(2).movev64<2>(U, D);
    qcol16(3).movev64<3>(U, D);
    U.inf |= (U.raw ^ raw) ? 0 : -1;
    D.inf |= (D.raw ^ raw) ? 0 : -1;
#endif
}

template<u32... patt>
inline constexpr u32 order() {
	if (sizeof...(patt) > 8 || sizeof...(patt) == 0) return -1;
	constexpr u32 x[] = { patt... };
	for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] <= x[i - 1])     return 0; // unordered
#if defined(__BMI2__) && !defined(PREFER_LEGACY_INDEXPT_ORDER)
	for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] != x[i - 1] + 1) return 1; // ordered
#else
	for (u32 i = 1; i < sizeof...(patt); i++) if (x[i] != x[i - 1] + 1) return 0; // ordered (fall back)
#endif
	return 2; // strictly ordered
}

template<u32... patt>
inline constexpr typename std::enable_if<order<patt...>() == 0, u64>::type indexpt(const board& b) {
	u32 index = 0, n = 0;
	for (u32 p : { patt... }) index += b.at(p) << (n++ << 2);
	return index;
}

#if defined(__BMI2__) && !defined(PREFER_LEGACY_INDEXPT_ORDER)
template<u32... patt>
inline constexpr typename std::enable_if<order<patt...>() == 1, u64>::type indexpt(const board& b) {
	u64 mask = 0;
	for (u64 p : { patt... }) mask |= 0xfull << (p << 2);
	return math::pext64(b, mask);
}
#elif !defined(PREFER_LEGACY_INDEXPT_ORDER) // specialize common ordered patterns when BMI2 is unavailable
template<> u64 indexpt<0x0,0x1,0x4,0x5>(const board& b) { return ((u64(b)) & 0x00ff) | ((u64(b) >> 8) & 0xff00); }
template<> u64 indexpt<0x1,0x2,0x5,0x6>(const board& b) { return ((u64(b) >> 4) & 0x00ff) | ((u64(b) >> 12) & 0xff00); }
template<> u64 indexpt<0x5,0x6,0x9,0xa>(const board& b) { return ((u64(b) >> 20) & 0x00ff) | ((u64(b) >> 28) & 0xff00); }
template<> u64 indexpt<0x0,0x1,0x2,0x4,0x5>(const board& b) { return ((u64(b)) & 0x00fff) | (((u64(b)) >> 4) & 0xff000); }
template<> u64 indexpt<0x4,0x5,0x6,0x8,0x9>(const board& b) { return ((u64(b) >> 16) & 0x00fff) | ((u64(b) >> 20) & 0xff000); }
template<> u64 indexpt<0x0,0x1,0x2,0x3,0x5>(const board& b) { return ((u64(b)) & 0x0ffff) | ((u64(b) >> 4) & 0xf0000); }
template<> u64 indexpt<0x4,0x5,0x6,0x7,0x9>(const board& b) { return ((u64(b) >> 16) & 0x0ffff) | ((u64(b) >> 20) & 0xf0000); }
template<> u64 indexpt<0x0,0x1,0x2,0x4,0x5,0x6>(const board& b) { return ((u64(b)) & 0x000fff) | (((u64(b)) >> 4) & 0xfff000); }
template<> u64 indexpt<0x4,0x5,0x6,0x8,0x9,0xa>(const board& b) { return ((u64(b) >> 16) & 0x000fff) | ((u64(b) >> 20) & 0xfff000); }
template<> u64 indexpt<0x2,0x3,0x4,0x5,0x6,0x9>(const board& b) { return ((u64(b) >> 8) & 0x0fffff) | ((u64(b) >> 16) & 0xf00000); }
template<> u64 indexpt<0x0,0x1,0x2,0x5,0x9,0xa>(const board& b) { return ((u64(b)) & 0x000fff) | ((u64(b) >> 8) & 0x00f000) | ((u64(b) >> 20) & 0xff0000); }
template<> u64 indexpt<0x1,0x3,0x4,0x5,0x6,0x7>(const board& b) { return ((u64(b) >> 4) & 0x00000f) | ((u64(b) >> 8) & 0xfffff0); }
template<> u64 indexpt<0x0,0x1,0x4,0x8,0x9,0xa>(const board& b) { return ((u64(b)) & 0x0000ff) | ((u64(b) >> 8) & 0x000f00) | ((u64(b) >> 20) & 0xfff000); }
#endif

template<u32 p, u32... x>
inline constexpr typename std::enable_if<order<p, x...>() == 2, u64>::type indexpt(const board& b) {
	return u32(u64(b) >> (p << 2)) & u32((1ull << ((sizeof...(x) + 1) << 2)) - 1);
}

template<typename mode = weight::segment>
struct isomorphic {
    constexpr inline operator method() { return { isomorphic::estimate, isomorphic::optimize }; }

    constexpr static inline_always numeric invoke(const board& iso, clip<feature> f) {
        register numeric esti = 0;
        for (register auto feat = f.begin(); feat != f.end(); feat += 8)
            esti += feat->at<mode>(iso);
        return esti;
    }
    constexpr static inline_always numeric invoke(const board& iso, numeric updv, clip<feature> f) {
        register numeric esti = 0;
        for (register auto feat = f.begin(); feat != f.end(); feat += 8)
            esti += (feat->at<mode>(iso) += updv);
        return esti;
    }

    template<estimator estim = isomorphic::invoke>
    constexpr static inline numeric estimate(const board& state, clip<feature> range = feature::feats()) {
        register numeric esti = 0;
        register board iso;
        esti += estim(({ iso = state;     iso; }), range);
        esti += estim(({ iso.flip();      iso; }), range);
        esti += estim(({ iso.transpose(); iso; }), range);
        esti += estim(({ iso.flip();      iso; }), range);
        esti += estim(({ iso.transpose(); iso; }), range);
        esti += estim(({ iso.flip();      iso; }), range);
        esti += estim(({ iso.transpose(); iso; }), range);
        esti += estim(({ iso.flip();      iso; }), range);
        return esti;
    }
    template<optimizer optim = isomorphic::invoke>
    constexpr static inline numeric optimize(const board& state, numeric updv, clip<feature> range = feature::feats()) {
        register numeric esti = 0;
        register board iso;
        esti += optim(({ iso = state;     iso; }), updv, range);
        esti += optim(({ iso.flip();      iso; }), updv, range);
        esti += optim(({ iso.transpose(); iso; }), updv, range);
        esti += optim(({ iso.flip();      iso; }), updv, range);
        esti += optim(({ iso.transpose(); iso; }), updv, range);
        esti += optim(({ iso.flip();      iso; }), updv, range);
        esti += optim(({ iso.transpose(); iso; }), updv, range);
        esti += optim(({ iso.flip();      iso; }), updv, range);
        return esti;
    }

    template<indexer::mapper... indexes>
    struct static_index {
        constexpr static std::array<indexer::mapper, sizeof...(indexes)> index = { indexes... };
        constexpr inline operator method() { return { static_index::estimate, static_index::optimize }; }

        template<indexer::mapper index, indexer::mapper... follow> constexpr static
        inline_always typename std::enable_if<(sizeof...(follow) != 0), numeric>::type invoke(const board& iso, clip<feature> f) {
            return (f[(sizeof...(indexes) - sizeof...(follow) - 1) << 3].at<mode>(index(iso))) + invoke<follow...>(iso, f);
        }
        template<indexer::mapper index, indexer::mapper... follow> constexpr static
        inline_always typename std::enable_if<(sizeof...(follow) == 0), numeric>::type invoke(const board& iso, clip<feature> f) {
            return (f[(sizeof...(indexes) - sizeof...(follow) - 1) << 3].at<mode>(index(iso)));
        }
        template<indexer::mapper index, indexer::mapper... follow> constexpr static
        inline_always typename std::enable_if<(sizeof...(follow) != 0), numeric>::type invoke(const board& iso, numeric updv, clip<feature> f) {
            return (f[(sizeof...(indexes) - sizeof...(follow) - 1) << 3].at<mode>(index(iso)) += updv) + invoke<follow...>(iso, updv, f);
        }
        template<indexer::mapper index, indexer::mapper... follow> constexpr static
        inline_always typename std::enable_if<(sizeof...(follow) == 0), numeric>::type invoke(const board& iso, numeric updv, clip<feature> f) {
            return (f[(sizeof...(indexes) - sizeof...(follow) - 1) << 3].at<mode>(index(iso)) += updv);
        }

        constexpr static estimator estimate = isomorphic::estimate<invoke<indexes...>>;
        constexpr static optimizer optimize = isomorphic::optimize<invoke<indexes...>>;
    };

    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>,
            index::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x8,0x9,0xa>> idx4x6patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>,
            index::indexpt<0x8,0x9,0xa,0xb,0xc,0xd>,
            index::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x8,0x9,0xa>> idx5x6patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>,
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>,
            index::indexpt<0x2,0x3,0x4,0x5,0x6,0x9>,
            index::indexpt<0x0,0x1,0x2,0x5,0x9,0xa>,
            index::indexpt<0x3,0x4,0x5,0x6,0x7,0x8>> idx6x6patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>,
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>,
            index::indexpt<0x2,0x3,0x4,0x5,0x6,0x9>,
            index::indexpt<0x0,0x1,0x2,0x5,0x9,0xa>,
            index::indexpt<0x3,0x4,0x5,0x6,0x7,0x8>,
            index::indexpt<0x1,0x3,0x4,0x5,0x6,0x7>> idx7x6patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9>,
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5>,
            index::indexpt<0x2,0x3,0x4,0x5,0x6,0x9>,
            index::indexpt<0x0,0x1,0x2,0x5,0x9,0xa>,
            index::indexpt<0x3,0x4,0x5,0x6,0x7,0x8>,
            index::indexpt<0x1,0x3,0x4,0x5,0x6,0x7>,
            index::indexpt<0x0,0x1,0x4,0x8,0x9,0xa>> idx8x6patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xa>> idx2x7patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xa>,
            index::indexpt<0x8,0x9,0xa,0xb,0xc,0xd,0xe>> idx3x7patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7>> idx1x8patt;
    typedef typename isomorphic<mode>::template static_index<
            index::indexpt<0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7>,
            index::indexpt<0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb>> idx2x8patt;
};