Compiler Explorer

Source code

#include <vector>
#include <array>
#include <stdexcept>
#include <string>
#include <tuple>
#include <iostream>
#include <cstdint>
#include <utility>
#include <chrono>
#include <random>
#include <cstring>
#include <functional>

#include <immintrin.h>

#if SHS_HAS_OPENSSL
    #include <openssl/evp.h>
    #include <openssl/sha.h>
    #include <openssl/crypto.h>
#endif

namespace sha256_simd {
    
#define SHS_ALIGN(n) alignas(n)
#define SHS_SAF { static_assert([]{ return false; }()); }
#define SHS_ASSERT_MSG(cond, msg) { if (!(cond)) throw std::runtime_error("Assert (" #cond ") failed at " + std::to_string(__LINE__) + "! Msg: \"" + std::string(msg) + "\"."); }
#define SHS_ASSERT(cond) SHS_ASSERT_MSG(cond, "")

#if !defined(SHS_HAS_SSE2)
    #ifdef __SSE2__
        #define SHS_HAS_SSE2 1
    #else
        #define SHS_HAS_SSE2 0
    #endif
#endif
#if !defined(SHS_HAS_AVX2)
    #ifdef __AVX2__
        #define SHS_HAS_AVX2 1
    #else
        #define SHS_HAS_AVX2 0
    #endif
#endif
#if !defined(SHS_HAS_AVX512)
    #ifdef __AVX512BW__
        #define SHS_HAS_AVX512 1
    #else
        #define SHS_HAS_AVX512 0
    #endif
#endif

#if SHS_HAS_AVX512
    #undef SHS_HAS_AVX2
    #define SHS_HAS_AVX2 1
    #undef SHS_HAS_SSE2
    #define SHS_HAS_SSE2 1
    #define SHS_NCAP 4
#elif SHS_HAS_AVX2
    #undef SHS_HAS_SSE2
    #define SHS_HAS_SSE2 1
    #define SHS_NCAP 3
#elif SHS_HAS_SSE2
    #define SHS_NCAP 2
#else
    #define SHS_NCAP 1
#endif

enum class CAP : size_t { GEN, SSE2, AVX2, AVX512 };

using std::size_t;
using u8 = uint8_t;
using u32 = uint32_t;
using u64 = uint64_t;

template <CAP Cap, size_t N>
class Simd {
public:
    enum {
        CapN = Cap == CAP::GEN ? 1 : Cap == CAP::SSE2 ? 4 : Cap == CAP::AVX2 ? 8 : Cap == CAP::AVX512 ? 16 : 0,
        TotN = CapN * N,
        AlignBy = CapN * 4,
    };

static_assert(size_t(Cap) < SHS_NCAP);

template <typename T, size_t M> struct TupN;
    template <typename T> struct TupN<T, 1> { using type = std::tuple<T>; };
    template <typename T> struct TupN<T, 2> { using type = std::tuple<T, T>; };
    template <typename T> struct TupN<T, 3> { using type = std::tuple<T, T, T>; };
    template <typename T> struct TupN<T, 4> { using type = std::tuple<T, T, T, T>; };
    template <typename T> struct TupN<T, 5> { using type = std::tuple<T, T, T, T, T>; };
    template <typename T> struct TupN<T, 6> { using type = std::tuple<T, T, T, T, T, T>; };
    template <typename T> struct TupN<T, 7> { using type = std::tuple<T, T, T, T, T, T, T>; };
    template <typename T> struct TupN<T, 8> { using type = std::tuple<T, T, T, T, T, T, T, T>; };
    template <typename T> struct TupN<T, 16> { using type = std::tuple<T, T, T, T, T, T, T, T,   T, T, T, T, T, T, T, T>; };
    
    template <CAP> struct RegOf;
    template <> struct RegOf<CAP::GEN> { using type = u32; };
    template <> struct RegOf<CAP::SSE2> { using type = __m128i; };
    template <> struct RegOf<CAP::AVX2> { using type = __m256i; };
    template <> struct RegOf<CAP::AVX512> { using type = __m512i; };
    
    using RT = typename RegOf<Cap>::type;
    using TupT = typename TupN<RT, N>::type;
    
    template <size_t M, size_t I = 0, typename F>
    void Loop(F && f) {
        if constexpr(I >= M) {}
        else {
            f.template operator () <I> ();
            Loop<M, I + 1>(std::forward<F>(f));
        }
    }
    
    #define SHS_LOOPN(code) Loop<N>([&]<size_t i>{ code; });
    #define SHS_RI (std::get<i>(rs))
    #define SHS_RID (*(RT*)&((u8*)&rs)[sizeof(RT) * i])
    #define SHS_RIO (std::get<i>(other.rs))
    
