Compiler Explorer

Source code

#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/hash_append_fwd.hpp>
#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/is_trivially_equality_comparable.hpp>
#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/is_endian_independent.hpp>
#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/endian.hpp>

// #include <boost/hash2/is_contiguously_hashable.hpp>

#ifndef BOOST_HASH2_IS_CONTIGUOUSLY_HASHABLE_HPP_INCLUDED
#define BOOST_HASH2_IS_CONTIGUOUSLY_HASHABLE_HPP_INCLUDED

// Copyright 2017, 2023, 2024 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/is_trivially_equality_comparable.hpp>
//#include <boost/hash2/is_endian_independent.hpp>
//#include <boost/hash2/endian.hpp>
#include <type_traits>
#include <cstddef>

namespace boost
{
namespace hash2
{

template<class T, endian E> struct is_contiguously_hashable:
 std::integral_constant<bool, is_trivially_equality_comparable<T>::value && (E == endian::native || is_endian_independent<T>::value)>
{
};

template<class T, std::size_t N, endian E> struct is_contiguously_hashable<T[N], E>:
 is_contiguously_hashable<T, E>
{
};

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_IS_CONTIGUOUSLY_HASHABLE_HPP_INCLUDED

#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/has_constant_size.hpp>

#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/detail/config.hpp>

//#include <boost/hash2/detail/is_constant_evaluated.hpp>

#ifndef BOOST_HASH2_DETAIL_IS_CONSTANT_EVALUATED_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_IS_CONSTANT_EVALUATED_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/config.hpp>

namespace boost
{
namespace hash2
{
namespace detail
{

constexpr bool is_constant_evaluated() noexcept
{
#if defined(BOOST_HASH2_HAS_BUILTIN_IS_CONSTANT_EVALUATED)

return __builtin_is_constant_evaluated();

#else

return true;

#endif
}

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_IS_CONSTANT_EVALUATED_HPP_INCLUDED

//#include <boost/hash2/detail/read.hpp>

#ifndef BOOST_HASH2_DETAIL_READ_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_READ_HPP_INCLUDED

// Copyright 2017, 2018, 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/endian.hpp>
//#include <boost/hash2/detail/is_constant_evaluated.hpp>
#include <boost/config.hpp>
#include <cstdint>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t read32le( unsigned char const * p ) noexcept
{
 if( !detail::is_constant_evaluated() && endian::native == endian::little )
 {
 std::uint32_t v = 0;
 std::memcpy( &v, p, sizeof(v) );
 return v;
 }
 else
 {
 return
 static_cast<std::uint32_t>( p[0] ) |
 ( static_cast<std::uint32_t>( p[1] ) << 8 ) |
 ( static_cast<std::uint32_t>( p[2] ) << 16 ) |
 ( static_cast<std::uint32_t>( p[3] ) << 24 );
 }
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint64_t read64le( unsigned char const * p ) noexcept
{
 if( !detail::is_constant_evaluated() && endian::native == endian::little )
 {
 std::uint64_t v = 0;
 std::memcpy( &v, p, sizeof(v) );
 return v;
 }
 else
 {
 return
 static_cast<std::uint64_t>( p[0] ) |
 ( static_cast<std::uint64_t>( p[1] ) << 8 ) |
 ( static_cast<std::uint64_t>( p[2] ) << 16 ) |
 ( static_cast<std::uint64_t>( p[3] ) << 24 ) |
 ( static_cast<std::uint64_t>( p[4] ) << 32 ) |
 ( static_cast<std::uint64_t>( p[5] ) << 40 ) |
 ( static_cast<std::uint64_t>( p[6] ) << 48 ) |
 ( static_cast<std::uint64_t>( p[7] ) << 56 );
 }
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t read32be( unsigned char const * p ) noexcept
{
 return
 static_cast<std::uint32_t>( p[3] ) |
 ( static_cast<std::uint32_t>( p[2] ) << 8 ) |
 ( static_cast<std::uint32_t>( p[1] ) << 16 ) |
 ( static_cast<std::uint32_t>( p[0] ) << 24 );
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint64_t read64be( unsigned char const * p ) noexcept
{
 return
 static_cast<std::uint64_t>( p[7] ) |
 ( static_cast<std::uint64_t>( p[6] ) << 8 ) |
 ( static_cast<std::uint64_t>( p[5] ) << 16 ) |
 ( static_cast<std::uint64_t>( p[4] ) << 24 ) |
 ( static_cast<std::uint64_t>( p[3] ) << 32 ) |
 ( static_cast<std::uint64_t>( p[2] ) << 40 ) |
 ( static_cast<std::uint64_t>( p[1] ) << 48 ) |
 ( static_cast<std::uint64_t>( p[0] ) << 56 );
}

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_READ_HPP_INCLUDED

//#include <boost/hash2/get_integral_result.hpp>

#ifndef BOOST_HASH2_GET_INTEGRAL_RESULT_HPP_INCLUDED
#define BOOST_HASH2_GET_INTEGRAL_RESULT_HPP_INCLUDED

// Copyright 2017, 2018 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/read.hpp>
#include <type_traits>
#include <limits>
#include <cstddef>

namespace boost
{
namespace hash2
{

namespace detail
{

// identity

template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == sizeof(U), U>::type
 get_result_multiplier()
{
 return 1;
}

// contraction

// 2 -> 1
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 1, R>::type
 get_result_multiplier()
{
 return 0xBF01;
}

// 4 -> 1
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 1, R>::type
 get_result_multiplier()
{
 return 0x7F7F7F7Fu;
}

// 8 -> 1
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 1, R>::type
 get_result_multiplier()
{
 return 0x7F7F7F7F7F7F7F7Full;
}

// 4 -> 2
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 2, R>::type
 get_result_multiplier()
{
 return 0xBFFF0001u;
}

// 8 -> 2
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 2, R>::type
 get_result_multiplier()
{
 return 0xBFFFBFFFBFFFBFFFull;
}

// 8 -> 4
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 8 && sizeof(U) == 4, R>::type
 get_result_multiplier()
{
 return 0xBFFFFFFF00000001ull;
}

// expansion

// 1 -> 2
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 2, U>::type
 get_result_multiplier()
{
 return 0x7F7F;
}

// 1 -> 4
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 4, U>::type
 get_result_multiplier()
{
 return 0xBFBFBFBFu;
}

// 1 -> 8
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 1 && sizeof(U) == 8, U>::type
 get_result_multiplier()
{
 return 0xDFDFDFDFDFDFDFDFull;
}

// 2 -> 4
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 4, U>::type
 get_result_multiplier()
{
 return 0x7FFF7FFFu;
}

// 2 -> 8
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 2 && sizeof(U) == 8, U>::type
 get_result_multiplier()
{
 return 0x7FFF7FFF7FFF7FFFull;
}

// 4 -> 8
template<class U, class R>
 constexpr typename std::enable_if<sizeof(R) == 4 && sizeof(U) == 8, U>::type
 get_result_multiplier()
{
 return 0x7FFFFFFF7FFFFFFFull;
}

} // namespace detail

// contraction

template<class T, class R>
 typename std::enable_if<std::is_integral<R>::value && (sizeof(R) > sizeof(T)), T>::type
 get_integral_result( R const & r )
{
 static_assert( std::is_integral<T>::value, "T must be integral" );
 static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );

static_assert( std::is_unsigned<R>::value, "R must be unsigned" );

typedef typename std::make_unsigned<T>::type U;

constexpr auto m = detail::get_result_multiplier<U, R>();

return static_cast<T>( static_cast( ( r * m ) >> ( std::numeric_limits<R>::digits - std::numeric_limits::digits ) ) );
}

// identity or expansion

template<class T, class R>
 typename std::enable_if<std::is_integral<R>::value && (sizeof(R) <= sizeof(T)), T>::type
 get_integral_result( R const & r )
{
 static_assert( std::is_integral<T>::value, "T must be integral" );
 static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );

static_assert( std::is_unsigned<R>::value, "R must be unsigned" );

typedef typename std::make_unsigned<T>::type U;

constexpr auto m = detail::get_result_multiplier<U, R>();

return static_cast<T>( static_cast( r * m ) );
}

// array-like R

template<class T, class R>
 typename std::enable_if< !std::is_integral<R>::value, T >::type
 get_integral_result( R const & r )
{
 static_assert( std::is_integral<T>::value, "T must be integral" );
 static_assert( !std::is_same<typename std::remove_cv<T>::type, bool>::value, "T must not be bool" );

static_assert( R().size() >= 8, "Array-like result type is too short" );

return static_cast<T>( detail::read64le( r.data() ) );
}

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_GET_INTEGRAL_RESULT_HPP_INCLUDED

//#include <boost/hash2/flavor.hpp>

#ifndef BOOST_HASH2_FLAVOR_HPP_INCLUDED
#define BOOST_HASH2_FLAVOR_HPP_INCLUDED

// Copyright 2024 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/endian.hpp>
#include <cstdint>

namespace boost
{
namespace hash2
{

struct default_flavor
{
    using size_type = std::uint64_t;
    static constexpr auto byte_order = endian::native;
};

struct little_endian_flavor
{
    using size_type = std::uint64_t;
    static constexpr auto byte_order = endian::little;
};

struct big_endian_flavor
{
    using size_type = std::uint64_t;
    static constexpr auto byte_order = endian::big;
};

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_FLAVOR_HPP_INCLUDED

//#include <boost/hash2/detail/bit_cast.hpp>

#ifndef BOOST_HASH2_DETAIL_BIT_CAST_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_BIT_CAST_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/config.hpp>
#include <boost/config.hpp>
#include <type_traits>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

template<class To, class From> BOOST_CXX14_CONSTEXPR To bit_cast( From const& from ) noexcept
{
 static_assert( sizeof(From) == sizeof(To), "Types must be the same size" );

#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 50000

// std::is_trivially_copyable doesn't exist in libstdc++ 4.x

#else

static_assert( std::is_trivially_copyable<From>::value, "Types must be trivially copyable" );
 static_assert( std::is_trivially_copyable<To>::value, "Types must be trivially copyable" );

#endif

#if defined(BOOST_HASH2_HAS_BUILTIN_BIT_CAST)

return __builtin_bit_cast( To, from );

#else

To to{};
    std::memcpy( &to, &from, sizeof(From) );
    return to;

#endif
}

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_BIT_CAST_HPP_INCLUDED

//#include <boost/hash2/detail/write.hpp>

#ifndef BOOST_HASH2_DETAIL_WRITE_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_WRITE_HPP_INCLUDED

// Copyright 2017, 2018, 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/endian.hpp>
//#include <boost/hash2/detail/is_constant_evaluated.hpp>
#include <boost/config.hpp>
#include <type_traits>
#include <cstdint>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

// little endian

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write16le( unsigned char* p, std::uint16_t v ) noexcept
{
 if( !detail::is_constant_evaluated() && endian::native == endian::little )
 {
 std::memcpy( p, &v, sizeof(v) );
 }
 else
 {
 p[0] = static_cast<unsigned char>( v & 0xFF );
 p[1] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 }
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write32le( unsigned char* p, std::uint32_t v ) noexcept
{
 if( !detail::is_constant_evaluated() && endian::native == endian::little )
 {
 std::memcpy( p, &v, sizeof(v) );
 }
 else
 {
 p[0] = static_cast<unsigned char>( v & 0xFF );
 p[1] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 p[2] = static_cast<unsigned char>( ( v >> 16 ) & 0xFF );
 p[3] = static_cast<unsigned char>( ( v >> 24 ) & 0xFF );
 }
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write64le( unsigned char* p, std::uint64_t v ) noexcept
{
 if( !detail::is_constant_evaluated() && endian::native == endian::little )
 {
 std::memcpy( p, &v, sizeof(v) );
 }
 else
 {
 p[0] = static_cast<unsigned char>( v & 0xFF );
 p[1] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 p[2] = static_cast<unsigned char>( ( v >> 16 ) & 0xFF );
 p[3] = static_cast<unsigned char>( ( v >> 24 ) & 0xFF );
 p[4] = static_cast<unsigned char>( ( v >> 32 ) & 0xFF );
 p[5] = static_cast<unsigned char>( ( v >> 40 ) & 0xFF );
 p[6] = static_cast<unsigned char>( ( v >> 48 ) & 0xFF );
 p[7] = static_cast<unsigned char>( ( v >> 56 ) & 0xFF );
 }
}

// big endian

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write16be( unsigned char* p, std::uint16_t v ) noexcept
{
 p[0] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 p[1] = static_cast<unsigned char>( v & 0xFF );
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write32be( unsigned char* p, std::uint32_t v ) noexcept
{
 p[0] = static_cast<unsigned char>( ( v >> 24 ) & 0xFF );
 p[1] = static_cast<unsigned char>( ( v >> 16 ) & 0xFF );
 p[2] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 p[3] = static_cast<unsigned char>( v & 0xFF );
}

BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write64be( unsigned char* p, std::uint64_t v ) noexcept
{
 p[0] = static_cast<unsigned char>( ( v >> 56 ) & 0xFF );
 p[1] = static_cast<unsigned char>( ( v >> 48 ) & 0xFF );
 p[2] = static_cast<unsigned char>( ( v >> 40 ) & 0xFF );
 p[3] = static_cast<unsigned char>( ( v >> 32 ) & 0xFF );
 p[4] = static_cast<unsigned char>( ( v >> 24 ) & 0xFF );
 p[5] = static_cast<unsigned char>( ( v >> 16 ) & 0xFF );
 p[6] = static_cast<unsigned char>( ( v >> 8 ) & 0xFF );
 p[7] = static_cast<unsigned char>( v & 0xFF );
}

// any endian

// template<class T> BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void write( T v, endian e, unsigned char (&w)[ sizeof(T) ] ) noexcept;

template<class T>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == 1, void>::type
write( T v, endian /*e*/, unsigned char (&w)[ sizeof(T) ] ) noexcept
{
 w[ 0 ] = static_cast<unsigned char>( v );
}

template<class T>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == 2, void>::type
write( T v, endian e, unsigned char (&w)[ sizeof(T) ] ) noexcept
{
 if( e == endian::little )
 {
 write16le( w, static_cast<std::uint16_t>( v ) );
 }
 else
 {
 write16be( w, static_cast<std::uint16_t>( v ) );
 }
}

template<class T>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == 4, void>::type
write( T v, endian e, unsigned char (&w)[ sizeof(T) ] ) noexcept
{
 if( e == endian::little )
 {
 write32le( w, static_cast<std::uint32_t>( v ) );
 }
 else
 {
 write32be( w, static_cast<std::uint32_t>( v ) );
 }
}

template<class T>
BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR
typename std::enable_if<std::is_integral<T>::value && sizeof(T) == 8, void>::type
write( T v, endian e, unsigned char (&w)[ sizeof(T) ] ) noexcept
{
 if( e == endian::little )
 {
 write64le( w, static_cast<std::uint64_t>( v ) );
 }
 else
 {
 write64be( w, static_cast<std::uint64_t>( v ) );
 }
}

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_WRITE_HPP_INCLUDED

//#include <boost/hash2/detail/has_tag_invoke.hpp>

#ifndef BOOST_HASH2_DETAIL_HAS_TAG_INVOKE_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_HAS_TAG_INVOKE_HPP_INCLUDED

// Copyright 2024 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/endian.hpp>
#include <type_traits>
#include <cstdint>
#include <cstddef>

namespace boost
{
namespace hash2
{

struct hash_append_tag;

namespace detail
{

struct hash_archetype
{
    using result_type = std::uint64_t;

hash_archetype();
    explicit hash_archetype( std::uint64_t );
    hash_archetype( unsigned char const*, std::size_t );

void update( void const*, std::size_t );
    result_type result();
};

struct flavor_archetype
{
    using size_type = std::uint32_t;
    static constexpr auto byte_order = endian::native;
};

template<class T, class En = void> struct has_tag_invoke: std::false_type
{
};

template<class T> struct has_tag_invoke<T, decltype(
 tag_invoke( std::declval<hash_append_tag const&>(), std::declval<hash_archetype&>(), std::declval<flavor_archetype const&>(), std::declval<T const&>() ),
 void())>: std::true_type
{
};

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_HAS_TAG_INVOKE_HPP_INCLUDED

// #include <boost/hash2/hash_append.hpp>

#ifndef BOOST_HASH2_HASH_APPEND_HPP_INCLUDED
#define BOOST_HASH2_HASH_APPEND_HPP_INCLUDED

// Copyright 2017, 2018, 2023, 2024 Peter Dimov.
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
//
// Based on
//
// Types Don't Know #
// Howard E. Hinnant, Vinnie Falco, John Bytheway
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3980.html

//#include <boost/hash2/hash_append_fwd.hpp>
//#include <boost/hash2/is_contiguously_hashable.hpp>
//#include <boost/hash2/has_constant_size.hpp>
//#include <boost/hash2/get_integral_result.hpp>
//#include <boost/hash2/flavor.hpp>
//#include <boost/hash2/detail/is_constant_evaluated.hpp>
//#include <boost/hash2/detail/bit_cast.hpp>
//#include <boost/hash2/detail/write.hpp>
//#include <boost/hash2/detail/has_tag_invoke.hpp>
#include <boost/container_hash/is_range.hpp>
#include <boost/container_hash/is_contiguous_range.hpp>
#include <boost/container_hash/is_unordered_range.hpp>
#include <boost/container_hash/is_tuple_like.hpp>
#include <boost/container_hash/is_described_class.hpp>
#include <boost/describe/bases.hpp>
#include <boost/describe/members.hpp>
#include <boost/mp11/algorithm.hpp>
#include <boost/mp11/integer_sequence.hpp>
#include <cstdint>
#include <type_traits>
#include <iterator>

namespace boost
{

template<class T, std::size_t N> class array;

namespace hash2
{

// hash_append_range

namespace detail
{

template<class Hash, class Flavor, class It> BOOST_CXX14_CONSTEXPR void hash_append_range_( Hash& h, Flavor const& f, It first, It last )
{
 for( ; first != last; ++first )
 {
 typename std::iterator_traits<It>::value_type const& v = *first;
 hash2::hash_append( h, f, v );
 }
}

template<class Hash, class Flavor> BOOST_CXX14_CONSTEXPR void hash_append_range_( Hash& h, Flavor const& /*f*/, unsigned char* first, unsigned char* last )
{
 h.update( first, last - first );
}

template<class Hash, class Flavor> BOOST_CXX14_CONSTEXPR void hash_append_range_( Hash& h, Flavor const& /*f*/, unsigned char const* first, unsigned char const* last )
{
 h.update( first, last - first );
}

#if defined(BOOST_NO_CXX14_CONSTEXPR)

template<class Hash, class Flavor, class T>
 typename std::enable_if<
 is_contiguously_hashable<T, Flavor::byte_order>::value, void >::type
 hash_append_range_( Hash& h, Flavor const& /*f*/, T* first, T* last )
{
 h.update( first, (last - first) * sizeof(T) );
}

#else

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if<
 is_contiguously_hashable<T, Flavor::byte_order>::value, void >::type
 hash_append_range_( Hash& h, Flavor const& f, T* first, T* last )
{
 if( !detail::is_constant_evaluated() )
 {
 h.update( first, (last - first) * sizeof(T) );
 }
 else
 {
 for( ; first != last; ++first )
 {
 hash2::hash_append( h, f, *first );
 }
 }
}

#endif

} // namespace detail

template<class Hash, class Flavor = default_flavor, class It> BOOST_CXX14_CONSTEXPR void hash_append_range( Hash& h, Flavor const& f, It first, It last )
{
 detail::hash_append_range_( h, f, first, last );
}

// hash_append_size

template<class Hash, class Flavor = default_flavor, class T> BOOST_CXX14_CONSTEXPR void hash_append_size( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, static_cast<typename Flavor::size_type>( v ) );
}

// hash_append_sized_range

namespace detail
{

template<class Hash, class Flavor, class It> void BOOST_CXX14_CONSTEXPR hash_append_sized_range_( Hash& h, Flavor const& f, It first, It last, std::input_iterator_tag )
{
 typename std::iterator_traits<It>::difference_type m = 0;

for( ; first != last; ++first, ++m )
    {
        hash2::hash_append( h, f, *first );
    }

hash2::hash_append_size( h, f, m );
}

template<class Hash, class Flavor, class It> BOOST_CXX14_CONSTEXPR void hash_append_sized_range_( Hash& h, Flavor const& f, It first, It last, std::random_access_iterator_tag )
{
 hash2::hash_append_range( h, f, first, last );
 hash2::hash_append_size( h, f, last - first );
}

} // namespace detail

template<class Hash, class Flavor = default_flavor, class It> BOOST_CXX14_CONSTEXPR void hash_append_sized_range( Hash& h, Flavor const& f, It first, It last )
{
 detail::hash_append_sized_range_( h, f, first, last, typename std::iterator_traits<It>::iterator_category() );
}

// hash_append_unordered_range

template<class Hash, class Flavor = default_flavor, class It> BOOST_CXX14_CONSTEXPR void hash_append_unordered_range( Hash& h, Flavor const& f, It first, It last )
{
 typename std::iterator_traits<It>::difference_type m = 0;

std::uint64_t w = 0;

for( ; first != last; ++first, ++m )
    {
        Hash h2( h );
        hash2::hash_append( h2, f, *first );

w += hash2::get_integral_result<std::uint64_t>( h2.result() );
 }

hash2::hash_append( h, f, w );
    hash2::hash_append_size( h, f, m );
}

// do_hash_append

struct hash_append_tag
{
};

namespace detail
{

// integral types

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< std::is_integral<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& /*f*/, T const& v )
{
 constexpr auto N = sizeof(T);

unsigned char tmp[ N ] = {};
    detail::write( v, Flavor::byte_order, tmp );

h.update( tmp, N );
}

// enum types

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< std::is_enum<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, static_cast<typename std::underlying_type<T>::type>( v ) );
}

// pointer types
// never constexpr

template<class Hash, class Flavor, class T>
 typename std::enable_if< std::is_pointer<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, reinterpret_cast<std::uintptr_t>( v ) );
}

// floating point

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< std::is_floating_point<T>::value && sizeof(T) == 4, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, detail::bit_cast<std::uint32_t>( v + 0 ) );
}

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< std::is_floating_point<T>::value && sizeof(T) == 8, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, detail::bit_cast<std::uint64_t>( v + 0 ) );
}

// std::nullptr_t
// not constexpr for consistency with T*

template<class Hash, class Flavor, class T>
 typename std::enable_if< std::is_same<T, std::nullptr_t>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append( h, f, static_cast<void*>( v ) );
}

// C arrays

template<class Hash, class Flavor, class T, std::size_t N> BOOST_CXX14_CONSTEXPR void do_hash_append( Hash& h, Flavor const& f, T const (&v)[ N ] )
{
 hash2::hash_append_range( h, f, v + 0, v + N );
}

// contiguous containers and ranges, w/ size

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_contiguous_range<T>::value && !has_constant_size<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append_range( h, f, v.data(), v.data() + v.size() );
 hash2::hash_append_size( h, f, v.size() );
}

// containers and ranges, w/ size

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_range<T>::value && !has_constant_size<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append_sized_range( h, f, v.begin(), v.end() );
}

#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4702) // unreachable code
#endif

// constant size contiguous containers and ranges (std::array, boost::array, hash2::digest)

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_contiguous_range<T>::value && has_constant_size<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 if( v.size() == 0 )
 {
 // A hash_append call must always result in a call to Hash::update
 hash2::hash_append( h, f, '\x00' );
 }
 else
 {
 // std::array<>::data() is only constexpr in C++17; boost::array<>::operator[] isn't constexpr
 hash2::hash_append_range( h, f, &v.front(), &v.front() + v.size() );
 }
}

// constant size non-contiguous containers and ranges

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_range<T>::value && has_constant_size<T>::value && !container_hash::is_contiguous_range<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 if( v.begin() == v.end() )
 {
 // A hash_append call must always result in a call to Hash::update
 hash2::hash_append( h, f, '\x00' );
 }
 else
 {
 hash2::hash_append_range( h, f, v.begin(), v.end() );
 }
}

#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif

// unordered containers (is_unordered_range implies is_range)

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_unordered_range<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 hash2::hash_append_unordered_range( h, f, v.begin(), v.end() );
}

// tuple-likes

template<class Hash, class Flavor, class T, std::size_t... J> BOOST_CXX14_CONSTEXPR void hash_append_tuple( Hash& h, Flavor const& f, T const& v, mp11::integer_sequence<std::size_t, J...> )
{
 using std::get;
 int a[] = { ((void)hash2::hash_append( h, f, get<J>(v) ), 0)... };
 (void)a;
}

template<class Hash, class Flavor, class T> BOOST_CXX14_CONSTEXPR void hash_append_tuple( Hash& h, Flavor const& f, T const& /*v*/, mp11::integer_sequence<std::size_t> )
{
 // A hash_append call must always result in a call to Hash::update
 hash2::hash_append( h, f, '\x00' );
}

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< !container_hash::is_range<T>::value && container_hash::is_tuple_like<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 using Seq = mp11::make_index_sequence<std::tuple_size<T>::value>;
 detail::hash_append_tuple( h, f, v, Seq() );
}

// described classes

#if defined(BOOST_DESCRIBE_CXX14)

#if defined(_MSC_VER) && _MSC_VER == 1900
# pragma warning(push)
# pragma warning(disable: 4100) // unreferenced formal parameter
#endif

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< container_hash::is_described_class<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 static_assert( !std::is_union<T>::value, "Described unions are not supported" );

std::size_t r = 0;

using Bd = describe::describe_bases<T, describe::mod_any_access>;

mp11::mp_for_each<Bd>([&](auto D){

using B = typename decltype(D)::type;
        hash2::hash_append( h, f, (B const&)v );
        ++r;

});

using Md = describe::describe_members<T, describe::mod_any_access>;

mp11::mp_for_each<Md>([&](auto D){

hash2::hash_append( h, f, v.*D.pointer );
        ++r;

});

// A hash_append call must always result in a call to Hash::update

if( r == 0 )
    {
        hash2::hash_append( h, f, '\x00' );
    }
}

#if defined(_MSC_VER) && _MSC_VER == 1900
# pragma warning(pop)
#endif

#endif // defined(BOOST_DESCRIBE_CXX14)

// classes with tag_invoke

template<class Hash, class Flavor, class T>
 BOOST_CXX14_CONSTEXPR
 typename std::enable_if< detail::has_tag_invoke<T>::value, void >::type
 do_hash_append( Hash& h, Flavor const& f, T const& v )
{
 tag_invoke( hash_append_tag(), h, f, v );
}

} // namespace detail