    template <size_t Shift>
    inline Simd & Ror() {
        static_assert(Shift < 32);
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI = (SHS_RI >> Shift) | (SHS_RI << (32 - Shift)); });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_or_si128(_mm_srli_epi32(SHS_RI, Shift), _mm_slli_epi32(SHS_RI, 32 - Shift)); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_or_si256(_mm256_srli_epi32(SHS_RI, Shift), _mm256_slli_epi32(SHS_RI, 32 - Shift)); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_maskz_ror_epi32(0xFFFF, SHS_RI, Shift); });
        } else
            SHS_SAF;
        return *this;
    }
    template <size_t Shift>
    inline Simd RorC() const {
        Simd c = *this;
        c.Ror<Shift>();
        return std::move(c);
    }
    template <size_t Shift>
    inline Simd & Shr() {
        static_assert(Shift < 32);
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI >>= Shift; });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_srli_epi32(SHS_RI, Shift); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_srli_epi32(SHS_RI, Shift); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_srli_epi32(SHS_RI, Shift); });
        } else
            SHS_SAF;
        return *this;
    }
    template <size_t Shift>
    inline Simd ShrC() const {
        Simd c = *this;
        c.Shr<Shift>();
        return std::move(c);
    }
    inline Simd & operator ^= (Simd const & other) {
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI ^= SHS_RIO; });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_xor_si128(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_xor_si256(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_xor_si512(SHS_RI, SHS_RIO); });
        } else
            SHS_SAF;
        return *this;
    }
    inline Simd operator ^ (Simd const & other) const {
        Simd c = *this;
        c ^= other;
        return std::move(c);
    }
    inline Simd & operator &= (Simd const & other) {
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI &= SHS_RIO; });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_and_si128(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_and_si256(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_and_si512(SHS_RI, SHS_RIO); });
        } else
            SHS_SAF;
        return *this;
    }
    inline Simd operator & (Simd const & other) const {
        Simd c = *this;
        c &= other;
        return std::move(c);
    }
    inline Simd & operator += (Simd const & other) {
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI += SHS_RIO; });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_add_epi32(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_add_epi32(SHS_RI, SHS_RIO); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_add_epi32(SHS_RI, SHS_RIO); });
        } else
            SHS_SAF;
        return *this;
    }
    inline Simd operator + (Simd const & other) const {
        Simd c = *this;
        c += other;
        return std::move(c);
    }
    inline Simd & Not() {
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({ SHS_RI = ~SHS_RI; });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({ SHS_RI = _mm_xor_si128(SHS_RI, _mm_set1_epi32(-1)); });
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({ SHS_RI = _mm256_xor_si256(SHS_RI, _mm256_set1_epi32(-1)); });
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({ SHS_RI = _mm512_xor_si512(SHS_RI, _mm512_set1_epi32(-1)); });
        } else
            SHS_SAF;
        return *this;
    }
    inline Simd operator ~ () const {
        Simd c = *this;
        c.Not();
        return std::move(c);
    }
    inline Simd & ByRev() {
        if constexpr(Cap == CAP::GEN) {
            SHS_LOOPN({
                u32 step16 = SHS_RI << 16 | SHS_RI >> 16;
                SHS_RI = ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
            });
        } else if constexpr(Cap == CAP::SSE2) {
            SHS_LOOPN({SHS_RI = _mm_shuffle_epi8(SHS_RI, _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3));});
        } else if constexpr(Cap == CAP::AVX2) {
            SHS_LOOPN({SHS_RI = _mm256_shuffle_epi8(SHS_RI, _mm256_set_epi8(
                28, 29, 30, 31, 24, 25, 26, 27, 20, 21, 22, 23, 16, 17, 18, 19,
                12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3
            ));});
        } else if constexpr(Cap == CAP::AVX512) {
            SHS_LOOPN({SHS_RI = _mm512_shuffle_epi8(SHS_RI, _mm512_set_epi8(
                60, 61, 62, 63, 56, 57, 58, 59, 52, 53, 54, 55, 48, 49, 50, 51,
                44, 45, 46, 47, 40, 41, 42, 43, 36, 37, 38, 39, 32, 33, 34, 35,
                28, 29, 30, 31, 24, 25, 26, 27, 20, 21, 22, 23, 16, 17, 18, 19,
                12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3
            ));});
        } else
            SHS_SAF;
        return *this;
    }
    inline Simd ByRevC() const {
        Simd c = *this;
        c.ByRev();
        return std::move(c);
    }
    template <typename ... Ts>
    inline Simd & SetCap(size_t i, Ts ... v) {
        if constexpr(Cap == CAP::GEN) {
            static_assert(sizeof...(v) == 1);
            SetCapGen(i, v...);
        } else if constexpr(Cap == CAP::SSE2) {
            static_assert(sizeof...(v) == 4);
            SetCapSse(i, v...);
        } else if constexpr(Cap == CAP::AVX2) {
            static_assert(sizeof...(v) == 8);
            SetCapAvx(i, v...);
        } else if constexpr(Cap == CAP::AVX512) {
            static_assert(sizeof...(v) == 16);
            SetCapAvx512(i, v...);
        } else
            SHS_SAF;
        return *this;
    }
    inline u32 GetI(size_t i) const {
        return ((u32*)&rs)[i];
    }
    
private:
    inline void SetCapGen(size_t i, u32 v0) {
        SHS_RID = v0;
    }
    inline void SetCapSse(size_t i, u32 v0, u32 v1, u32 v2, u32 v3) {
        SHS_RID = _mm_set_epi32(v3, v2, v1, v0);
    }
    inline void SetCapAvx(size_t i, u32 v0, u32 v1, u32 v2, u32 v3, u32 v4, u32 v5, u32 v6, u32 v7) {
        SHS_RID = _mm256_set_epi32(v7, v6, v5, v4, v3, v2, v1, v0);
    }
    inline void SetCapAvx512(size_t i, u32 v0, u32 v1, u32 v2, u32 v3, u32 v4, u32 v5, u32 v6, u32 v7,
            u32 v8, u32 v9, u32 v10, u32 v11, u32 v12, u32 v13, u32 v14, u32 v15) {
        SHS_RID = _mm512_set_epi32(v15, v14, v13, v12, v11, v10, v9, v8, v7, v6, v5, v4, v3, v2, v1, v0);
    }

private:
    SHS_ALIGN(AlignBy) TupT rs;
    
    #undef SHS_RI
    #undef SHS_RIO
    #undef SHS_RID
    #undef SHS_LOOPN
};

template <CAP Cap, size_t NSimd>
class SHA256 {
public:
    using u8 = uint8_t;
    using u32 = uint32_t;
    using u64 = uint64_t;
    using SimdT = Simd<Cap, NSimd>;
    
    enum {
        TotN = Simd<Cap, NSimd>::TotN,
        CapN = Simd<Cap, NSimd>::CapN,
        AlignBy = Simd<Cap, NSimd>::AlignBy,
    };
    
    using DigestT = std::array<std::array<u8, 32>, TotN>;
    
    enum {
        output_size = 8,
        blocksize = 1,
        block_size = 64,
        digest_size = 32,
    };
    
    static u32 constexpr F32 = 0xFFFFFFFF;
    
    static std::array<u32, 64> constexpr c_k = {
        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
        0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
        0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
        0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
        0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
    };

static std::array<u32, 8> constexpr c_h = {
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
    };
    
    static inline auto const c_ks = []{
        std::array<std::array<u32, TotN>, 64> r{};
        for (size_t i = 0; i < c_k.size(); ++i)
            for (size_t j = 0; j < TotN; ++j)
                r[i][j] = c_k[i];
        return r;
    }();
    
    static inline auto const c_hs = []{
        std::array<std::array<u32, TotN>, 8> r{};
        for (size_t i = 0; i < c_h.size(); ++i)
            for (size_t j = 0; j < TotN; ++j)
                r[i][j] = c_h[i];
        return r;
    }();
    
    static inline u32 endian_reverse32(u32 x) {
        u32 step16 = x << 16 | x >> 16;
        return ((step16 << 8) & 0xff00ff00) | ((step16 >> 8) & 0x00ff00ff);
    }
    
    static inline u64 endian_reverse64(uint64_t x) {
        u64 step32, step16;
        step32 = x << 32 | x >> 32;
        step16 = (step32 & 0x0000FFFF0000FFFFULL) << 16
            | (step32 & 0xFFFF0000FFFF0000ULL) >> 16;
        return (step16 & 0x00FF00FF00FF00FFULL) << 8
            | (step16 & 0xFF00FF00FF00FF00ULL) >> 8;
    }

SHA256() {
        static_assert(sizeof(k_) == sizeof(c_ks));
        static_assert(sizeof(h_) == sizeof(c_hs));
        std::memcpy(&k_, &c_ks, sizeof(c_ks));
        std::memcpy(&h_, &c_hs, sizeof(c_hs));
        for (size_t i = 0; i < cache_.size(); ++i)
            cachep_[i] = cache_[i].data();
    }
    
    static inline SimdT _maj(SimdT const & x, SimdT const & y, SimdT const & z) {
        return (x & y) ^ (x & z) ^ (y & z);
    }

static inline SimdT _ch(SimdT const & x, SimdT const & y, SimdT const & z) {
        return (x & y) ^ ((~x) & z);
    }

void Compress(std::array<u8 const *, TotN> const & blocks) {
        std::memset(w_.data(), 0, w_.size() * sizeof(w_[0]));
        
        for (size_t i = 0; i < 16; ++i) {
            for (size_t j = 0; j < NSimd; ++j) {
                #define SHS_AT(k) (*(u32*)&blocks[j * CapN + k][i * 4])
                if constexpr(Cap == CAP::GEN) {
                    w_[i].SetCap(j, SHS_AT(0));
                } else if constexpr(Cap == CAP::SSE2) {
                    w_[i].SetCap(j, SHS_AT(0), SHS_AT(1), SHS_AT(2), SHS_AT(3));
                } else if constexpr(Cap == CAP::AVX2) {
                    w_[i].SetCap(j, SHS_AT(0), SHS_AT(1), SHS_AT(2), SHS_AT(3),
                        SHS_AT(4), SHS_AT(5), SHS_AT(6), SHS_AT(7));
                } else if constexpr(Cap == CAP::AVX512) {
                    w_[i].SetCap(j, SHS_AT(0), SHS_AT(1), SHS_AT(2), SHS_AT(3),
                        SHS_AT(4), SHS_AT(5), SHS_AT(6), SHS_AT(7),
                        SHS_AT(8), SHS_AT(9), SHS_AT(10), SHS_AT(11),
                        SHS_AT(12), SHS_AT(13), SHS_AT(14), SHS_AT(15));
                } else
                    SHS_SAF;
                #undef SHS_AT
            }
            w_[i].ByRev();
        }

for (size_t i = 16; i < 64; ++i) {
            SimdT const
                s0 = w_[i - 15].template RorC<7>() ^ w_[i - 15].template RorC<18>() ^ w_[i - 15].template ShrC<3>(),
                s1 = w_[i - 2].template RorC<17>() ^ w_[i - 2].template RorC<19>() ^ w_[i - 2].template ShrC<10>();
            w_[i] = w_[i - 16] + s0 + w_[i - 7] + s1;
        }
        
        auto h2 = h_;
        auto & [a, b, c, d, e, f, g, h] = h2;

for (size_t i = 0; i < 64; ++i) {
            SimdT const
                s0 = a.template RorC<2>() ^ a.template RorC<13>() ^ a.template RorC<22>(),
                t2 = s0 + _maj(a, b, c),
                s1 = e.template RorC<6>() ^ e.template RorC<11>() ^ e.template RorC<25>(),
                t1 = h + s1 + _ch(e, f, g) + k_[i] + w_[i];

h = g; g = f; f = e;
            e = d + t1;
            d = c; c = b; b = a;
            a = t1 + t2;
        }

for (size_t i = 0; i < h_.size(); ++i)
            h_[i] += h2[i];
    }

void update(std::array<u8 const *, TotN> m, size_t size) {
        SHS_ASSERT(!fin_);
        
        if (size == 0)
            return;

counter_ += size;
        size_t const port = std::min(size_t(64 - cache_size_), size);
        for (size_t i = 0; i < m.size(); ++i) {
            std::memcpy(cache_[i].data() + cache_size_, m[i], port);
            m[i] += port;
        }
        cache_size_ += port;
        size -= port;
        
        if (cache_size_ < 64)
            return;
            
        Compress(cachep_);
        cache_size_ = 0;
        
        while (size >= 64) {
            Compress(m);
            for (size_t i = 0; i < m.size(); ++i)
                m[i] += 64;
            size -= 64;
        }
        
        for (size_t i = 0; i < m.size(); ++i)
            std::memcpy(cache_[i].data(), m[i], size);
        cache_size_ = size;
    }
    
    static auto _pad(u64 msglen) {
        size_t mdi = msglen & 0x3F;
        u64 length = endian_reverse64(msglen << 3);
        size_t padlen = mdi < 56 ? 55 - mdi : 119 - mdi;
        std::array<u8, 128> r = {0x80};
        *(u64*)(r.data() + 1 + padlen) = length; //std::memcpy(r.data() + 1 + padlen, &length, 8);
        return std::make_tuple(std::move(r), 1 + padlen + 8);
    }

DigestT const & digest() {
        if (!fin_) {
            auto [pad, padl] = _pad(counter_);
            std::array<u8 const *, TotN> pads;
            for (size_t i = 0; i < pads.size(); ++i)
                pads[i] = pad.data();
            update(pads, padl);
            for (size_t i = 0; i < output_size; ++i) {
                SimdT const hc = h_[i].ByRevC();
                for (size_t j = 0; j < dig_.size(); ++j)
                    *(u32*)&dig_[j][i * 4] = hc.GetI(j);
            }
            fin_ = true;
        }
        return dig_;
    }
    
    template <size_t Size>
    static DigestT DigestS(std::array<std::array<u8, Size>, TotN> const & data) {
        SHA256 s;
        return s.DigestSH<Size>(data);
    }
    