// hash_append

template<class Hash, class Flavor = default_flavor, class T>
BOOST_CXX14_CONSTEXPR void hash_append( Hash& h, Flavor const& f, T const& v )
{
 if( !detail::is_constant_evaluated() && is_contiguously_hashable<T, Flavor::byte_order>::value )
 {
 h.update( &v, sizeof(T) );
 }
 else
 {
 detail::do_hash_append( h, f, v );
 }
}

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_HASH_APPEND_HPP_INCLUDED

//#include <boost/hash2/detail/memcpy.hpp>

#ifndef BOOST_HASH2_DETAIL_MEMCPY_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_MEMCPY_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/is_constant_evaluated.hpp>
#include <boost/config.hpp>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

#if defined(BOOST_NO_CXX14_CONSTEXPR)

BOOST_FORCEINLINE void memcpy( unsigned char* d, unsigned char const* s, std::size_t n ) noexcept
{
    std::memcpy( d, s, n );
}

#else

constexpr void memcpy( unsigned char* d, unsigned char const* s, std::size_t n ) noexcept
{
 if( !detail::is_constant_evaluated() )
 {
 std::memcpy( d, s, n );
 }
 else
 {
 for( std::size_t i = 0; i < n; ++i )
 {
 d[ i ] = s[ i ];
 }
 }
}