    auto hexdigest() {
        static char const tab[] = "0123456789abcdef";
        auto const & dig = digest();
        std::array<std::string, TotN> r{};
        for (size_t i = 0; i < dig.size(); ++i)
            for (auto e: dig[i]) {
                r[i].append(1, tab[e >> 4]);
                r[i].append(1, tab[e & 0xF]);
            }
        return std::move(r);
    }
        
private:
    SHA256(SHA256 const &) = delete;
    SHA256(SHA256 &&) = delete;
    SHA256 & operator =(SHA256 const &) = delete;
    SHA256 & operator =(SHA256 &&) = delete;
    
    template <size_t Size>
    DigestT const & DigestSH(std::array<std::array<u8, Size>, TotN> const & data) {
        SHS_ASSERT(!fin_);
        SHS_ASSERT_MSG(counter_ == 0, "DigestS function allowed to call on non-updated object!");
        size_t constexpr size = (Size + 64) / 64 * 64;
        std::array<std::array<u8, size>, TotN> d;
        static auto [pad, padl] = _pad(Size);
        SHS_ASSERT(Size + padl == size);
        for (size_t i = 0; i < TotN; ++i) {
            std::memcpy(d[i].data(), data[i].data(), Size);
            std::memcpy(d[i].data() + size - padl, pad.data(), padl);
        }
        std::array<u8 const *, TotN> p;
        for (size_t i = 0; i < size; i += 64) {
            for (size_t j = 0; j < TotN; ++j)
                p[j] = d[j].data() + i;
            this->Compress(p);
        }
        for (size_t i = 0; i < output_size; ++i) {
            SimdT const hc = h_[i].ByRevC();
            for (size_t j = 0; j < dig_.size(); ++j)
                *(u32*)&dig_[j][i * 4] = hc.GetI(j);
        }
        fin_ = true;
        return dig_;
    }
    
private:
    bool fin_ = false;
    u64 counter_ = 0;
    SHS_ALIGN(64) DigestT dig_;
    SHS_ALIGN(64) std::array<std::array<u8, 64>, TotN> cache_;
    std::array<u8 const *, TotN> cachep_;
    size_t cache_size_ = 0;
    SHS_ALIGN(AlignBy) std::array<SimdT,  8> h_;
    SHS_ALIGN(AlignBy) std::array<SimdT, 64> k_, w_;
    
    #undef SHS_ALIGN
};

class Timer {
public:
    Timer(std::string const & name)
        : name_(name), tb_(std::chrono::high_resolution_clock::now()) {}
    ~Timer() {
        auto te = std::chrono::high_resolution_clock::now();
        std::cout << name_ << " " << std::chrono::duration_cast<std::chrono::milliseconds>(te - tb_).count() << " ms" << std::endl << std::flush;
    }
private:
    std::string name_;
    std::chrono::high_resolution_clock::time_point tb_;
};

template <CAP Cap, size_t N = 4>
inline std::array<u8, 32> MerkleRootS(std::vector<std::array<u8, 32>> a) {
    size_t cnt = a.size();
    auto f = [&a, &cnt]<size_t Mult>{
        enum { TotN = SHA256<Cap, N>::TotN };
        size_t lo = 0, hi = cnt - cnt % (TotN * Mult);
        for (size_t i = lo; i < hi; i += TotN * Mult)
            *(typename SHA256<Cap, N>::DigestT *)&a[i / Mult] = SHA256<Cap, N>::template DigestS<32 * Mult>(*(std::array<std::array<u8, 32 * Mult>, TotN> *)&a[i]);
        lo = hi; hi = cnt - cnt % Mult;
        for (size_t i = lo; i < hi; i += Mult)
            *(typename SHA256<CAP::GEN, 1>::DigestT *)&a[i / Mult] = SHA256<CAP::GEN, 1>::template DigestS<32 * Mult>(*(std::array<std::array<u8, 32 * Mult>, 1> *)&a[i]);
        if constexpr(Mult > 1) {
            if (hi < cnt) {
                SHS_ASSERT(Mult == 2);
                size_t const i = cnt - 1;
                std::array<std::array<u8, 32>, Mult> b = {a[i], a[i]};
                *(SHA256<CAP::GEN, 1>::DigestT *)&a[i / Mult] = SHA256<CAP::GEN, 1>::template DigestS<32 * Mult>(*(std::array<std::array<u8, 32 * Mult>, 1> *)&b);
            }
        }
        cnt = (cnt + Mult - 1) / Mult;
    };
    while (cnt > 1) {
        f.template operator() <2> ();
        f.template operator() <1> ();
    }
    return a.at(0);
}

inline std::string CapName(CAP Cap) {
    return std::string(Cap == CAP::GEN ? "GEN" : Cap == CAP::SSE2 ? "SSE2" :
        Cap == CAP::AVX2 ? "AVX2" : Cap == CAP::AVX512 ? "AVX512" : "<UNKNOWN>");
}

inline void MerkleRootPy(u32 cap, u32 n, u8 const * data, u32 cnt32, u8 * hsh) {
    //Timer tim("MerkleRootPy");
    static auto a = []{
        std::array<std::array<std::function<void(u8 const *, u32, u8 *)>, 4>, SHS_NCAP> r{};
        auto f = []<CAP Cap, size_t N>(u8 const * data, u32 cnt32, u8 * hsh){
            *(std::array<u8, 32>*)hsh = MerkleRootS<Cap, N>(std::vector<std::array<u8, 32>>((std::array<u8, 32>*)data, ((std::array<u8, 32>*)data) + cnt32));
        };
        #define SHS_F(i, j) if constexpr(i < r.size() && j < r[0].size()) { r.at(i).at(j) = [&](u8 const * data, u32 cnt32, u8 * hsh){ f.template operator() <CAP(i), (1 << j)> (data, cnt32, hsh); }; }
        #if SHS_NCAP >= 1
        SHS_F(0, 0); SHS_F(0, 1); SHS_F(0, 2); SHS_F(0, 3);
        #endif
        #if SHS_NCAP >= 2
        SHS_F(1, 0); SHS_F(1, 1); SHS_F(1, 2); SHS_F(1, 3);
        #endif
        #if SHS_NCAP >= 3
        SHS_F(2, 0); SHS_F(2, 1); SHS_F(2, 2); SHS_F(2, 3);
        #endif
        #if SHS_NCAP >= 4
        SHS_F(3, 0); SHS_F(3, 1); SHS_F(3, 2); SHS_F(3, 3);
        #endif
        #undef SHS_F
        return r;
    }();
    SHS_ASSERT_MSG(cap < a.size(), "Library wasn't compiled for capability " + CapName(CAP(size_t(cap))) + ", maximal capability is " + CapName(CAP(size_t(a.size() - 1))));
    SHS_ASSERT_MSG(n < a[0].size(), std::to_string(n) + " " + std::to_string(a[0].size()));
    a[cap][n](data, cnt32, hsh);
}