#endif

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_MEMCPY_HPP_INCLUDED

//#include <boost/hash2/detail/memcmp.hpp>

#ifndef BOOST_HASH2_DETAIL_MEMCMP_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_MEMCMP_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/is_constant_evaluated.hpp>
#include <boost/config.hpp>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

#if defined(BOOST_NO_CXX14_CONSTEXPR)

BOOST_FORCEINLINE int memcmp( unsigned char const* p, unsigned char const* q, std::size_t n ) noexcept
{
    return std::memcmp( p, q, n );
}

#else

constexpr int memcmp( unsigned char const* p, unsigned char const* q, std::size_t n ) noexcept
{
 if( !detail::is_constant_evaluated() )
 {
 return std::memcmp( p, q, n );
 }
 else
 {
 for( std::size_t i = 0; i < n; ++i )
 {
 if( p[ i ] != q[ i ] ) return p[ i ] - q[ i ];
 }

return 0;
    }
}

#endif

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_MEMCMP_HPP_INCLUDED

//#include <boost/hash2/digest.hpp>

#ifndef BOOST_HASH2_DIGEST_HPP_INCLUDED
#define BOOST_HASH2_DIGEST_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/memcpy.hpp>
//#include <boost/hash2/detail/memcmp.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <string>
#include <iosfwd>
#include <cstddef>

namespace boost
{
namespace hash2
{

template<std::size_t N> class digest
{
private:

unsigned char data_[ N ] = {};

public:

// constructors

digest() = default;

BOOST_CXX14_CONSTEXPR digest( unsigned char const (&v)[ N ] ) noexcept
    {
        detail::memcpy( data_, v, N );
    }

// iteration

using value_type = unsigned char;
    using reference = unsigned char&;
    using const_reference = unsigned char const&;
    using iterator = unsigned char*;
    using const_iterator = unsigned char const*;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;

BOOST_CXX14_CONSTEXPR iterator begin() noexcept { return data_; }
    constexpr const_iterator begin() const noexcept { return data_; }

BOOST_CXX14_CONSTEXPR iterator end() noexcept { return data_ + N; }
    constexpr const_iterator end() const noexcept { return data_ + N; }

// data, size

BOOST_CXX14_CONSTEXPR unsigned char* data() noexcept { return data_; }
    constexpr unsigned char const* data() const noexcept { return data_; }

constexpr size_type size() const noexcept { return N; }
    constexpr size_type max_size() const noexcept { return N; }

// element access

BOOST_CXX14_CONSTEXPR reference operator[]( std::size_t i ) { BOOST_ASSERT( i < N ); return data_[ i ]; }
 BOOST_CXX14_CONSTEXPR const_reference operator[]( std::size_t i ) const { BOOST_ASSERT( i < N ); return data_[ i ]; }

BOOST_CXX14_CONSTEXPR reference front() noexcept { return data_[ 0 ]; }
    constexpr const_reference front() const noexcept { return data_[ 0 ]; }

BOOST_CXX14_CONSTEXPR reference back() noexcept { return data_[ N-1 ]; }
    constexpr const_reference back() const noexcept { return data_[ N-1 ]; }
};

// comparisons

template<std::size_t N> BOOST_CXX14_CONSTEXPR bool operator==( digest<N> const& a, digest<N> const& b ) noexcept
{
 return detail::memcmp( a.data(), b.data(), N ) == 0;
}

template<std::size_t N> BOOST_CXX14_CONSTEXPR bool operator!=( digest<N> const& a, digest<N> const& b ) noexcept
{
 return !( a == b );
}

// to_chars

template<std::size_t N> BOOST_CXX14_CONSTEXPR char* to_chars( digest<N> const& v, char* first, char* last ) noexcept
{
 if( last - first < static_cast<std::ptrdiff_t>( 2 * N ) )
 {
 return nullptr;
 }

constexpr char digits[] = "0123456789abcdef";

for( std::size_t i = 0; i < N; ++i )
 {
 first[ i*2 + 0 ] = digits[ v[i] >> 4 ];
 first[ i*2 + 1 ] = digits[ v[i] & 0x0F ];
 }

return first + N * 2;
}

template<std::size_t N, std::size_t M> BOOST_CXX14_CONSTEXPR void to_chars( digest<N> const& v, char (&w)[ M ] ) noexcept
{
 static_assert( M >= 2 * N + 1, "Output buffer not large enough" );
 *to_chars( v, w, w + M ) = 0;
}

// operator<<

template<std::size_t N> std::ostream& operator<<( std::ostream& os, digest<N> const& v )
{
 char tmp[ 2*N+1 ];
 to_chars( v, tmp );

os << tmp;
 return os;
}

// to_string

template<std::size_t N> std::string to_string( digest<N> const& v )
{
 char tmp[ 2*N+1 ];
 to_chars( v, tmp );

return std::string( tmp, 2*N );
}

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DIGEST_HPP_INCLUDED

//#include <boost/hash2/detail/read.hpp>
//#include <boost/hash2/detail/write.hpp>

#include <https://raw.githubusercontent.com/pdimov/hash2/refs/heads/develop/include/boost/hash2/detail/rot.hpp>

//#include <boost/hash2/detail/memset.hpp>

#ifndef BOOST_HASH2_DETAIL_MEMSET_HPP_INCLUDED
#define BOOST_HASH2_DETAIL_MEMSET_HPP_INCLUDED

// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

//#include <boost/hash2/detail/is_constant_evaluated.hpp>
#include <boost/config.hpp>
#include <cstring>

namespace boost
{
namespace hash2
{
namespace detail
{

#if defined(BOOST_NO_CXX14_CONSTEXPR)

BOOST_FORCEINLINE void memset( unsigned char* p, unsigned char v, std::size_t n ) noexcept
{
    std::memset( p, v, n );
}

#else

constexpr void memset( unsigned char* p, unsigned char v, std::size_t n ) noexcept
{
 if( !detail::is_constant_evaluated() )
 {
 std::memset( p, v, n );
 }
 else
 {
 for( std::size_t i = 0; i < n; ++i )
 {
 p[ i ] = v;
 }
 }
}

#endif

} // namespace detail
} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_DETAIL_MEMSET_HPP_INCLUDED

// #include <boost/hash2/ripemd.hpp>

#ifndef BOOST_HASH2_RIPEMD_HPP_INCLUDED
#define BOOST_HASH2_RIPEMD_HPP_INCLUDED

// Copyright 2017, 2018 Peter Dimov
// Copyright 2024 Christian Mazakas
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
//
// RIPEMD-160 message digest algorithm, https://www.esat.kuleuven.be/cosic/publications/article-317.pdf
//                                      https://homes.esat.kuleuven.be/~bosselae/ripemd/rmd160.c
//                                      https://homes.esat.kuleuven.be/~bosselae/ripemd/rmd160.h
// RIPEMD-128 message digest algorithm, https://homes.esat.kuleuven.be/~bosselae/ripemd/rmd128.txt
//                                      https://homes.esat.kuleuven.be/~bosselae/ripemd/rmd128.c
//                                      https://homes.esat.kuleuven.be/~bosselae/ripemd/rmd128.h

//#include <boost/hash2/hmac.hpp>
//#include <boost/hash2/digest.hpp>
//#include <boost/hash2/detail/read.hpp>
//#include <boost/hash2/detail/write.hpp>
//#include <boost/hash2/detail/rot.hpp>
//#include <boost/hash2/detail/memset.hpp>
#include <boost/assert.hpp>
#include <boost/config.hpp>
#include <cstdint>
#include <cstring>
#include <cstddef>

namespace boost
{
namespace hash2
{

class ripemd_128
{
private:

std::uint32_t state_[ 4 ] = { 0x67452301u, 0xEFCDAB89u, 0x98BADCFEu, 0x10325476u };

static constexpr int N = 64;

unsigned char buffer_[ N ] = {};
    std::size_t m_ = 0; // == n_ % N

std::uint64_t n_ = 0;

private:

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t F1( std::uint32_t x, std::uint32_t y, std::uint32_t z) { return x ^ y ^ z; }
    static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t F2( std::uint32_t x, std::uint32_t y, std::uint32_t z) { return (x & y) | (~x & z); }
    static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t F3( std::uint32_t x, std::uint32_t y, std::uint32_t z) { return (x | ~y) ^ z; }
    static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR std::uint32_t F4( std::uint32_t x, std::uint32_t y, std::uint32_t z) { return (x & z) | (y & ~z); }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R1( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F1(b, c, d) + x;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R2( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F2(b, c, d) + x + 0x5a827999u;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R3( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F3(b, c, d) + x + 0x6ed9eba1u;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R4( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F4(b, c, d) + x + 0x8f1bbcdcu;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR1( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F4(b, c, d) + x + 0x50a28be6u;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR2( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F3(b, c, d) + x + 0x5c4dd124u;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR3( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F2(b, c, d) + x + 0x6d703ef3u;
        a = detail::rotl(a, s);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR4( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t x, std::uint32_t s )
    {
        a += F1(b, c, d) + x;
        a = detail::rotl(a, s);
    }

BOOST_CXX14_CONSTEXPR void transform( unsigned char const block[ 64 ] )
    {
        std::uint32_t aa = state_[ 0 ];
        std::uint32_t bb = state_[ 1 ];
        std::uint32_t cc = state_[ 2 ];
        std::uint32_t dd = state_[ 3 ];

std::uint32_t aaa = state_[ 0 ];
        std::uint32_t bbb = state_[ 1 ];
        std::uint32_t ccc = state_[ 2 ];
        std::uint32_t ddd = state_[ 3 ];

std::uint32_t X[ 16 ] = {};

for( int i = 0; i < 16; ++i )
 {
 X[ i ] = detail::read32le( block + i * 4 );
 }

//  A   B   C   D
        R1(aa, bb, cc, dd, X[ 0], 11);
        R1(dd, aa, bb, cc, X[ 1], 14);
        R1(cc, dd, aa, bb, X[ 2], 15);
        R1(bb, cc, dd, aa, X[ 3], 12);
        R1(aa, bb, cc, dd, X[ 4],  5);
        R1(dd, aa, bb, cc, X[ 5],  8);
        R1(cc, dd, aa, bb, X[ 6],  7);
        R1(bb, cc, dd, aa, X[ 7],  9);
        R1(aa, bb, cc, dd, X[ 8], 11);
        R1(dd, aa, bb, cc, X[ 9], 13);
        R1(cc, dd, aa, bb, X[10], 14);
        R1(bb, cc, dd, aa, X[11], 15);
        R1(aa, bb, cc, dd, X[12],  6);
        R1(dd, aa, bb, cc, X[13],  7);
        R1(cc, dd, aa, bb, X[14],  9);
        R1(bb, cc, dd, aa, X[15],  8);

RR1(aaa, bbb, ccc, ddd, X[ 5],  8);
        RR1(ddd, aaa, bbb, ccc, X[14],  9);
        RR1(ccc, ddd, aaa, bbb, X[ 7],  9);
        RR1(bbb, ccc, ddd, aaa, X[ 0], 11);
        RR1(aaa, bbb, ccc, ddd, X[ 9], 13);
        RR1(ddd, aaa, bbb, ccc, X[ 2], 15);
        RR1(ccc, ddd, aaa, bbb, X[11], 15);
        RR1(bbb, ccc, ddd, aaa, X[ 4],  5);
        RR1(aaa, bbb, ccc, ddd, X[13],  7);
        RR1(ddd, aaa, bbb, ccc, X[ 6],  7);
        RR1(ccc, ddd, aaa, bbb, X[15],  8);
        RR1(bbb, ccc, ddd, aaa, X[ 8], 11);
        RR1(aaa, bbb, ccc, ddd, X[ 1], 14);
        RR1(ddd, aaa, bbb, ccc, X[10], 14);
        RR1(ccc, ddd, aaa, bbb, X[ 3], 12);
        RR1(bbb, ccc, ddd, aaa, X[12],  6);

R2(aa, bb, cc, dd, X[ 7],  7);
        R2(dd, aa, bb, cc, X[ 4],  6);
        R2(cc, dd, aa, bb, X[13],  8);
        R2(bb, cc, dd, aa, X[ 1], 13);
        R2(aa, bb, cc, dd, X[10], 11);
        R2(dd, aa, bb, cc, X[ 6],  9);
        R2(cc, dd, aa, bb, X[15],  7);
        R2(bb, cc, dd, aa, X[ 3], 15);
        R2(aa, bb, cc, dd, X[12],  7);
        R2(dd, aa, bb, cc, X[ 0], 12);
        R2(cc, dd, aa, bb, X[ 9], 15);
        R2(bb, cc, dd, aa, X[ 5],  9);
        R2(aa, bb, cc, dd, X[ 2], 11);
        R2(dd, aa, bb, cc, X[14],  7);
        R2(cc, dd, aa, bb, X[11], 13);
        R2(bb, cc, dd, aa, X[ 8], 12);

RR2(aaa, bbb, ccc, ddd, X[ 6],  9);
        RR2(ddd, aaa, bbb, ccc, X[11], 13);
        RR2(ccc, ddd, aaa, bbb, X[ 3], 15);
        RR2(bbb, ccc, ddd, aaa, X[ 7],  7);
        RR2(aaa, bbb, ccc, ddd, X[ 0], 12);
        RR2(ddd, aaa, bbb, ccc, X[13],  8);
        RR2(ccc, ddd, aaa, bbb, X[ 5],  9);
        RR2(bbb, ccc, ddd, aaa, X[10], 11);
        RR2(aaa, bbb, ccc, ddd, X[14],  7);
        RR2(ddd, aaa, bbb, ccc, X[15],  7);
        RR2(ccc, ddd, aaa, bbb, X[ 8], 12);
        RR2(bbb, ccc, ddd, aaa, X[12],  7);
        RR2(aaa, bbb, ccc, ddd, X[ 4],  6);
        RR2(ddd, aaa, bbb, ccc, X[ 9], 15);
        RR2(ccc, ddd, aaa, bbb, X[ 1], 13);
        RR2(bbb, ccc, ddd, aaa, X[ 2], 11);

R3(aa, bb, cc, dd, X[ 3], 11);
        R3(dd, aa, bb, cc, X[10], 13);
        R3(cc, dd, aa, bb, X[14],  6);
        R3(bb, cc, dd, aa, X[ 4],  7);
        R3(aa, bb, cc, dd, X[ 9], 14);
        R3(dd, aa, bb, cc, X[15],  9);
        R3(cc, dd, aa, bb, X[ 8], 13);
        R3(bb, cc, dd, aa, X[ 1], 15);
        R3(aa, bb, cc, dd, X[ 2], 14);
        R3(dd, aa, bb, cc, X[ 7],  8);
        R3(cc, dd, aa, bb, X[ 0], 13);
        R3(bb, cc, dd, aa, X[ 6],  6);
        R3(aa, bb, cc, dd, X[13],  5);
        R3(dd, aa, bb, cc, X[11], 12);
        R3(cc, dd, aa, bb, X[ 5],  7);
        R3(bb, cc, dd, aa, X[12],  5);

RR3(aaa, bbb, ccc, ddd, X[15],  9);
        RR3(ddd, aaa, bbb, ccc, X[ 5],  7);
        RR3(ccc, ddd, aaa, bbb, X[ 1], 15);
        RR3(bbb, ccc, ddd, aaa, X[ 3], 11);
        RR3(aaa, bbb, ccc, ddd, X[ 7],  8);
        RR3(ddd, aaa, bbb, ccc, X[14],  6);
        RR3(ccc, ddd, aaa, bbb, X[ 6],  6);
        RR3(bbb, ccc, ddd, aaa, X[ 9], 14);
        RR3(aaa, bbb, ccc, ddd, X[11], 12);
        RR3(ddd, aaa, bbb, ccc, X[ 8], 13);
        RR3(ccc, ddd, aaa, bbb, X[12],  5);
        RR3(bbb, ccc, ddd, aaa, X[ 2], 14);
        RR3(aaa, bbb, ccc, ddd, X[10], 13);
        RR3(ddd, aaa, bbb, ccc, X[ 0], 13);
        RR3(ccc, ddd, aaa, bbb, X[ 4],  7);
        RR3(bbb, ccc, ddd, aaa, X[13],  5);

R4(aa, bb, cc, dd, X[ 1], 11);
        R4(dd, aa, bb, cc, X[ 9], 12);
        R4(cc, dd, aa, bb, X[11], 14);
        R4(bb, cc, dd, aa, X[10], 15);
        R4(aa, bb, cc, dd, X[ 0], 14);
        R4(dd, aa, bb, cc, X[ 8], 15);
        R4(cc, dd, aa, bb, X[12],  9);
        R4(bb, cc, dd, aa, X[ 4],  8);
        R4(aa, bb, cc, dd, X[13],  9);
        R4(dd, aa, bb, cc, X[ 3], 14);
        R4(cc, dd, aa, bb, X[ 7],  5);
        R4(bb, cc, dd, aa, X[15],  6);
        R4(aa, bb, cc, dd, X[14],  8);
        R4(dd, aa, bb, cc, X[ 5],  6);
        R4(cc, dd, aa, bb, X[ 6],  5);
        R4(bb, cc, dd, aa, X[ 2], 12);

RR4(aaa, bbb, ccc, ddd, X[ 8], 15);
        RR4(ddd, aaa, bbb, ccc, X[ 6],  5);
        RR4(ccc, ddd, aaa, bbb, X[ 4],  8);
        RR4(bbb, ccc, ddd, aaa, X[ 1], 11);
        RR4(aaa, bbb, ccc, ddd, X[ 3], 14);
        RR4(ddd, aaa, bbb, ccc, X[11], 14);
        RR4(ccc, ddd, aaa, bbb, X[15],  6);
        RR4(bbb, ccc, ddd, aaa, X[ 0], 14);
        RR4(aaa, bbb, ccc, ddd, X[ 5],  6);
        RR4(ddd, aaa, bbb, ccc, X[12],  9);
        RR4(ccc, ddd, aaa, bbb, X[ 2], 12);
        RR4(bbb, ccc, ddd, aaa, X[13],  9);
        RR4(aaa, bbb, ccc, ddd, X[ 9], 12);
        RR4(ddd, aaa, bbb, ccc, X[ 7],  5);
        RR4(ccc, ddd, aaa, bbb, X[10], 15);
        RR4(bbb, ccc, ddd, aaa, X[14],  8);

ddd += cc + state_[ 1 ];
        state_[ 1 ] = state_[ 2 ] + dd + aaa;
        state_[ 2 ] = state_[ 3 ] + aa + bbb;
        state_[ 3 ] = state_[ 0 ] + bb + ccc;
        state_[ 0 ] = ddd;
    }

public:

typedef digest<16> result_type;

static constexpr int block_size = 64;

ripemd_128() = default;

explicit BOOST_CXX14_CONSTEXPR ripemd_128( std::uint64_t seed )
    {
        if( seed != 0 )
        {
            unsigned char tmp[ 8 ] = {};
            detail::write64le( tmp, seed );

update( tmp, 8 );
            result();
        }
    }

BOOST_CXX14_CONSTEXPR ripemd_128( unsigned char const * p, std::size_t n )
    {
        if( n != 0 )
        {
            update( p, n );
            result();
        }
    }

BOOST_CXX14_CONSTEXPR void update( unsigned char const* p, std::size_t n )
    {
        BOOST_ASSERT( m_ == n_ % N );

if( n == 0 ) return;

n_ += n;

if( m_ > 0 )
        {
            std::size_t k = N - m_;

if( n < k )
 {
 k = n;
 }

detail::memcpy( buffer_ + m_, p, k );

p += k;
            n -= k;
            m_ += k;

if( m_ < N ) return;

BOOST_ASSERT( m_ == N );

transform( buffer_ );
            m_ = 0;

detail::memset( buffer_, 0, N );
        }

BOOST_ASSERT( m_ == 0 );

while( n >= N )
        {
            transform( p );

p += N;
            n -= N;
        }

BOOST_ASSERT( n < N );

if( n > 0 )
        {
            detail::memcpy( buffer_, p, n );
            m_ = n;
        }

BOOST_ASSERT( m_ == n_ % N );
    }

void update( void const * pv, std::size_t n )
 {
 unsigned char const* p = static_cast<unsigned char const*>( pv );
 update( p, n );
 }

BOOST_CXX14_CONSTEXPR result_type result()
    {
        BOOST_ASSERT( m_ == n_ % N );

unsigned char bits[ 8 ] = {};

detail::write64le( bits, n_ * 8 );

std::size_t k = m_ < 56? 56 - m_: 120 - m_;

unsigned char padding[ 64 ] = { 0x80 };

update( padding, k );

update( bits, 8 );

BOOST_ASSERT( m_ == 0 );

result_type digest;

for( int i = 0; i < 4; ++i )
 {
 detail::write32le( &digest[ i * 4 ], state_[ i ] );
 }

return digest;
    }
};

class ripemd_160
{
private:

std::uint32_t state_[ 5 ] = { 0x67452301u, 0xefcdab89u, 0x98badcfeu, 0x10325476u, 0xc3d2e1f0u };

static constexpr int N = 64;

unsigned char buffer_[ N ] = {};
    std::size_t m_ = 0; // == n_ % N

std::uint64_t n_ = 0;

private:

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R1( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F1(b, c, d) + x;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R2( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F2(b, c, d) + x + 0x5a827999u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R3( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F3(b, c, d) + x + 0x6ed9eba1u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R4( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F4(b, c, d) + x + 0x8f1bbcdcu;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void R5( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F5(b, c, d) + x + 0xa953fd4eu;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR1( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F5(b, c, d) + x + 0x50a28be6u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR2( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F4(b, c, d) + x + 0x5c4dd124u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR3( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F3(b, c, d) + x + 0x6d703ef3u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR4( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F2(b, c, d) + x + 0x7a6d76e9u;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

static BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void RR5( std::uint32_t & a, std::uint32_t b, std::uint32_t & c, std::uint32_t d, std::uint32_t e, std::uint32_t x, std::uint32_t s )
    {
        a += F1(b, c, d) + x;
        a = detail::rotl(a, s) + e;
        c = detail::rotl(c, 10);
    }

std::uint32_t aaa = state_[ 0 ];
        std::uint32_t bbb = state_[ 1 ];
        std::uint32_t ccc = state_[ 2 ];
        std::uint32_t ddd = state_[ 3 ];
        std::uint32_t eee = state_[ 4 ];

std::uint32_t X[ 16 ] = {};

for( int i = 0; i < 16; ++i )
 {
 X[ i ] = detail::read32le( block + i * 4 );
 }

// each function mutates a and c inputs so that we can easily rotate the arguments when expanding the evaluation
        // of the core algorithm in the paper:
        // T = rotl(A + f(j, B, C, D) + X[i][r[j]] + K[j], s)
        // A = E
        // E = D
        // D = rotl(C, 10)
        // C = B
        // B = T
        // mutating A in-place as T permits us to use it as B in the next call and so on and so forth
        // mutating C in-place permits us to use it as D in later calls as well and so on and so forth

//  A   B   C   D   E
        R1(aa, bb, cc, dd, ee, X[ 0], 11);
        R1(ee, aa, bb, cc, dd, X[ 1], 14);
        R1(dd, ee, aa, bb, cc, X[ 2], 15);
        R1(cc, dd, ee, aa, bb, X[ 3], 12);
        R1(bb, cc, dd, ee, aa, X[ 4],  5);
        R1(aa, bb, cc, dd, ee, X[ 5],  8);
        R1(ee, aa, bb, cc, dd, X[ 6],  7);
        R1(dd, ee, aa, bb, cc, X[ 7],  9);
        R1(cc, dd, ee, aa, bb, X[ 8], 11);
        R1(bb, cc, dd, ee, aa, X[ 9], 13);
        R1(aa, bb, cc, dd, ee, X[10], 14);
        R1(ee, aa, bb, cc, dd, X[11], 15);
        R1(dd, ee, aa, bb, cc, X[12],  6);
        R1(cc, dd, ee, aa, bb, X[13],  7);
        R1(bb, cc, dd, ee, aa, X[14],  9);
        R1(aa, bb, cc, dd, ee, X[15],  8);

RR1(aaa, bbb, ccc, ddd, eee, X[ 5],  8);
        RR1(eee, aaa, bbb, ccc, ddd, X[14],  9);
        RR1(ddd, eee, aaa, bbb, ccc, X[ 7],  9);
        RR1(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
        RR1(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
        RR1(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
        RR1(eee, aaa, bbb, ccc, ddd, X[11], 15);
        RR1(ddd, eee, aaa, bbb, ccc, X[ 4],  5);
        RR1(ccc, ddd, eee, aaa, bbb, X[13],  7);
        RR1(bbb, ccc, ddd, eee, aaa, X[ 6],  7);
        RR1(aaa, bbb, ccc, ddd, eee, X[15],  8);
        RR1(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
        RR1(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
        RR1(ccc, ddd, eee, aaa, bbb, X[10], 14);
        RR1(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
        RR1(aaa, bbb, ccc, ddd, eee, X[12],  6);

R2(ee, aa, bb, cc, dd, X[ 7],  7);
        R2(dd, ee, aa, bb, cc, X[ 4],  6);
        R2(cc, dd, ee, aa, bb, X[13],  8);
        R2(bb, cc, dd, ee, aa, X[ 1], 13);
        R2(aa, bb, cc, dd, ee, X[10], 11);
        R2(ee, aa, bb, cc, dd, X[ 6],  9);
        R2(dd, ee, aa, bb, cc, X[15],  7);
        R2(cc, dd, ee, aa, bb, X[ 3], 15);
        R2(bb, cc, dd, ee, aa, X[12],  7);
        R2(aa, bb, cc, dd, ee, X[ 0], 12);
        R2(ee, aa, bb, cc, dd, X[ 9], 15);
        R2(dd, ee, aa, bb, cc, X[ 5],  9);
        R2(cc, dd, ee, aa, bb, X[ 2], 11);
        R2(bb, cc, dd, ee, aa, X[14],  7);
        R2(aa, bb, cc, dd, ee, X[11], 13);
        R2(ee, aa, bb, cc, dd, X[ 8], 12);

RR2(eee, aaa, bbb, ccc, ddd, X[ 6],  9);
        RR2(ddd, eee, aaa, bbb, ccc, X[11], 13);
        RR2(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
        RR2(bbb, ccc, ddd, eee, aaa, X[ 7],  7);
        RR2(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
        RR2(eee, aaa, bbb, ccc, ddd, X[13],  8);
        RR2(ddd, eee, aaa, bbb, ccc, X[ 5],  9);
        RR2(ccc, ddd, eee, aaa, bbb, X[10], 11);
        RR2(bbb, ccc, ddd, eee, aaa, X[14],  7);
        RR2(aaa, bbb, ccc, ddd, eee, X[15],  7);
        RR2(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
        RR2(ddd, eee, aaa, bbb, ccc, X[12],  7);
        RR2(ccc, ddd, eee, aaa, bbb, X[ 4],  6);
        RR2(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
        RR2(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
        RR2(eee, aaa, bbb, ccc, ddd, X[ 2], 11);

R3(dd, ee, aa, bb, cc, X[ 3], 11);
        R3(cc, dd, ee, aa, bb, X[10], 13);
        R3(bb, cc, dd, ee, aa, X[14],  6);
        R3(aa, bb, cc, dd, ee, X[ 4],  7);
        R3(ee, aa, bb, cc, dd, X[ 9], 14);
        R3(dd, ee, aa, bb, cc, X[15],  9);
        R3(cc, dd, ee, aa, bb, X[ 8], 13);
        R3(bb, cc, dd, ee, aa, X[ 1], 15);
        R3(aa, bb, cc, dd, ee, X[ 2], 14);
        R3(ee, aa, bb, cc, dd, X[ 7],  8);
        R3(dd, ee, aa, bb, cc, X[ 0], 13);
        R3(cc, dd, ee, aa, bb, X[ 6],  6);
        R3(bb, cc, dd, ee, aa, X[13],  5);
        R3(aa, bb, cc, dd, ee, X[11], 12);
        R3(ee, aa, bb, cc, dd, X[ 5],  7);
        R3(dd, ee, aa, bb, cc, X[12],  5);

RR3(ddd, eee, aaa, bbb, ccc, X[15],  9);
        RR3(ccc, ddd, eee, aaa, bbb, X[ 5],  7);
        RR3(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
        RR3(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
        RR3(eee, aaa, bbb, ccc, ddd, X[ 7],  8);
        RR3(ddd, eee, aaa, bbb, ccc, X[14],  6);
        RR3(ccc, ddd, eee, aaa, bbb, X[ 6],  6);
        RR3(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
        RR3(aaa, bbb, ccc, ddd, eee, X[11], 12);
        RR3(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
        RR3(ddd, eee, aaa, bbb, ccc, X[12],  5);
        RR3(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
        RR3(bbb, ccc, ddd, eee, aaa, X[10], 13);
        RR3(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
        RR3(eee, aaa, bbb, ccc, ddd, X[ 4],  7);
        RR3(ddd, eee, aaa, bbb, ccc, X[13],  5);

R4(cc, dd, ee, aa, bb, X[ 1], 11);
        R4(bb, cc, dd, ee, aa, X[ 9], 12);
        R4(aa, bb, cc, dd, ee, X[11], 14);
        R4(ee, aa, bb, cc, dd, X[10], 15);
        R4(dd, ee, aa, bb, cc, X[ 0], 14);
        R4(cc, dd, ee, aa, bb, X[ 8], 15);
        R4(bb, cc, dd, ee, aa, X[12],  9);
        R4(aa, bb, cc, dd, ee, X[ 4],  8);
        R4(ee, aa, bb, cc, dd, X[13],  9);
        R4(dd, ee, aa, bb, cc, X[ 3], 14);
        R4(cc, dd, ee, aa, bb, X[ 7],  5);
        R4(bb, cc, dd, ee, aa, X[15],  6);
        R4(aa, bb, cc, dd, ee, X[14],  8);
        R4(ee, aa, bb, cc, dd, X[ 5],  6);
        R4(dd, ee, aa, bb, cc, X[ 6],  5);
        R4(cc, dd, ee, aa, bb, X[ 2], 12);

RR4(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
        RR4(bbb, ccc, ddd, eee, aaa, X[ 6],  5);
        RR4(aaa, bbb, ccc, ddd, eee, X[ 4],  8);
        RR4(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
        RR4(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
        RR4(ccc, ddd, eee, aaa, bbb, X[11], 14);
        RR4(bbb, ccc, ddd, eee, aaa, X[15],  6);
        RR4(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
        RR4(eee, aaa, bbb, ccc, ddd, X[ 5],  6);
        RR4(ddd, eee, aaa, bbb, ccc, X[12],  9);
        RR4(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
        RR4(bbb, ccc, ddd, eee, aaa, X[13],  9);
        RR4(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
        RR4(eee, aaa, bbb, ccc, ddd, X[ 7],  5);
        RR4(ddd, eee, aaa, bbb, ccc, X[10], 15);
        RR4(ccc, ddd, eee, aaa, bbb, X[14],  8);

R5(bb, cc, dd, ee, aa, X[ 4],  9);
        R5(aa, bb, cc, dd, ee, X[ 0], 15);
        R5(ee, aa, bb, cc, dd, X[ 5],  5);
        R5(dd, ee, aa, bb, cc, X[ 9], 11);
        R5(cc, dd, ee, aa, bb, X[ 7],  6);
        R5(bb, cc, dd, ee, aa, X[12],  8);
        R5(aa, bb, cc, dd, ee, X[ 2], 13);
        R5(ee, aa, bb, cc, dd, X[10], 12);
        R5(dd, ee, aa, bb, cc, X[14],  5);
        R5(cc, dd, ee, aa, bb, X[ 1], 12);
        R5(bb, cc, dd, ee, aa, X[ 3], 13);
        R5(aa, bb, cc, dd, ee, X[ 8], 14);
        R5(ee, aa, bb, cc, dd, X[11], 11);
        R5(dd, ee, aa, bb, cc, X[ 6],  8);
        R5(cc, dd, ee, aa, bb, X[15],  5);
        R5(bb, cc, dd, ee, aa, X[13],  6);

RR5(bbb, ccc, ddd, eee, aaa, X[12] ,  8);
        RR5(aaa, bbb, ccc, ddd, eee, X[15] ,  5);
        RR5(eee, aaa, bbb, ccc, ddd, X[10] , 12);
        RR5(ddd, eee, aaa, bbb, ccc, X[ 4] ,  9);
        RR5(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
        RR5(bbb, ccc, ddd, eee, aaa, X[ 5] ,  5);
        RR5(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
        RR5(eee, aaa, bbb, ccc, ddd, X[ 7] ,  6);
        RR5(ddd, eee, aaa, bbb, ccc, X[ 6] ,  8);
        RR5(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
        RR5(bbb, ccc, ddd, eee, aaa, X[13] ,  6);
        RR5(aaa, bbb, ccc, ddd, eee, X[14] ,  5);
        RR5(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
        RR5(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
        RR5(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
        RR5(bbb, ccc, ddd, eee, aaa, X[11] , 11);

ddd += cc + state_[ 1 ];
        state_[ 1 ] = state_[ 2 ] + dd + eee;
        state_[ 2 ] = state_[ 3 ] + ee + aaa;
        state_[ 3 ] = state_[ 4 ] + aa + bbb;
        state_[ 4 ] = state_[ 0 ] + bb + ccc;
        state_[ 0 ] = ddd;
    }

public:

typedef digest<20> result_type;

static constexpr int block_size = 64;

ripemd_160() = default;

explicit BOOST_CXX14_CONSTEXPR ripemd_160( std::uint64_t seed )
    {
        if( seed != 0 )
        {
            unsigned char tmp[ 8 ] = {};
            detail::write64le( tmp, seed );

update( tmp, 8 );
            result();
        }
    }

BOOST_CXX14_CONSTEXPR ripemd_160( unsigned char const * p, std::size_t n )
    {
        if( n != 0 )
        {
            update( p, n );
            result();
        }
    }

BOOST_CXX14_CONSTEXPR void update( unsigned char const* p, std::size_t n )
    {
        BOOST_ASSERT( m_ == n_ % N );

if( n == 0 ) return;

n_ += n;

if( m_ > 0 )
        {
            std::size_t k = N - m_;

if( n < k )
 {
 k = n;
 }

detail::memcpy( buffer_ + m_, p, k );

p += k;
            n -= k;
            m_ += k;

if( m_ < N ) return;

BOOST_ASSERT( m_ == N );

transform( buffer_ );
            m_ = 0;

detail::memset( buffer_, 0, N );
        }

BOOST_ASSERT( m_ == 0 );

while( n >= N )
        {
            transform( p );

p += N;
            n -= N;
        }

BOOST_ASSERT( n < N );

if( n > 0 )
        {
            detail::memcpy( buffer_, p, n );
            m_ = n;
        }

BOOST_ASSERT( m_ == n_ % N );
    }

void update( void const * pv, std::size_t n )
 {
 unsigned char const* p = static_cast<unsigned char const*>( pv );
 update( p, n );
 }

BOOST_CXX14_CONSTEXPR result_type result()
    {
        BOOST_ASSERT( m_ == n_ % N );

unsigned char bits[ 8 ] = {};

detail::write64le( bits, n_ * 8 );

std::size_t k = m_ < 56? 56 - m_: 120 - m_;

unsigned char padding[ 64 ] = { 0x80 };

update( padding, k );

update( bits, 8 );

BOOST_ASSERT( m_ == 0 );

result_type digest;

for( int i = 0; i < 5; ++i )
 {
 detail::write32le( &digest[ i * 4 ], state_[ i ] );
 }

return digest;
    }
};

//using hmac_ripemd_160 = hmac<ripemd_160>;
//using hmac_ripemd_128 = hmac<ripemd_128>;

} // namespace hash2
} // namespace boost

#endif // #ifndef BOOST_HASH2_RIPEMD_HPP_INCLUDED

#include <boost/describe/class.hpp>
#include <vector>
#include <print>
#include

#include <bit>
#include <vector>
#include 
#include <print>
#include <set>
#include <map>
#include <chrono>
#include <ranges>
#include <boost/type.hpp>
#include <boost/type_index.hpp>
#include <boost/mp11/tuple.hpp>
#include <boost/describe/class.hpp>
#include <boost/static_string/static_string.hpp>

namespace sr = std::ranges;
namespace sv = std::views;
namespace sc = std::chrono;
namespace ti = boost::typeindex;

namespace bh2 = boost::hash2;

template <typename Fn>
auto time_fn(Fn&& fn) {
 const auto start = sc::steady_clock::now();
 const auto result = fn();
 const auto end = sc::steady_clock::now();
 return std::pair{sc::round<sc::nanoseconds>(end - start), result};
}

constexpr int num_bench = 200;

constexpr std::array<std::string_view, 100> coins = {
 "BTC", "ETH", "XRP", "USDT", "SOL", "BNB", "DOGE", "ADA", "USDC", "TRX",
 "AVAX", "TON", "SHIB", "DOT", "LINK", "XLM", "HBAR", "BCH", "SUI", "UNI",
 "LTC", "NEAR", "PEPE", "LEO", "APT", "ICP", "POL", "CRO", "VET", "ETC",
 "DAI", "TAO", "FIL", "ARB", "USDe",
 "FET", "RNDR", "ALGO", "KAS", "AAVE", "ATOM", "STX", "TIA", "MNT", "IMX", "XMR",
 "OKB", "OM", "FTM", "OP", "WIF", "INJ", "BONK", "GRT", "THETA", "SEI", "ENA", "ONDO", "SAND", "BGB", "WLD", "RUNE", "GALA",
 "FLOKI", "EOS", "KAIA", "MKR", "BRETT", "JASMY", "PYTH", "FLOW", "LDO",
 "FDUSD", "QNT", "AR", "FLR", "XTZ", "JUP", "IOTA", "VIRTUAL", "STRK", "BSV", "BEAM", "BTT", "KCS", "MANA", "NEO", "CORE", "EGLD", "ENS",
 "AXS", "RAY", "APE", "HNT", "MATIC", "CRV", "POPCAT", "AIOZ", "AERO", "PNUT"
};

template <typename Str>
static constexpr size_t max_str_size = [] <typename Str_ = Str> {
 if constexpr (requires { Str_::static_capacity; }) {
 return Str_::static_capacity;
 } else if constexpr (std::is_same_v<std::string, Str_>) {
 return Str{}.max_size();
 }
}();

template <typename Str>
std::vector<Str> get_pairs() {
 std::vector<Str> result;
 for (const auto& first : coins) {
 for (const auto& second : coins) {
 if (first < second) {
 // horrible perf, but fine for example
 std::string pair = std::string{first} + "-" + std::string{second};
 if (pair.size() > max_str_size<Str>) {
 continue;
 }
 result.emplace_back(pair.data(), pair.size());
 }
 }
 }
 return result;
}

template <typename Str, class H>
struct Hash {
 inline static std::string desc = "Hash";

[[gnu::always_inline]]
 std::size_t operator()(const Str& str) const {
 H h;
 bh2::hash_append(h, {}, str);
 //restrict hashes to small result ones
 static_assert(std::is_same_v<size_t, std::remove_cvref_t<decltype(h.result())>> ||
 std::is_same_v<uint32_t, std::remove_cvref_t<decltype(h.result())>>);
 return h.result();
 }
};

// Same as Hash, but we exploit the fact we are only item being used to produce entire hash so we skip size encode.
// If prefer_constant_arg_value we use fact that our strings are limited in max size to chop up calls to hash_append
// with n argument that is constant since it seems optimizer likes that for some hashes.
// If hash_size is true we also hash size so we must produce same result as Hash.
// Sanity/prediction: if prefer_constant_arg_value is false and hash_size is true performance should be very similar to Hash.
template <typename Str, class H, bool prefer_constant_arg_value, bool hash_size>
struct HashOne {
 // can be any value, used this so I can check the result with some online tool so it is a "typable" char.
 static constexpr char filler = '?';
 inline static std::string desc = [] {
 std::string result{"Hash one "};
 if constexpr (prefer_constant_arg_value) {
 result += "prefers constant arg value, ";
 }
 if constexpr (hash_size) {
 result += "hashes size";
 }
 return result;
 }();

[[gnu::always_inline]]
 std::size_t operator()(const Str& str) const {
 H h;
 const auto sz = str.size();
 const auto* data = str.data();
 // we must hash something, if we do not hash size we just always add prefix
 if constexpr (!hash_size) {
 bh2::hash_append(h, {}, filler);
 }
 if constexpr (prefer_constant_arg_value) {
 if (sz < 8) {
 bh2::hash_append_range(h, {}, data, data + sz);
 } else {
 bh2::hash_append_range(h, {}, data, data + 8);
 bh2::hash_append_range(h, {}, data + 8, data + sz);
 }
 } else {
 bh2::hash_append_range(h, {}, data, data + sz);
 }

if constexpr (hash_size) {
            bh2::hash_append(h, {}, str.size());
        }

// restrict hashes to small result ones
 static_assert(std::is_same_v<size_t, std::remove_cvref_t<decltype(h.result())>> ||
 std::is_same_v<uint32_t, std::remove_cvref_t<decltype(h.result())>>);
 return h.result();
 }
};

template <typename Str, typename HashType>
void run_benchmark() {
 const auto pairs = get_pairs<Str>();
 const auto [min_it,max_it] = sr::minmax_element(pairs, {}, &Str::size);
 auto run_sum_hash = [&pairs]<typename H>() {
 size_t sum = 0;
#pragma nounroll
 for (const auto& pair : pairs) {
 sum += H{}(pair);
 }
 return sum;
 };
 std::map<std::string, std::set<sc::nanoseconds>> description_to_times;
 for (int i = 0; i < num_bench; ++i) {
 auto run_hasher = [&description_to_times, &run_sum_hash]<typename Hasher>() {
 const auto [time_one, sum] = time_fn([&run_sum_hash] {
 return run_sum_hash.template operator()<Hasher>();
 });
 description_to_times[Hasher::desc].insert(time_one);
 // prevent optimizations removing computations
 if (rand() + rand() == 0) {
 std::print("{:<60}{:<30x}\n", Hasher::desc, sum);
 }
 };
 run_hasher.template operator()<HashOne<Str, HashType, false, false>>();
 run_hasher.template operator()<HashOne<Str, HashType, false, true>>();
 run_hasher.template operator()<HashOne<Str, HashType, true, false>>();
 run_hasher.template operator()<HashOne<Str, HashType, true, true>>();
 run_hasher.template operator()<Hash<Str, HashType>>();
 }
 std::print("\nNum strings {}, min/max len: {}/{}\n", pairs.size(), min_it->size(), max_it->size());
 print("String type:{:<40}\nHash type:{:<40}\n", boost::typeindex::type_id<Str>().pretty_name(), boost::typeindex::type_id<HashType>().pretty_name());
 for (const auto& [desc, times] : description_to_times) {
 std::print("{:<50} best times {:<10} {:<10}\n", desc, *times.begin(), *std::next(times.begin()));
 }
}

void basic_tests() {
 std::string str;
 while (true) {
 // all hashes that hash size must give same result
 const auto h0 = Hash<std::string, bh2::fnv1a_32>{}(str);
 const auto h1 = HashOne<std::string, bh2::fnv1a_32, false, true>{}(str);
 const auto h2 = HashOne<std::string, bh2::fnv1a_32, true, true>{}(str);
 if (str.size() == 6) {
 const auto h_no_size = HashOne<std::string, bh2::fnv1a_32, true, false>{}(str);
 if (h_no_size != 0xc1d598b0) {
 // value from online hasher with filler prepended
 static_assert(HashOne<std::string, bh2::fnv1a_32, true, false>::filler == '?');
 std::terminate();
 }
 }
 if ((h0 != h1) || (h1 != h2)) {
 // bug :(
 std::terminate();
 }
 str.push_back('a');

if (str.size() == std::min(size_t{100}, max_str_size<std::string>)) {
 break;
 }
 }
}

int main() {
 basic_tests();
 [[maybe_unused]] const std::tuple<bh2::fnv1a_32, bh2::fnv1a_64, bh2::xxhash_32, bh2::xxhash_64,
 bh2::siphash_32,
 bh2::siphash_64> all_hashes;
 const std::tuple<bh2::fnv1a_32, bh2::fnv1a_64> fast_hashes;
 const std::tuple<std::string, boost::static_string<14>, boost::static_string<22>> strings;
 static_assert(sizeof(boost::static_string<14>) == 16); // no overhead representation
 boost::mp11::tuple_for_each(strings, [&fast_hashes] <typename Str>(const Str&) {
 boost::mp11::tuple_for_each(fast_hashes, []<typename HashType>(const HashType&) {
 run_benchmark<Str, HashType>();
 });
 });
}