inline std::string ToHex(u8 const * data, size_t size) {
    std::string r;
    r.append(size * 2, '_');
    static char const tab[] = "0123456789abcdef";
    for (size_t i = 0; i < size; ++i) {
        r[2 * i + 0] = tab[data[i] >> 4];
        r[2 * i + 1] = tab[data[i] & 0xF];
    }
    return r;
}

template <size_t Size>
inline std::string ToHex(std::array<u8, Size> const & a) {
    return ToHex(a.data(), a.size());
}

inline std::string FromHexS(std::string const & s) {
    std::string r;
    SHS_ASSERT(s.size() % 2 == 0);
    for (size_t i = 0; i < s.size(); ++i) {
        auto c = s[i];
        if ('0' <= c && c <= '9')
            c -= '0';
        else if ('A' <= c && c <= 'F')
            c -= 'A' - 10;
        else if ('a' <= c && c <= 'f')
            c -= 'a' - 10;
        else
            SHS_ASSERT(false);
        if (i % 2 == 0)
            r.push_back(u8(c) << 4);
        else
            r.back() |= u8(c);
    }
    return r;
}

template <size_t Size>
inline std::array<u8, Size> FromHexA(std::string const & s) {
    auto v = FromHexS(s);
    SHS_ASSERT(v.size() == Size);
    std::array<u8, Size> r{};
    std::copy(v.begin(), v.end(), r.data());
    return r;
}

inline auto GenTxids(size_t cnt) {
    std::mt19937_64 rng(1234);
    std::vector<std::array<u8, 32>> v(cnt);
    for (size_t i = 0; i < v.size(); ++i)
        for (size_t j = 0; j < v[i].size(); j += 8)
            *(u64*)&v[i][j] = rng();
    return v;
}

#if SHS_HAS_OPENSSL
class OsslMerkleRoot {
public:
    OsslMerkleRoot() : md_algo(EVP_sha256()) {
        SHS_ASSERT(EVP_MD_size(md_algo) == 32);
    }
    std::array<u8, 32> DSha(std::array<std::array<u8, 32>, 2> const & ab) {
        unsigned int md_len = 32;
        std::array<u8, 32> out;
        EVP_Digest(&ab, 64, out.data(), &md_len, md_algo, nullptr);
        EVP_Digest(out.data(), md_len, out.data(), &md_len, md_algo, nullptr);
        return out;
    }
    std::array<u8, 32> MerkleRoot(std::vector<std::array<u8, 32>> a) {
        while (a.size() > 1) {
            size_t const hi = a.size() - a.size() % 2;
            for (size_t i = 0; i < hi; i += 2)
                a[i / 2] = DSha(*(std::array<std::array<u8, 32>, 2>*)&a[i]);
            for (size_t i = hi; i < a.size(); ++i) {
                std::array<std::array<u8, 32>, 2> b = {a[i], a[i]};
                a[i / 2] = DSha(b);
            }
            a.resize((a.size() + 1) / 2);
        }
        return a.at(0);
    }
private:
    EVP_MD const * md_algo = nullptr;
};

inline void OsslMerkleRootPy(u8 const * data, u32 cnt32, u8 * hsh) {
    OsslMerkleRoot omr;
    *(std::array<u8, 32>*)hsh = omr.MerkleRoot(std::vector<std::array<u8, 32>>((std::array<u8, 32>*)data, ((std::array<u8, 32>*)data) + cnt32));
}
#endif

inline void Test() {
    {
        std::vector<std::tuple<std::string, std::string>> tests = {
            {"",
                "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"},
            {"a",
                "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"},
            {"abc",
                "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"},
            {"message digest",
                "f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650"},
            {"abcdefghijklmnopqrstuvwxyz",
                "71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73"},
            {"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
                "db4bfcbd4da0cd85a60c3c37d3fbd8805c77f15fc6b1fdfe614ee0a7c8fdb4c0"},
            {"12345678901234567890123456789012345678901234567890123456789"
             "012345678901234567890",
                "f371bc4a311f2b009eef952dd83ca80e2b60026c8e935592d0f9c308453c813e"},
        };

for (auto const & [msg, sig]: tests) {
            auto m = SHA256<CAP::GEN, 1>();
            m.update({(u8*)msg.data()}, msg.size());
            SHS_ASSERT_MSG(m.hexdigest()[0] == sig, m.hexdigest()[0] + "   " + sig);
        }
    }
    {
        std::string s = "6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0";
        auto v = FromHexS(s);
        SHS_ASSERT_MSG(ToHex((u8*)v.data(), v.size()) == s, s + "  " + v);
    }
    {
        std::vector<std::tuple<std::string, std::string>> tests = {
            {"yWAcqGF", "80c22ec4242ba36d8b39651afa108dc1b1f719edc53cda1f4cebdb96da4d5536"},
            {"zYtEwLn", "77bd7836de67730e5fe78fb625b2bf37fce4b00c0ffcec84ec654016691fb679"},
            {"GisiWgN", "6373d0735780f735ca51a661330490bd33ea7396407cf20d729d51d7f65a4190"},
            {"ZqITZMj", "87179c77033904f3cec034a918b0f2863eef7a6b3e5773802c8b504c64ecb8bb"},
            {"tgUeRvE", "590c5e053ce39d886f7ee04fe27e47af28887940211c98a4e16c47689916a53a"},
            {"JgwBuNO", "5e40ef6b524442fe121d6092c6237dcfeef9c39443e57aed9a39767fc40fef76"},
            {"nJECHqd", "8c8ad7af3c525de7d7fb16ff29e30c2c62d3244e42740f535126906f2b005491"},
            {"ZJafUzT", "3de47821898dc828b4348546a962b296ba39aa564ffe062a83f6913be0d08a76"},

{"yWAcqGF", "80c22ec4242ba36d8b39651afa108dc1b1f719edc53cda1f4cebdb96da4d5536"},
            {"zYtEwLn", "77bd7836de67730e5fe78fb625b2bf37fce4b00c0ffcec84ec654016691fb679"},
            {"GisiWgN", "6373d0735780f735ca51a661330490bd33ea7396407cf20d729d51d7f65a4190"},
            {"ZqITZMj", "87179c77033904f3cec034a918b0f2863eef7a6b3e5773802c8b504c64ecb8bb"},
            {"tgUeRvE", "590c5e053ce39d886f7ee04fe27e47af28887940211c98a4e16c47689916a53a"},
            {"JgwBuNO", "5e40ef6b524442fe121d6092c6237dcfeef9c39443e57aed9a39767fc40fef76"},
            {"nJECHqd", "8c8ad7af3c525de7d7fb16ff29e30c2c62d3244e42740f535126906f2b005491"},
            {"ZJafUzT", "3de47821898dc828b4348546a962b296ba39aa564ffe062a83f6913be0d08a76"},

{"iKZWeqhFWCEPyYngFbyBMWXaSCrUZoLgubbbPIayRnBUbHoWCFJowoRoWDsbAJPglOUshVvUTGBGQmtsLFGzLcEpVZzAQlxJS", "2db0122ad8849a1fed4ba071c0aeb238b485973cd20435816f475bdb015fc7ac"},
            {"XRVxfCQGgXkHzxFUbEctTNLLzPkkGoaXmIJozGwKwDrQJMUayYVGZiHXJnBdExKJmGAFwAwaIINYNvDMbZoOlJLlfZJZqcRef", "4c0db3a2efcd4d8b4fc300b1cf2a80c40a99002df4f4590b6574dd6e64f37351"},
            {"bCaWWrprhZNlwsekkqHkQrPTsDSuFEhbtyvAYmqgqUGnMBbobzjcUkCTGRBIoOZSHCoHPbzRKZuQOBdVtindteettVkAKqiaJ", "94ffacb43c4c1a41d7bba9a7776ccc00026551240deeae501a79deb767868f8b"},
            {"cLnKDkXTNGcymwgnKRBLmFgQysGFbuNzsbkmuZKYivBnrRgyJwRIFXIpeUcfikkInrWvMGqxvvhspMXTFiLJXgucAeyYjivhN", "f67a7d47a4903b8e55c8db34f36eadffbb20ef62961a2858d6aa11f4c97d72df"},
            {"LYyeKJoKfrxsKIhDrgYcsaNQafAhYcmpYLAkhCkRpkVgByZIsJqTEugnPucbaYsUMuCzuzeeuMDhqnYNXISEQwqlIntmpxfrf", "cc71add4fec79b3fe2ff48939e4d930f932efd6d675b179a79699fca0bcaca7d"},
            {"WCfPKPvoytculuYLtpvgINLZMfpobZpzerJeUebOasWYwFEjgGXYueGQllXjjutgTGMsinjIUcXuNZRJVSnltBIkdTQpqXeRC", "ba2ed195d251e6f5612599ec83727e48692d91ccf1adafd4f3972c7fe6824d39"},
            {"ZBJqICIDazvkqFbYPAKbdSwLiLiiqrzKzlNfoFalHuGPCROUopuFREoTAvJNUPrPodeWGPxkGXYnttStJxkSSVDMfhMGKyljq", "8f3a56ea9bd2145d6e8f9fc9137ef7dd6dc88f23be2212bda1bcc2b62b145240"},
            {"BnKUWYdFRzTOwyGkIUcHfZqOgrVfiXNQRSfCpyZBzkuCiNFnhBMIAhQsrpyVJamHCLbbOMpqnlsjImrtLWqRCYZkIwFAhXnKy", "71326c4102ebbc8a804768a67a7c416cb431e349f6babef240c65afc263dd1a9"},
            
            {"iKZWeqhFWCEPyYngFbyBMWXaSCrUZoLgubbbPIayRnBUbHoWCFJowoRoWDsbAJPglOUshVvUTGBGQmtsLFGzLcEpVZzAQlxJS", "2db0122ad8849a1fed4ba071c0aeb238b485973cd20435816f475bdb015fc7ac"},
            {"XRVxfCQGgXkHzxFUbEctTNLLzPkkGoaXmIJozGwKwDrQJMUayYVGZiHXJnBdExKJmGAFwAwaIINYNvDMbZoOlJLlfZJZqcRef", "4c0db3a2efcd4d8b4fc300b1cf2a80c40a99002df4f4590b6574dd6e64f37351"},
            {"bCaWWrprhZNlwsekkqHkQrPTsDSuFEhbtyvAYmqgqUGnMBbobzjcUkCTGRBIoOZSHCoHPbzRKZuQOBdVtindteettVkAKqiaJ", "94ffacb43c4c1a41d7bba9a7776ccc00026551240deeae501a79deb767868f8b"},
            {"cLnKDkXTNGcymwgnKRBLmFgQysGFbuNzsbkmuZKYivBnrRgyJwRIFXIpeUcfikkInrWvMGqxvvhspMXTFiLJXgucAeyYjivhN", "f67a7d47a4903b8e55c8db34f36eadffbb20ef62961a2858d6aa11f4c97d72df"},
            {"LYyeKJoKfrxsKIhDrgYcsaNQafAhYcmpYLAkhCkRpkVgByZIsJqTEugnPucbaYsUMuCzuzeeuMDhqnYNXISEQwqlIntmpxfrf", "cc71add4fec79b3fe2ff48939e4d930f932efd6d675b179a79699fca0bcaca7d"},
            {"WCfPKPvoytculuYLtpvgINLZMfpobZpzerJeUebOasWYwFEjgGXYueGQllXjjutgTGMsinjIUcXuNZRJVSnltBIkdTQpqXeRC", "ba2ed195d251e6f5612599ec83727e48692d91ccf1adafd4f3972c7fe6824d39"},
            {"ZBJqICIDazvkqFbYPAKbdSwLiLiiqrzKzlNfoFalHuGPCROUopuFREoTAvJNUPrPodeWGPxkGXYnttStJxkSSVDMfhMGKyljq", "8f3a56ea9bd2145d6e8f9fc9137ef7dd6dc88f23be2212bda1bcc2b62b145240"},
            {"BnKUWYdFRzTOwyGkIUcHfZqOgrVfiXNQRSfCpyZBzkuCiNFnhBMIAhQsrpyVJamHCLbbOMpqnlsjImrtLWqRCYZkIwFAhXnKy", "71326c4102ebbc8a804768a67a7c416cb431e349f6babef240c65afc263dd1a9"},

{FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            {FromHexS("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0"), "cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"},
            
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
            {FromHexS("cb6e62ed6d9cfd27316271d777c61a9487de86d05eddd674b09948e0fef6bdb7"), "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
        };
        
        for (size_t i = 0; i < tests.size(); i += 4) {
            auto const * p = &tests[i];
            auto m = SHA256<CAP::GEN, 4>();
            m.update({
                (u8*)std::get<0>(p[0]).data(),
                (u8*)std::get<0>(p[1]).data(),
                (u8*)std::get<0>(p[2]).data(),
                (u8*)std::get<0>(p[3]).data(),
            }, std::get<0>(p[0]).size());
            SHS_ASSERT_MSG(
                m.hexdigest()[0] == std::get<1>(p[0]) &&
                m.hexdigest()[1] == std::get<1>(p[1]) &&
                m.hexdigest()[2] == std::get<1>(p[2]) &&
                m.hexdigest()[3] == std::get<1>(p[3]),
                std::to_string(i)
            );
        }
        
        #if SHS_HAS_SSE2
        for (size_t i = 0; i < tests.size(); i += 4) {
            auto const * p = &tests[i];
            auto m = SHA256<CAP::SSE2, 1>();
            m.update({
                (u8*)std::get<0>(p[0]).data(),
                (u8*)std::get<0>(p[1]).data(),
                (u8*)std::get<0>(p[2]).data(),
                (u8*)std::get<0>(p[3]).data(),
            }, std::get<0>(p[0]).size());
            SHS_ASSERT(
                m.hexdigest()[0] == std::get<1>(p[0]) &&
                m.hexdigest()[1] == std::get<1>(p[1]) &&
                m.hexdigest()[2] == std::get<1>(p[2]) &&
                m.hexdigest()[3] == std::get<1>(p[3])
            );
        }
        
        for (size_t i = 0; i < tests.size(); i += 8) {
            auto const * p = &tests[i];
            auto m = SHA256<CAP::SSE2, 2>();
            m.update({
                (u8*)std::get<0>(p[0]).data(),
                (u8*)std::get<0>(p[1]).data(),
                (u8*)std::get<0>(p[2]).data(),
                (u8*)std::get<0>(p[3]).data(),
                (u8*)std::get<0>(p[4]).data(),
                (u8*)std::get<0>(p[5]).data(),
                (u8*)std::get<0>(p[6]).data(),
                (u8*)std::get<0>(p[7]).data(),
            }, std::get<0>(p[0]).size());
            SHS_ASSERT(
                m.hexdigest()[0] == std::get<1>(p[0]) &&
                m.hexdigest()[1] == std::get<1>(p[1]) &&
                m.hexdigest()[2] == std::get<1>(p[2]) &&
                m.hexdigest()[3] == std::get<1>(p[3]) &&
                m.hexdigest()[4] == std::get<1>(p[4]) &&
                m.hexdigest()[5] == std::get<1>(p[5]) &&
                m.hexdigest()[6] == std::get<1>(p[6]) &&
                m.hexdigest()[7] == std::get<1>(p[7])
            );
        }
        #endif
        
        #if SHS_HAS_AVX2
        for (size_t i = 0; i < tests.size(); i += 8) {
            auto const * p = &tests[i];
            auto m = SHA256<CAP::AVX2, 1>();
            m.update({
                (u8*)std::get<0>(p[0]).data(),
                (u8*)std::get<0>(p[1]).data(),
                (u8*)std::get<0>(p[2]).data(),
                (u8*)std::get<0>(p[3]).data(),
                (u8*)std::get<0>(p[4]).data(),
                (u8*)std::get<0>(p[5]).data(),
                (u8*)std::get<0>(p[6]).data(),
                (u8*)std::get<0>(p[7]).data(),
            }, std::get<0>(p[0]).size());
            SHS_ASSERT(
                m.hexdigest()[0] == std::get<1>(p[0]) &&
                m.hexdigest()[1] == std::get<1>(p[1]) &&
                m.hexdigest()[2] == std::get<1>(p[2]) &&
                m.hexdigest()[3] == std::get<1>(p[3]) &&
                m.hexdigest()[4] == std::get<1>(p[4]) &&
                m.hexdigest()[5] == std::get<1>(p[5]) &&
                m.hexdigest()[6] == std::get<1>(p[6]) &&
                m.hexdigest()[7] == std::get<1>(p[7])
            );
        }
        #endif
        
        #if SHS_HAS_AVX512
        for (size_t i = 0; i < tests.size(); i += 16) {
            auto const * p = &tests[i];
            auto m = SHA256<CAP::AVX512, 1>();
            m.update({
                (u8*)std::get<0>(p[0]).data(),
                (u8*)std::get<0>(p[1]).data(),
                (u8*)std::get<0>(p[2]).data(),
                (u8*)std::get<0>(p[3]).data(),
                (u8*)std::get<0>(p[4]).data(),
                (u8*)std::get<0>(p[5]).data(),
                (u8*)std::get<0>(p[6]).data(),
                (u8*)std::get<0>(p[7]).data(),
                
                (u8*)std::get<0>(p[8]).data(),
                (u8*)std::get<0>(p[9]).data(),
                (u8*)std::get<0>(p[10]).data(),
                (u8*)std::get<0>(p[11]).data(),
                (u8*)std::get<0>(p[12]).data(),
                (u8*)std::get<0>(p[13]).data(),
                (u8*)std::get<0>(p[14]).data(),
                (u8*)std::get<0>(p[15]).data(),
            }, std::get<0>(p[0]).size());
            SHS_ASSERT(
                m.hexdigest()[0] == std::get<1>(p[0]) &&
                m.hexdigest()[1] == std::get<1>(p[1]) &&
                m.hexdigest()[2] == std::get<1>(p[2]) &&
                m.hexdigest()[3] == std::get<1>(p[3]) &&
                m.hexdigest()[4] == std::get<1>(p[4]) &&
                m.hexdigest()[5] == std::get<1>(p[5]) &&
                m.hexdigest()[6] == std::get<1>(p[6]) &&
                m.hexdigest()[7] == std::get<1>(p[7]) &&
                m.hexdigest()[8] == std::get<1>(p[8]) &&
                m.hexdigest()[9] == std::get<1>(p[9]) &&
                m.hexdigest()[10] == std::get<1>(p[10]) &&
                m.hexdigest()[11] == std::get<1>(p[11]) &&
                m.hexdigest()[12] == std::get<1>(p[12]) &&
                m.hexdigest()[13] == std::get<1>(p[13]) &&
                m.hexdigest()[14] == std::get<1>(p[14]) &&
                m.hexdigest()[15] == std::get<1>(p[15])
            );
        }
        #endif
        
        for (size_t i = 0; i < tests.size(); i += 2) {
            auto const & [l, r] = tests[i];
            if (!(l.size() == 32 || l.size() == 64))
                continue;
            std::array<u8, 32> h{};
            if (l.size() == 32)
                h = SHA256<CAP::GEN, 1>::DigestS<32>({*(std::array<u8, 32> *)l.data()}).at(0);
            else
                h = SHA256<CAP::GEN, 1>::DigestS<64>({*(std::array<u8, 64> *)l.data()}).at(0);
            SHS_ASSERT_MSG(ToHex(h) == r, ToHex(h) + " " + r);
        }
    }
    {
        std::vector<std::tuple<std::vector<std::array<u8, 32>>, std::string>> tests = {
            {{FromHexA<32>("6774ea12dda610127c68256ae67ac8e1f31e4d773dfabfc45932032215457ccd"),
              FromHexA<32>("5db38b72a499f468a07eb8bd75f1f7589c63529022737fe6b8c7deb128acfcf0")},
             "abc21d164c6b075064cbf707abd23c2ff6d5ae22cda2a2f43220375a2aedc511"},
        };
        for (size_t i = 0; i < tests.size(); ++i) {
            auto a = ToHex(MerkleRootS<CAP::GEN, 1>(std::get<0>(tests[i]))),
                 b = std::get<1>(tests[i]);
            SHS_ASSERT_MSG(a == b, a + " " + b);
        }
    }
    {
        auto f = [&]<bool is_simd, CAP Cap, size_t N>{
            size_t const niter = 128;
            auto txids = GenTxids(1452);
            volatile size_t t = 0;
            Timer tim("MerkleRoot-" + (is_simd ? ("Simd-" + CapName(Cap) + "-" + std::to_string(N)): std::string("Ossl")));
            std::array<u8, 32> h{};
            #if SHS_HAS_OPENSSL
            OsslMerkleRoot omr;
            #endif
            for (size_t i = 0; i < niter; ++i) {
                if constexpr(is_simd)
                    h = MerkleRootS<Cap, N>(txids);
                #if SHS_HAS_OPENSSL
                else
                    h = omr.MerkleRoot(txids);
                #endif
                SHS_ASSERT_MSG(ToHex(h) == "40cdf9e5ffa3894fc7a3fa4e50478b92ce340c945db25a645cc71e5864860a3b", ToHex(h)); // 1021: "ef244a24cadba1ef9d992dd68c44ca4b8aec5ea92732410042d19c91640255e0"
                t = t + h[0];
            }
            //std::cout << ToHex(h.data(), h.size()) << std::endl;
        };
        #if 1
        #if SHS_HAS_OPENSSL
        f.template operator() <false, CAP::GEN, 1> ();
        #endif
        f.template operator() <true, CAP::GEN, 1> ();
        f.template operator() <true, CAP::GEN, 2> ();
        #endif
        #if 1
        f.template operator() <true, CAP::GEN, 4> ();
        f.template operator() <true, CAP::GEN, 8> ();
        f.template operator() <true, CAP::GEN, 16> ();
        #endif
        #if 1
        #if SHS_HAS_SSE2
        f.template operator() <true, CAP::SSE2, 1> ();
        f.template operator() <true, CAP::SSE2, 2> ();
        f.template operator() <true, CAP::SSE2, 4> ();
        #endif
        #endif
        #if 1
        #if SHS_HAS_AVX2
        f.template operator() <true, CAP::AVX2, 1> ();
        f.template operator() <true, CAP::AVX2, 2> ();
        f.template operator() <true, CAP::AVX2, 4> ();
        #endif
        #endif
        #if 1
        #if SHS_HAS_AVX512
        f.template operator() <true, CAP::AVX512, 1> ();
        f.template operator() <true, CAP::AVX512, 2> ();
        f.template operator() <true, CAP::AVX512, 4> ();
        #endif
        #endif
    }
    if (0) {
        auto g = [&]<size_t ByN, bool IsS>{
            size_t const niter = 256;
            std::vector<std::array<u8, ByN>> data(1024);
            for (size_t i = 0; i < data.size(); ++i)
                for (size_t j = 0; j < data[i].size(); ++j)
                    data[i][j] = u8(j);
            auto f = [&]<CAP Cap, size_t N>{
                enum { TotN = Simd<Cap, N>::TotN };
                Timer tim(std::to_string(ByN) + "-" + CapName(Cap) + "-" + std::to_string(N) + "-" + std::string(IsS ? "S" : "D"));
                volatile size_t t = 0;
                std::array<u8 const *, TotN> d;
                (void)d;
                for (size_t k = 0; k < niter; ++k)
                    for (size_t i = 0; i < data.size(); i += TotN) {
                        if constexpr(IsS) {
                            SHA256<Cap, N> s;
                            t = t + s.template DigestS<ByN>(*(std::array<std::array<u8, ByN>, TotN> *)&data[i])[0][0];
                        } else {
                            for (size_t j = 0; j < TotN; ++j)
                                d[j] = data[i + j].data();
                            SHA256<Cap, N> s;
                            s.update(d, data[0].size());
                            t = t + s.digest()[0][0];
                        }
                    }
                return t;
            };
            f.template operator () <CAP::GEN, 1>();
            f.template operator () <CAP::GEN, 2>();
            f.template operator () <CAP::GEN, 4>();
            f.template operator () <CAP::GEN, 8>();
            #if SHS_HAS_SSE2
            f.template operator () <CAP::SSE2, 1>();
            f.template operator () <CAP::SSE2, 2>();
            f.template operator () <CAP::SSE2, 4>();
            f.template operator () <CAP::SSE2, 8>();
            #endif
        };
        g.operator()<64, false>();
        g.operator()<64, true>();
        g.operator()<32, false>();
        g.operator()<32, true>();
    }
}

#undef SHS_ASSERT_MSG
#undef SHS_ASSERT
#undef SHS_SAF
} // namespace

#if 1
int main() {
    try {
        sha256_simd::Test();
        std::cout << "All OK" << std::endl;
        return 0;
    } catch (std::exception const & ex) {
        std::cout << "Exception: " << ex.what() << std::endl;
        return -1;
    }
}
#endif