misc.h

Go to the documentation of this file.

// misc.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_MISC_H
#define CRYPTOPP_MISC_H
 
#include "config.h"
 
#include "cryptlib.h"
#include "secblockfwd.h"
#include "smartptr.h"
#include "stdcpp.h"
#include "trap.h"
 
#if !defined(CRYPTOPP_DOXYGEN_PROCESSING)
 
#if (CRYPTOPP_MSC_VERSION)
# pragma warning(push)
# pragma warning(disable: 4146 4514)
# if (CRYPTOPP_MSC_VERSION >= 1400)
#  pragma warning(disable: 6326)
# endif
#endif
 
// Issue 340 and Issue 793
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wconversion"
# pragma GCC diagnostic ignored "-Wsign-conversion"
# pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
#ifdef _MSC_VER
        #if _MSC_VER >= 1400
                // VC2005 workaround: disable declarations that conflict with winnt.h
                #define _interlockedbittestandset CRYPTOPP_DISABLED_INTRINSIC_1
                #define _interlockedbittestandreset CRYPTOPP_DISABLED_INTRINSIC_2
                #define _interlockedbittestandset64 CRYPTOPP_DISABLED_INTRINSIC_3
                #define _interlockedbittestandreset64 CRYPTOPP_DISABLED_INTRINSIC_4
                #include <intrin.h>
                #undef _interlockedbittestandset
                #undef _interlockedbittestandreset
                #undef _interlockedbittestandset64
                #undef _interlockedbittestandreset64
                #define CRYPTOPP_FAST_ROTATE(x) 1
        #elif _MSC_VER >= 1300
                #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32 | (x) == 64)
        #else
                #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32)
        #endif
#elif (defined(__MWERKS__) && TARGET_CPU_PPC) || \
        (defined(__GNUC__) && (defined(_ARCH_PWR2) || defined(_ARCH_PWR) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || defined(_ARCH_COM)))
        #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32)
#elif defined(__GNUC__) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X86)        // depend on GCC's peephole optimization to generate rotate instructions
        #define CRYPTOPP_FAST_ROTATE(x) 1
#else
        #define CRYPTOPP_FAST_ROTATE(x) 0
#endif
 
#ifdef __BORLANDC__
#include <mem.h>
#include <stdlib.h>
#endif
 
#if (defined(__GNUC__) || defined(__clang__)) && defined(__linux__)
#define CRYPTOPP_BYTESWAP_AVAILABLE 1
#include <byteswap.h>
#endif
 
// Limit to ARM A-32. Aarch64 is failing self tests.
#if defined(__arm__) && (defined(__GNUC__) || defined(__clang__)) && (__ARM_ARCH >= 6)
#define CRYPTOPP_ARM_BYTEREV_AVAILABLE 1
#endif
 
// Limit to ARM A-32. Aarch64 is failing self tests.
#if defined(__arm__) && (defined(__GNUC__) || defined(__clang__)) && (__ARM_ARCH >= 7)
#define CRYPTOPP_ARM_BITREV_AVAILABLE 1
#endif
 
#if defined(__BMI__)
# include <x86intrin.h>
# include <immintrin.h>
#endif  // GCC and BMI
 
// More LLVM bullshit. Apple Clang 6.0 does not define them.
// Later version of Clang defines them and results in warnings.
#if defined(__clang__)
# ifndef _blsr_u32
#  define _blsr_u32 __blsr_u32
# endif
# ifndef _blsr_u64
#  define _blsr_u64 __blsr_u64
# endif
# ifndef _tzcnt_u32
#  define _tzcnt_u32 __tzcnt_u32
# endif
# ifndef _tzcnt_u64
#  define _tzcnt_u64 __tzcnt_u64
# endif
#endif
 
#endif  // CRYPTOPP_DOXYGEN_PROCESSING
 
#if CRYPTOPP_DOXYGEN_PROCESSING
#  define SIZE_MAX ...
#else
// Its amazing portability problems still plague this simple concept in 2015.
// http://stackoverflow.com/questions/30472731/which-c-standard-header-defines-size-max
// Avoid NOMINMAX macro on Windows. http://support.microsoft.com/en-us/kb/143208
#ifndef SIZE_MAX
# if defined(__SIZE_MAX__)
#  define SIZE_MAX __SIZE_MAX__
# elif defined(SIZE_T_MAX)
#  define SIZE_MAX SIZE_T_MAX
# elif defined(__SIZE_TYPE__)
#  define SIZE_MAX (~(__SIZE_TYPE__)0)
# else
#  define SIZE_MAX ((std::numeric_limits<size_t>::max)())
# endif
#endif
 
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
NAMESPACE_BEGIN(CryptoPP)
 
// Forward declaration for IntToString specialization
class Integer;
 
// ************** compile-time assertion ***************
 
#if CRYPTOPP_DOXYGEN_PROCESSING
# define CRYPTOPP_COMPILE_ASSERT(expr) { ... }
#elif defined(CRYPTOPP_CXX17_STATIC_ASSERT)
# define CRYPTOPP_COMPILE_ASSERT(expr) static_assert(expr)
#else // CRYPTOPP_DOXYGEN_PROCESSING
template <bool b>
struct CompileAssert
{
        static char dummy[2*b-1];
};
 
#define CRYPTOPP_COMPILE_ASSERT(assertion) CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, __LINE__)
#define CRYPTOPP_ASSERT_JOIN(X, Y) CRYPTOPP_DO_ASSERT_JOIN(X, Y)
#define CRYPTOPP_DO_ASSERT_JOIN(X, Y) X##Y
 
#if defined(CRYPTOPP_EXPORTS) || defined(CRYPTOPP_IMPORTS)
# define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance)
#else
# if defined(__GNUC__) || defined(__clang__)
#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \
       static CompileAssert<(assertion)> \
       CRYPTOPP_ASSERT_JOIN(cryptopp_CRYPTOPP_ASSERT_, instance) __attribute__ ((unused))
# else
#  define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \
       static CompileAssert<(assertion)> \
       CRYPTOPP_ASSERT_JOIN(cryptopp_CRYPTOPP_ASSERT_, instance)
# endif // GCC or Clang
#endif
 
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
// ************** count elements in an array ***************
 
#if CRYPTOPP_DOXYGEN_PROCESSING
# define COUNTOF(arr)
#else
// VS2005 added _countof
#ifndef COUNTOF
# if defined(_MSC_VER) && (_MSC_VER >= 1400)
#  define COUNTOF(x) _countof(x)
# else
#  define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
# endif
#endif // COUNTOF
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
// ************** misc classes ***************
 
class CRYPTOPP_DLL Empty
{
};
 
#if !defined(CRYPTOPP_DOXYGEN_PROCESSING)
template <class BASE1, class BASE2>
class CRYPTOPP_NO_VTABLE TwoBases : public BASE1, public BASE2
{
};
 
template <class BASE1, class BASE2, class BASE3>
class CRYPTOPP_NO_VTABLE ThreeBases : public BASE1, public BASE2, public BASE3
{
};
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
template <class T>
class ObjectHolder
{
protected:
        T m_object;
};
 
class NotCopyable
{
public:
        NotCopyable() {}
#if CRYPTOPP_CXX11_DELETED_FUNCTIONS
        NotCopyable(const NotCopyable &) = delete;
        void operator=(const NotCopyable &) = delete;
#else
private:
        NotCopyable(const NotCopyable &);
        void operator=(const NotCopyable &);
#endif
};
 
template <class T>
struct NewObject
{
        T* operator()() const {return new T;}
};
 
#if CRYPTOPP_DOXYGEN_PROCESSING
#define MEMORY_BARRIER ...
#else
#if defined(CRYPTOPP_CXX11_ATOMIC)
# define MEMORY_BARRIER() std::atomic_thread_fence(std::memory_order_acq_rel)
#elif (_MSC_VER >= 1400)
# pragma intrinsic(_ReadWriteBarrier)
# define MEMORY_BARRIER() _ReadWriteBarrier()
#elif defined(__INTEL_COMPILER)
# define MEMORY_BARRIER() __memory_barrier()
#elif defined(__GNUC__) || defined(__clang__)
# define MEMORY_BARRIER() __asm__ __volatile__ ("" ::: "memory")
#else
# define MEMORY_BARRIER()
#endif
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
template <class T, class F = NewObject<T>, int instance=0>
class Singleton
{
public:
        Singleton(F objectFactory = F()) : m_objectFactory(objectFactory) {}
 
        // prevent this function from being inlined
        CRYPTOPP_NOINLINE const T & Ref(CRYPTOPP_NOINLINE_DOTDOTDOT) const;
 
private:
        F m_objectFactory;
};
 
template <class T, class F, int instance>
  const T & Singleton<T, F, instance>::Ref(CRYPTOPP_NOINLINE_DOTDOTDOT) const
{
#if defined(CRYPTOPP_CXX11_ATOMIC) && defined(CRYPTOPP_CXX11_SYNCHRONIZATION) && defined(CRYPTOPP_CXX11_STATIC_INIT)
        static std::mutex s_mutex;
        static std::atomic<T*> s_pObject;
 
        T *p = s_pObject.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);
 
        if (p)
                return *p;
 
        std::lock_guard<std::mutex> lock(s_mutex);
        p = s_pObject.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);
 
        if (p)
                return *p;
 
        T *newObject = m_objectFactory();
        s_pObject.store(newObject, std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_release);
 
        return *newObject;
#else
        static volatile simple_ptr<T> s_pObject;
        T *p = s_pObject.m_p;
        MEMORY_BARRIER();
 
        if (p)
                return *p;
 
        T *newObject = m_objectFactory();
        p = s_pObject.m_p;
        MEMORY_BARRIER();
 
        if (p)
        {
                delete newObject;
                return *p;
        }
 
        s_pObject.m_p = newObject;
        MEMORY_BARRIER();
 
        return *newObject;
#endif
}
 
// ************** misc functions ***************
 
template <typename PTR, typename OFF>
inline PTR PtrAdd(PTR pointer, OFF offset)
{
        return pointer+static_cast<ptrdiff_t>(offset);
}
 
template <typename PTR, typename OFF>
inline PTR PtrSub(PTR pointer, OFF offset)
{
        return pointer-static_cast<ptrdiff_t>(offset);
}
 
template <typename PTR>
inline ptrdiff_t PtrDiff(const PTR pointer1, const PTR pointer2)
{
        return pointer1 - pointer2;
}
 
template <typename PTR>
inline size_t PtrByteDiff(const PTR pointer1, const PTR pointer2)
{
        return (size_t)(reinterpret_cast<uintptr_t>(pointer1) - reinterpret_cast<uintptr_t>(pointer2));
}
 
inline byte* BytePtr(std::string& str)
{
        // Caller wants a writable pointer
        CRYPTOPP_ASSERT(str.empty() == false);
 
        if (str.empty())
                return NULLPTR;
        return reinterpret_cast<byte*>(&str[0]);
}
 
byte* BytePtr(SecByteBlock& str);
 
inline const byte* ConstBytePtr(const std::string& str)
{
        if (str.empty())
                return NULLPTR;
        return reinterpret_cast<const byte*>(&str[0]);
}
 
const byte* ConstBytePtr(const SecByteBlock& str);
 
inline size_t BytePtrSize(const std::string& str)
{
        return str.size();
}
 
size_t BytePtrSize(const SecByteBlock& str);
 
#if (CRYPTOPP_CXX11_CONSTEXPR)
template <typename T>
constexpr int EnumToInt(T v) {
        return static_cast<int>(v);
}
#else
#  define EnumToInt(v) static_cast<int>(v)
#endif
 
#if (!__STDC_WANT_SECURE_LIB__ && !defined(_MEMORY_S_DEFINED)) || defined(CRYPTOPP_WANT_SECURE_LIB)
 
inline void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
{
        // Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55
 
        // Pointers must be valid; otherwise undefined behavior
        CRYPTOPP_ASSERT(dest != NULLPTR); CRYPTOPP_ASSERT(src != NULLPTR);
        // Restricted pointers. We want to check ranges, but it is not clear how to do it.
        CRYPTOPP_ASSERT(src != dest);
        // Destination buffer must be large enough to satisfy request
        CRYPTOPP_ASSERT(sizeInBytes >= count);
 
        if (count > sizeInBytes)
                throw InvalidArgument("memcpy_s: buffer overflow");
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4996)
# if (CRYPTOPP_MSC_VERSION >= 1400)
#  pragma warning(disable: 6386)
# endif
#endif
        if (src != NULLPTR && dest != NULLPTR)
                std::memcpy(dest, src, count);
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
}
 
inline void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
{
        // Safer functions on Windows for C&A, http://github.com/weidai11/cryptopp/issues/55
 
        // Pointers must be valid; otherwise undefined behavior
        CRYPTOPP_ASSERT(dest != NULLPTR); CRYPTOPP_ASSERT(src != NULLPTR);
        // Destination buffer must be large enough to satisfy request
        CRYPTOPP_ASSERT(sizeInBytes >= count);
 
        if (count > sizeInBytes)
                throw InvalidArgument("memmove_s: buffer overflow");
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4996)
# if (CRYPTOPP_MSC_VERSION >= 1400)
#  pragma warning(disable: 6386)
# endif
#endif
        if (src != NULLPTR && dest != NULLPTR)
                std::memmove(dest, src, count);
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
}
 
#if __BORLANDC__ >= 0x620
// C++Builder 2010 workaround: can't use std::memcpy_s
// because it doesn't allow 0 lengths
# define memcpy_s CryptoPP::memcpy_s
# define memmove_s CryptoPP::memmove_s
#endif
 
#endif // __STDC_WANT_SECURE_LIB__
 
template <class T>
inline void vec_swap(T& a, T& b)
{
        // __m128i is an unsigned long long[2], and support for swapping it was
        // not added until C++11. SunCC 12.1 - 12.3 fail to consume the swap; while
        // SunCC 12.4 consumes it without -std=c++11.
#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x5120)
        T t;
        t=a, a=b, b=t;
#else
        std::swap(a, b);
#endif
}
 
inline void * memset_z(void *ptr, int val, size_t num)
{
// avoid extraneous warning on GCC 4.3.2 Ubuntu 8.10
#if CRYPTOPP_GCC_VERSION >= 30001 || CRYPTOPP_LLVM_CLANG_VERSION >= 20800 || \
    CRYPTOPP_APPLE_CLANG_VERSION >= 30000
        if (__builtin_constant_p(num) && num==0)
                return ptr;
#endif
        return std::memset(ptr, val, num);
}
 
template <class T> inline const T& STDMIN(const T& a, const T& b)
{
        return b < a ? b : a;
}
 
template <class T> inline const T& STDMAX(const T& a, const T& b)
{
        return a < b ? b : a;
}
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4389)
#endif
 
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wsign-compare"
# pragma GCC diagnostic ignored "-Wstrict-overflow"
# if (CRYPTOPP_LLVM_CLANG_VERSION >= 20800) || (CRYPTOPP_APPLE_CLANG_VERSION >= 30000)
#  pragma GCC diagnostic ignored "-Wtautological-compare"
# elif (CRYPTOPP_GCC_VERSION >= 40300)
#  pragma GCC diagnostic ignored "-Wtype-limits"
# endif
#endif
 
template <class T1, class T2> inline const T1 UnsignedMin(const T1& a, const T2& b)
{
        CRYPTOPP_COMPILE_ASSERT((sizeof(T1)<=sizeof(T2) && T2(-1)>0) || (sizeof(T1)>sizeof(T2) && T1(-1)>0));
        if (sizeof(T1)<=sizeof(T2))
                return b < (T2)a ? (T1)b : a;
        else
                return (T1)b < a ? (T1)b : a;
}
 
template <class T1, class T2>
inline bool SafeConvert(T1 from, T2 &to)
{
        to = static_cast<T2>(from);
        if (from != to || (from > 0) != (to > 0))
                return false;
        return true;
}
 
template <class T>
std::string IntToString(T value, unsigned int base = 10)
{
        // Hack... set the high bit for uppercase.
        const unsigned int HIGH_BIT = (1U << 31);
        const char CH = !!(base & HIGH_BIT) ? 'A' : 'a';
        base &= ~HIGH_BIT;
 
        CRYPTOPP_ASSERT(base >= 2);
        if (value == 0)
                return "0";
 
        bool negate = false;
        if (value < 0)
        {
                negate = true;
                value = 0-value;        // VC .NET does not like -a
        }
        std::string result;
        while (value > 0)
        {
                T digit = value % base;
                result = char((digit < 10 ? '0' : (CH - 10)) + digit) + result;
                value /= base;
        }
        if (negate)
                result = "-" + result;
        return result;
}
 
template <> CRYPTOPP_DLL
std::string IntToString<word64>(word64 value, unsigned int base);
 
template <> CRYPTOPP_DLL
std::string IntToString<Integer>(Integer value, unsigned int base);
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
 
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic pop
#endif
 
#define RETURN_IF_NONZERO(x) size_t returnedValue = x; if (returnedValue) return returnedValue
 
// this version of the macro is fastest on Pentium 3 and Pentium 4 with MSVC 6 SP5 w/ Processor Pack
#define GETBYTE(x, y) (unsigned int)byte((x)>>(8*(y)))
// these may be faster on other CPUs/compilers
// #define GETBYTE(x, y) (unsigned int)(((x)>>(8*(y)))&255)
// #define GETBYTE(x, y) (((byte *)&(x))[y])
 
#define CRYPTOPP_GET_BYTE_AS_BYTE(x, y) byte((x)>>(8*(y)))
 
template <class T>
unsigned int Parity(T value)
{
        for (unsigned int i=8*sizeof(value)/2; i>0; i/=2)
                value ^= value >> i;
        return (unsigned int)value&1;
}
 
template <class T>
unsigned int BytePrecision(const T &value)
{
        if (!value)
                return 0;
 
        unsigned int l=0, h=8*sizeof(value);
        while (h-l > 8)
        {
                unsigned int t = (l+h)/2;
                if (value >> t)
                        l = t;
                else
                        h = t;
        }
 
        return h/8;
}
 
template <class T>
unsigned int BitPrecision(const T &value)
{
        if (!value)
                return 0;
 
        unsigned int l=0, h=8*sizeof(value);
 
        while (h-l > 1)
        {
                unsigned int t = (l+h)/2;
                if (value >> t)
                        l = t;
                else
                        h = t;
        }
 
        return h;
}
 
inline unsigned int TrailingZeros(word32 v)
{
        // GCC 4.7 and VS2012 provides tzcnt on AVX2/BMI enabled processors
        // We don't enable for Microsoft because it requires a runtime check.
        // http://msdn.microsoft.com/en-us/library/hh977023%28v=vs.110%29.aspx
        CRYPTOPP_ASSERT(v != 0);
#if defined(__BMI__)
        return (unsigned int)_tzcnt_u32(v);
#elif defined(__GNUC__) && (CRYPTOPP_GCC_VERSION >= 30400)
        return (unsigned int)__builtin_ctz(v);
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
        unsigned long result;
        _BitScanForward(&result, v);
        return static_cast<unsigned int>(result);
#else
        // from http://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightMultLookup
        static const int MultiplyDeBruijnBitPosition[32] =
        {
          0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
          31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
        };
        return MultiplyDeBruijnBitPosition[((word32)((v & -v) * 0x077CB531U)) >> 27];
#endif
}
 
inline unsigned int TrailingZeros(word64 v)
{
        // GCC 4.7 and VS2012 provides tzcnt on AVX2/BMI enabled processors
        // We don't enable for Microsoft because it requires a runtime check.
        // http://msdn.microsoft.com/en-us/library/hh977023%28v=vs.110%29.aspx
        CRYPTOPP_ASSERT(v != 0);
#if defined(__BMI__) && defined(__x86_64__)
        return (unsigned int)_tzcnt_u64(v);
#elif defined(__GNUC__) && (CRYPTOPP_GCC_VERSION >= 30400)
        return (unsigned int)__builtin_ctzll(v);
#elif defined(_MSC_VER) && (_MSC_VER >= 1400) && (defined(_M_X64) || defined(_M_IA64))
        unsigned long result;
        _BitScanForward64(&result, v);
        return static_cast<unsigned int>(result);
#else
        return word32(v) ? TrailingZeros(word32(v)) : 32 + TrailingZeros(word32(v>>32));
#endif
}
 
template <class T>
inline T Crop(T value, size_t bits)
{
        if (bits < 8*sizeof(value))
        return T(value & ((T(1) << bits) - 1));
        else
                return value;
}
 
inline size_t BitsToBytes(size_t bitCount)
{
        return ((bitCount+7)/(8));
}
 
inline size_t BytesToWords(size_t byteCount)
{
        return ((byteCount+WORD_SIZE-1)/WORD_SIZE);
}
 
inline size_t BitsToWords(size_t bitCount)
{
        return ((bitCount+WORD_BITS-1)/(WORD_BITS));
}
 
inline size_t BitsToDwords(size_t bitCount)
{
        return ((bitCount+2*WORD_BITS-1)/(2*WORD_BITS));
}
 
CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *buf, const byte *mask, size_t count);
 
CRYPTOPP_DLL void CRYPTOPP_API xorbuf(byte *output, const byte *input, const byte *mask, size_t count);
 
CRYPTOPP_DLL bool CRYPTOPP_API VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count);
 
template <class T>
inline bool IsPowerOf2(const T &value)
{
        return value > 0 && (value & (value-1)) == 0;
}
 
#if defined(__BMI__)
template <>
inline bool IsPowerOf2<word32>(const word32 &value)
{
        return value > 0 && _blsr_u32(value) == 0;
}
 
# if defined(__x86_64__)
template <>
inline bool IsPowerOf2<word64>(const word64 &value)
{
        return value > 0 && _blsr_u64(value) == 0;
}
# endif  // __x86_64__
#endif   // __BMI__
 
template<class T>
inline T NumericLimitsMin()
{
        CRYPTOPP_ASSERT(std::numeric_limits<T>::is_specialized);
        return (std::numeric_limits<T>::min)();
}
 
template<class T>
inline T NumericLimitsMax()
{
        CRYPTOPP_ASSERT(std::numeric_limits<T>::is_specialized);
        return (std::numeric_limits<T>::max)();
}
 
// NumericLimitsMin and NumericLimitsMax added for word128 types,
//   see http://github.com/weidai11/cryptopp/issues/364
#if defined(CRYPTOPP_WORD128_AVAILABLE)
template<>
inline word128 NumericLimitsMin()
{
        return 0;
}
template<>
inline word128 NumericLimitsMax()
{
        return (static_cast<word128>(LWORD_MAX) << 64U) | LWORD_MAX;
}
#endif
 
template <class T1, class T2>
inline T1 SaturatingSubtract(const T1 &a, const T2 &b)
{
        // Generated ASM of a typical clamp, http://gcc.gnu.org/ml/gcc-help/2014-10/msg00112.html
        return T1((a > b) ? (a - b) : 0);
}
 
template <class T1, class T2>
inline T1 SaturatingSubtract1(const T1 &a, const T2 &b)
{
        // Generated ASM of a typical clamp, http://gcc.gnu.org/ml/gcc-help/2014-10/msg00112.html
        return T1((a > b) ? (a - b) : 1);
}
 
template <class T1, class T2>
inline T2 ModPowerOf2(const T1 &a, const T2 &b)
{
        CRYPTOPP_ASSERT(IsPowerOf2(b));
    // Coverity finding CID 170383 Overflowed return value (INTEGER_OVERFLOW)
    // Visual Studio and /RTCc warning, https://docs.microsoft.com/en-us/cpp/build/reference/rtc-run-time-error-checks
        return T2(a & SaturatingSubtract(b,1U));
}
 
template <class T1, class T2>
inline T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
{
        // http://github.com/weidai11/cryptopp/issues/364
#if !defined(CRYPTOPP_APPLE_CLANG_VERSION) || (CRYPTOPP_APPLE_CLANG_VERSION >= 80000)
        CRYPTOPP_ASSERT(std::numeric_limits<T1>::is_integer);
        CRYPTOPP_ASSERT(std::numeric_limits<T2>::is_integer);
#endif
 
        CRYPTOPP_ASSERT(!std::numeric_limits<T1>::is_signed || n > 0);
        CRYPTOPP_ASSERT(!std::numeric_limits<T2>::is_signed || m > 0);
 
        if (IsPowerOf2(m))
                return n - ModPowerOf2(n, m);
        else
                return n - n%m;
}
 
template <class T1, class T2>
inline T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
{
        // http://github.com/weidai11/cryptopp/issues/364
#if !defined(CRYPTOPP_APPLE_CLANG_VERSION) || (CRYPTOPP_APPLE_CLANG_VERSION >= 80000)
        CRYPTOPP_ASSERT(std::numeric_limits<T1>::is_integer);
        CRYPTOPP_ASSERT(std::numeric_limits<T2>::is_integer);
#endif
 
        CRYPTOPP_ASSERT(!std::numeric_limits<T1>::is_signed || n > 0);
        CRYPTOPP_ASSERT(!std::numeric_limits<T2>::is_signed || m > 0);
 
        if (NumericLimitsMax<T1>() - m + 1 < n)
                throw InvalidArgument("RoundUpToMultipleOf: integer overflow");
        return RoundDownToMultipleOf(T1(n+m-1), m);
}
 
template <class T>
inline unsigned int GetAlignmentOf()
{
#if defined(CRYPTOPP_CXX11_ALIGNOF)
        return alignof(T);
#elif (_MSC_VER >= 1300)
        return __alignof(T);
#elif defined(__GNUC__)
        return __alignof__(T);
#elif defined(__SUNPRO_CC)
        return __alignof__(T);
#elif defined(__IBM_ALIGNOF__)
        return __alignof__(T);
#elif CRYPTOPP_BOOL_SLOW_WORD64
        return UnsignedMin(4U, sizeof(T));
#else
        return sizeof(T);
#endif
}
 
inline bool IsAlignedOn(const void *ptr, unsigned int alignment)
{
        const uintptr_t x = reinterpret_cast<uintptr_t>(ptr);
        return alignment==1 || (IsPowerOf2(alignment) ? ModPowerOf2(x, alignment) == 0 : x % alignment == 0);
}
 
template <class T>
inline bool IsAligned(const void *ptr)
{
        return IsAlignedOn(ptr, GetAlignmentOf<T>());
}
 
#if (CRYPTOPP_LITTLE_ENDIAN)
typedef LittleEndian NativeByteOrder;
#elif (CRYPTOPP_BIG_ENDIAN)
typedef BigEndian NativeByteOrder;
#else
# error "Unable to determine endianness"
#endif
 
inline ByteOrder GetNativeByteOrder()
{
        return NativeByteOrder::ToEnum();
}
 
inline bool NativeByteOrderIs(ByteOrder order)
{
        return order == GetNativeByteOrder();
}
 
template <class T>
inline CipherDir GetCipherDir(const T &obj)
{
        return obj.IsForwardTransformation() ? ENCRYPTION : DECRYPTION;
}
 
inline void IncrementCounterByOne(byte *inout, unsigned int size)
{
        CRYPTOPP_ASSERT(inout != NULLPTR);
 
        unsigned int carry=1;
        while (carry && size != 0)
        {
                // On carry inout[n] equals 0
                carry = ! ++inout[size-1];
                size--;
        }
}
 
inline void IncrementCounterByOne(byte *output, const byte *input, unsigned int size)
{
        CRYPTOPP_ASSERT(output != NULLPTR);
        CRYPTOPP_ASSERT(input != NULLPTR);
 
        unsigned int carry=1;
        while (carry && size != 0)
        {
                // On carry output[n] equals 0
                carry = ! (output[size-1] = input[size-1] + 1);
                size--;
        }
 
        while (size != 0)
        {
                output[size-1] = input[size-1];
                size--;
        }
}
 
template <class T>
inline void ConditionalSwap(bool c, T &a, T &b)
{
        T t = c * (a ^ b);
        a ^= t;
        b ^= t;
}
 
template <class T>
inline void ConditionalSwapPointers(bool c, T &a, T &b)
{
        ptrdiff_t t = size_t(c) * (a - b);
        a -= t;
        b += t;
}
 
// see http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/protect-secrets.html
// and http://www.securecoding.cert.org/confluence/display/cplusplus/MSC06-CPP.+Be+aware+of+compiler+optimization+when+dealing+with+sensitive+data
 
template <class T>
void SecureWipeBuffer(T *buf, size_t n)
{
        // GCC 4.3.2 on Cygwin optimizes away the first store if this
        // loop is done in the forward direction
        volatile T *p = buf+n;
        while (n--)
                *(--p) = 0;
}
 
#if !defined(CRYPTOPP_DISABLE_ASM) && \
    (_MSC_VER >= 1400 || defined(__GNUC__)) && \
    (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X86)
 
template<> inline void SecureWipeBuffer(byte *buf, size_t n)
{
        volatile byte *p = buf;
#ifdef __GNUC__
        asm volatile("rep stosb" : "+c"(n), "+D"(p) : "a"(0) : "memory");
#else
        __stosb(reinterpret_cast<byte *>(reinterpret_cast<size_t>(p)), 0, n);
#endif
}
 
template<> inline void SecureWipeBuffer(word16 *buf, size_t n)
{
        volatile word16 *p = buf;
#ifdef __GNUC__
        asm volatile("rep stosw" : "+c"(n), "+D"(p) : "a"(0) : "memory");
#else
        __stosw(reinterpret_cast<word16 *>(reinterpret_cast<size_t>(p)), 0, n);
#endif
}
 
template<> inline void SecureWipeBuffer(word32 *buf, size_t n)
{
        volatile word32 *p = buf;
#ifdef __GNUC__
        asm volatile("rep stosl" : "+c"(n), "+D"(p) : "a"(0) : "memory");
#else
        __stosd(reinterpret_cast<unsigned long *>(reinterpret_cast<size_t>(p)), 0, n);
#endif
}
 
template<> inline void SecureWipeBuffer(word64 *buf, size_t n)
{
#if CRYPTOPP_BOOL_X64
        volatile word64 *p = buf;
# ifdef __GNUC__
        asm volatile("rep stosq" : "+c"(n), "+D"(p) : "a"(0) : "memory");
# else
        __stosq(const_cast<word64 *>(p), 0, n);
# endif
#else
        SecureWipeBuffer(reinterpret_cast<word32 *>(buf), 2*n);
#endif
}
 
#endif  // CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X86
 
#if !defined(CRYPTOPP_DISABLE_ASM) && (_MSC_VER >= 1700) && defined(_M_ARM)
template<> inline void SecureWipeBuffer(byte *buf, size_t n)
{
        char *p = reinterpret_cast<char*>(buf+n);
        while (n--)
                __iso_volatile_store8(--p, 0);
}
 
template<> inline void SecureWipeBuffer(word16 *buf, size_t n)
{
        short *p = reinterpret_cast<short*>(buf+n);
        while (n--)
                __iso_volatile_store16(--p, 0);
}
 
template<> inline void SecureWipeBuffer(word32 *buf, size_t n)
{
        int *p = reinterpret_cast<int*>(buf+n);
        while (n--)
                __iso_volatile_store32(--p, 0);
}
 
template<> inline void SecureWipeBuffer(word64 *buf, size_t n)
{
        __int64 *p = reinterpret_cast<__int64*>(buf+n);
        while (n--)
                __iso_volatile_store64(--p, 0);
}
#endif
 
template <class T>
inline void SecureWipeArray(T *buf, size_t n)
{
        if (sizeof(T) % 8 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word64>() == 0)
                SecureWipeBuffer(reinterpret_cast<word64 *>(static_cast<void *>(buf)), n * (sizeof(T)/8));
        else if (sizeof(T) % 4 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word32>() == 0)
                SecureWipeBuffer(reinterpret_cast<word32 *>(static_cast<void *>(buf)), n * (sizeof(T)/4));
        else if (sizeof(T) % 2 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word16>() == 0)
                SecureWipeBuffer(reinterpret_cast<word16 *>(static_cast<void *>(buf)), n * (sizeof(T)/2));
        else
                SecureWipeBuffer(reinterpret_cast<byte *>(static_cast<void *>(buf)), n * sizeof(T));
}
 
std::string StringNarrow(const wchar_t *str, bool throwOnError = true);
 
std::wstring StringWiden(const char *str, bool throwOnError = true);
 
// ************** rotate functions ***************
 
template <unsigned int R, class T> inline T rotlConstant(T x)
{
        // Portable rotate that reduces to single instruction...
        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57157,
        // http://software.intel.com/en-us/forums/topic/580884
        // and http://llvm.org/bugs/show_bug.cgi?id=24226
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(R) < THIS_SIZE);
        return T((x<<R)|(x>>(-R&MASK)));
}
 
template <unsigned int R, class T> inline T rotrConstant(T x)
{
        // Portable rotate that reduces to single instruction...
        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57157,
        // http://software.intel.com/en-us/forums/topic/580884
        // and http://llvm.org/bugs/show_bug.cgi?id=24226
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(R) < THIS_SIZE);
        return T((x >> R)|(x<<(-R&MASK)));
}
 
template <class T> inline T rotlFixed(T x, unsigned int y)
{
        // Portable rotate that reduces to single instruction...
        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57157,
        // http://software.intel.com/en-us/forums/topic/580884
        // and http://llvm.org/bugs/show_bug.cgi?id=24226
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(y) < THIS_SIZE);
        return T((x<<y)|(x>>(-y&MASK)));
}
 
template <class T> inline T rotrFixed(T x, unsigned int y)
{
        // Portable rotate that reduces to single instruction...
        // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57157,
        // http://software.intel.com/en-us/forums/topic/580884
        // and http://llvm.org/bugs/show_bug.cgi?id=24226
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(y) < THIS_SIZE);
        return T((x >> y)|(x<<(-y&MASK)));
}
 
template <class T> inline T rotlVariable(T x, unsigned int y)
{
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(y) < THIS_SIZE);
        return T((x<<y)|(x>>(-y&MASK)));
}
 
template <class T> inline T rotrVariable(T x, unsigned int y)
{
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        CRYPTOPP_ASSERT(static_cast<int>(y) < THIS_SIZE);
        return T((x>>y)|(x<<(-y&MASK)));
}
 
template <class T> inline T rotlMod(T x, unsigned int y)
{
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        return T((x<<(y&MASK))|(x>>(-y&MASK)));
}
 
template <class T> inline T rotrMod(T x, unsigned int y)
{
        CRYPTOPP_CONSTANT(THIS_SIZE = sizeof(T)*8);
        CRYPTOPP_CONSTANT(MASK = THIS_SIZE-1);
        return T((x>>(y&MASK))|(x<<(-y&MASK)));
}
 
#ifdef _MSC_VER
 
template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)
{
        // Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _lrotl(x, static_cast<byte>(y)) : x;
}
 
template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)
{
        // Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _lrotr(x, static_cast<byte>(y)) : x;
}
 
template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return _lrotl(x, static_cast<byte>(y));
}
 
template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return _lrotr(x, static_cast<byte>(y));
}
 
template<> inline word32 rotlMod<word32>(word32 x, unsigned int y)
{
        y %= 8*sizeof(x);
        return _lrotl(x, static_cast<byte>(y));
}
 
template<> inline word32 rotrMod<word32>(word32 x, unsigned int y)
{
        y %= 8*sizeof(x);
        return _lrotr(x, static_cast<byte>(y));
}
 
#endif // #ifdef _MSC_VER
 
#if (_MSC_VER >= 1400) || (defined(_MSC_VER) && !defined(_DLL))
// Intel C++ Compiler 10.0 calls a function instead of using the rotate instruction when using these instructions
 
template<> inline word64 rotlFixed<word64>(word64 x, unsigned int y)
{
        // Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _rotl64(x, static_cast<byte>(y)) : x;
}
 
template<> inline word64 rotrFixed<word64>(word64 x, unsigned int y)
{
        // Uses Microsoft <stdlib.h> call, bound to C/C++ language rules.
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _rotr64(x, static_cast<byte>(y)) : x;
}
 
template<> inline word64 rotlVariable<word64>(word64 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return _rotl64(x, static_cast<byte>(y));
}
 
template<> inline word64 rotrVariable<word64>(word64 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _rotr64(x, static_cast<byte>(y)) : x;
}
 
template<> inline word64 rotlMod<word64>(word64 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _rotl64(x, static_cast<byte>(y)) : x;
}
 
template<> inline word64 rotrMod<word64>(word64 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 8*sizeof(x));
        return y ? _rotr64(x, static_cast<byte>(y)) : x;
}
 
#endif // #if _MSC_VER >= 1310
 
#if _MSC_VER >= 1400 && !defined(__INTEL_COMPILER)
// Intel C++ Compiler 10.0 gives undefined externals with these
template<> inline word16 rotlFixed<word16>(word16 x, unsigned int y)
{
        // Intrinsic, not bound to C/C++ language rules.
        return _rotl16(x, static_cast<byte>(y));
}
 
template<> inline word16 rotrFixed<word16>(word16 x, unsigned int y)
{
        // Intrinsic, not bound to C/C++ language rules.
        return _rotr16(x, static_cast<byte>(y));
}
 
template<> inline word16 rotlVariable<word16>(word16 x, unsigned int y)
{
        return _rotl16(x, static_cast<byte>(y));
}
 
template<> inline word16 rotrVariable<word16>(word16 x, unsigned int y)
{
        return _rotr16(x, static_cast<byte>(y));
}
 
template<> inline word16 rotlMod<word16>(word16 x, unsigned int y)
{
        return _rotl16(x, static_cast<byte>(y));
}
 
template<> inline word16 rotrMod<word16>(word16 x, unsigned int y)
{
        return _rotr16(x, static_cast<byte>(y));
}
 
template<> inline byte rotlFixed<byte>(byte x, unsigned int y)
{
        // Intrinsic, not bound to C/C++ language rules.
        return _rotl8(x, static_cast<byte>(y));
}
 
template<> inline byte rotrFixed<byte>(byte x, unsigned int y)
{
        // Intrinsic, not bound to C/C++ language rules.
        return _rotr8(x, static_cast<byte>(y));
}
 
template<> inline byte rotlVariable<byte>(byte x, unsigned int y)
{
        return _rotl8(x, static_cast<byte>(y));
}
 
template<> inline byte rotrVariable<byte>(byte x, unsigned int y)
{
        return _rotr8(x, static_cast<byte>(y));
}
 
template<> inline byte rotlMod<byte>(byte x, unsigned int y)
{
        return _rotl8(x, static_cast<byte>(y));
}
 
template<> inline byte rotrMod<byte>(byte x, unsigned int y)
{
        return _rotr8(x, static_cast<byte>(y));
}
 
#endif // #if _MSC_VER >= 1400
 
#if (defined(__MWERKS__) && TARGET_CPU_PPC)
 
template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 32);
        return y ? __rlwinm(x,y,0,31) : x;
}
 
template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 32);
        return y ? __rlwinm(x,32-y,0,31) : x;
}
 
template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 32);
        return (__rlwnm(x,y,0,31));
}
 
template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y)
{
        CRYPTOPP_ASSERT(y < 32);
        return (__rlwnm(x,32-y,0,31));
}
 
template<> inline word32 rotlMod<word32>(word32 x, unsigned int y)
{
        return (__rlwnm(x,y,0,31));
}
 
template<> inline word32 rotrMod<word32>(word32 x, unsigned int y)
{
        return (__rlwnm(x,32-y,0,31));
}
 
#endif // __MWERKS__ && TARGET_CPU_PPC
 
// ************** endian reversal ***************
 
template <class T>
inline unsigned int GetByte(ByteOrder order, T value, unsigned int index)
{
        if (order == LITTLE_ENDIAN_ORDER)
                return GETBYTE(value, index);
        else
                return GETBYTE(value, sizeof(T)-index-1);
}
 
inline byte ByteReverse(byte value)
{
        return value;
}
 
inline word16 ByteReverse(word16 value)
{
#if defined(CRYPTOPP_BYTESWAP_AVAILABLE)
        return bswap_16(value);
#elif (_MSC_VER >= 1400) || (defined(_MSC_VER) && !defined(_DLL))
        return _byteswap_ushort(value);
#else
        return rotlFixed(value, 8U);
#endif
}
 
inline word32 ByteReverse(word32 value)
{
#if defined(CRYPTOPP_BYTESWAP_AVAILABLE)
        return bswap_32(value);
#elif defined(CRYPTOPP_ARM_BYTEREV_AVAILABLE)
        word32 rvalue;
        __asm__ ("rev %0, %1" : "=r" (rvalue) : "r" (value));
        return rvalue;
#elif defined(__GNUC__) && defined(CRYPTOPP_X86_ASM_AVAILABLE)
        __asm__ ("bswap %0" : "=r" (value) : "0" (value));
        return value;
#elif defined(__MWERKS__) && TARGET_CPU_PPC
        return (word32)__lwbrx(&value,0);
#elif (_MSC_VER >= 1400) || (defined(_MSC_VER) && !defined(_DLL))
        return _byteswap_ulong(value);
#elif CRYPTOPP_FAST_ROTATE(32) && !defined(__xlC__)
        // 5 instructions with rotate instruction, 9 without
        return (rotrFixed(value, 8U) & 0xff00ff00) | (rotlFixed(value, 8U) & 0x00ff00ff);
#else
        // 6 instructions with rotate instruction, 8 without
        value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
        return rotlFixed(value, 16U);
#endif
}
 
inline word64 ByteReverse(word64 value)
{
#if defined(CRYPTOPP_BYTESWAP_AVAILABLE)
        return bswap_64(value);
#elif defined(__GNUC__) && defined(CRYPTOPP_X86_ASM_AVAILABLE) && defined(__x86_64__)
        __asm__ ("bswap %0" : "=r" (value) : "0" (value));
        return value;
#elif (_MSC_VER >= 1400) || (defined(_MSC_VER) && !defined(_DLL))
        return _byteswap_uint64(value);
#elif CRYPTOPP_BOOL_SLOW_WORD64
        return (word64(ByteReverse(word32(value))) << 32) | ByteReverse(word32(value>>32));
#else
        value = ((value & W64LIT(0xFF00FF00FF00FF00)) >> 8) | ((value & W64LIT(0x00FF00FF00FF00FF)) << 8);
        value = ((value & W64LIT(0xFFFF0000FFFF0000)) >> 16) | ((value & W64LIT(0x0000FFFF0000FFFF)) << 16);
        return rotlFixed(value, 32U);
#endif
}
 
#if defined(CRYPTOPP_WORD128_AVAILABLE)
inline word128 ByteReverse(word128 value)
{
        // TODO: speed this up
        return (word128(ByteReverse(word64(value))) << 64) | ByteReverse(word64(value>>64));
}
#endif
 
inline byte BitReverse(byte value)
{
        value = byte((value & 0xAA) >> 1) | byte((value & 0x55) << 1);
        value = byte((value & 0xCC) >> 2) | byte((value & 0x33) << 2);
        return rotlFixed(value, 4U);
}
 
inline word16 BitReverse(word16 value)
{
#if defined(CRYPTOPP_ARM_BITREV_AVAILABLE)
        // 4 instructions on ARM.
        word32 rvalue;
        __asm__ ("rbit %0, %1" : "=r" (rvalue) : "r" (value));
        return word16(rvalue >> 16);
#else
        // 15 instructions on ARM.
        value = word16((value & 0xAAAA) >> 1) | word16((value & 0x5555) << 1);
        value = word16((value & 0xCCCC) >> 2) | word16((value & 0x3333) << 2);
        value = word16((value & 0xF0F0) >> 4) | word16((value & 0x0F0F) << 4);
        return ByteReverse(value);
#endif
}
 
inline word32 BitReverse(word32 value)
{
#if defined(CRYPTOPP_ARM_BITREV_AVAILABLE)
        // 2 instructions on ARM.
        word32 rvalue;
        __asm__ ("rbit %0, %1" : "=r" (rvalue) : "r" (value));
        return rvalue;
#else
        // 19 instructions on ARM.
        value = word32((value & 0xAAAAAAAA) >> 1) | word32((value & 0x55555555) << 1);
        value = word32((value & 0xCCCCCCCC) >> 2) | word32((value & 0x33333333) << 2);
        value = word32((value & 0xF0F0F0F0) >> 4) | word32((value & 0x0F0F0F0F) << 4);
        return ByteReverse(value);
#endif
}
 
inline word64 BitReverse(word64 value)
{
#if CRYPTOPP_BOOL_SLOW_WORD64
        return (word64(BitReverse(word32(value))) << 32) | BitReverse(word32(value>>32));
#else
        value = word64((value & W64LIT(0xAAAAAAAAAAAAAAAA)) >> 1) | word64((value & W64LIT(0x5555555555555555)) << 1);
        value = word64((value & W64LIT(0xCCCCCCCCCCCCCCCC)) >> 2) | word64((value & W64LIT(0x3333333333333333)) << 2);
        value = word64((value & W64LIT(0xF0F0F0F0F0F0F0F0)) >> 4) | word64((value & W64LIT(0x0F0F0F0F0F0F0F0F)) << 4);
        return ByteReverse(value);
#endif
}
 
template <class T>
inline T BitReverse(T value)
{
        if (sizeof(T) == 1)
                return (T)BitReverse((byte)value);
        else if (sizeof(T) == 2)
                return (T)BitReverse((word16)value);
        else if (sizeof(T) == 4)
                return (T)BitReverse((word32)value);
        else if (sizeof(T) == 8)
                return (T)BitReverse((word64)value);
#if defined(CRYPTOPP_WORD128_AVAILABLE)
        else if (sizeof(T) == 16)
                return (T)BitReverse((word128)value);
#endif
        else
        {
                CRYPTOPP_ASSERT(0);
                return (T)BitReverse((word64)value);
        }
}
 
template <class T>
inline T ConditionalByteReverse(ByteOrder order, T value)
{
        return NativeByteOrderIs(order) ? value : ByteReverse(value);
}
 
template <class T>
void ByteReverse(T *out, const T *in, size_t byteCount)
{
        // Alignment check due to Issues 690
        CRYPTOPP_ASSERT(byteCount % sizeof(T) == 0);
        CRYPTOPP_ASSERT(IsAligned<T>(in));
        CRYPTOPP_ASSERT(IsAligned<T>(out));
 
        size_t count = byteCount/sizeof(T);
        for (size_t i=0; i<count; i++)
                out[i] = ByteReverse(in[i]);
}
 
template <class T>
inline void ConditionalByteReverse(ByteOrder order, T *out, const T *in, size_t byteCount)
{
        if (!NativeByteOrderIs(order))
                ByteReverse(out, in, byteCount);
        else if (in != out)
                memcpy_s(out, byteCount, in, byteCount);
}
 
template <class T>
inline void GetUserKey(ByteOrder order, T *out, size_t outlen, const byte *in, size_t inlen)
{
        const size_t U = sizeof(T);
        CRYPTOPP_ASSERT(inlen <= outlen*U);
        memcpy_s(out, outlen*U, in, inlen);
        memset_z((byte *)out+inlen, 0, outlen*U-inlen);
        ConditionalByteReverse(order, out, out, RoundUpToMultipleOf(inlen, U));
}
 
inline byte UnalignedGetWordNonTemplate(ByteOrder order, const byte *block, const byte *unused)
{
        CRYPTOPP_UNUSED(order); CRYPTOPP_UNUSED(unused);
        return block[0];
}
 
inline word16 UnalignedGetWordNonTemplate(ByteOrder order, const byte *block, const word16 *unused)
{
        CRYPTOPP_UNUSED(unused);
        return (order == BIG_ENDIAN_ORDER)
                ? block[1] | (block[0] << 8)
                : block[0] | (block[1] << 8);
}
 
inline word32 UnalignedGetWordNonTemplate(ByteOrder order, const byte *block, const word32 *unused)
{
        CRYPTOPP_UNUSED(unused);
        return (order == BIG_ENDIAN_ORDER)
                ? word32(block[3]) | (word32(block[2]) << 8) | (word32(block[1]) << 16) | (word32(block[0]) << 24)
                : word32(block[0]) | (word32(block[1]) << 8) | (word32(block[2]) << 16) | (word32(block[3]) << 24);
}
 
inline word64 UnalignedGetWordNonTemplate(ByteOrder order, const byte *block, const word64 *unused)
{
        CRYPTOPP_UNUSED(unused);
        return (order == BIG_ENDIAN_ORDER)
                ?
                (word64(block[7]) |
                (word64(block[6]) <<  8) |
                (word64(block[5]) << 16) |
                (word64(block[4]) << 24) |
                (word64(block[3]) << 32) |
                (word64(block[2]) << 40) |
                (word64(block[1]) << 48) |
                (word64(block[0]) << 56))
                :
                (word64(block[0]) |
                (word64(block[1]) <<  8) |
                (word64(block[2]) << 16) |
                (word64(block[3]) << 24) |
                (word64(block[4]) << 32) |
                (word64(block[5]) << 40) |
                (word64(block[6]) << 48) |
                (word64(block[7]) << 56));
}
 
#if defined(CRYPTOPP_WORD128_AVAILABLE)
inline word128 UnalignedGetWordNonTemplate(ByteOrder order, const byte *block, const word128 *unused)
{
        CRYPTOPP_UNUSED(unused);
        return (order == BIG_ENDIAN_ORDER)
                ?
                (word128(block[15]) |
                (word128(block[14]) <<   8) |
                (word128(block[13]) <<  16) |
                (word128(block[12]) <<  24) |
                (word128(block[11]) <<  32) |
                (word128(block[10]) <<  40) |
                (word128(block[ 9]) <<  48) |
                (word128(block[ 8]) <<  56) |
                (word128(block[ 7]) <<  64) |
                (word128(block[ 6]) <<  72) |
                (word128(block[ 5]) <<  80) |
                (word128(block[ 4]) <<  88) |
                (word128(block[ 3]) <<  96) |
                (word128(block[ 2]) << 104) |
                (word128(block[ 1]) << 112) |
                (word128(block[ 0]) << 120))
                :
                (word128(block[ 0]) |
                (word128(block[ 1]) <<   8) |
                (word128(block[ 2]) <<  16) |
                (word128(block[ 3]) <<  24) |
                (word128(block[ 4]) <<  32) |
                (word128(block[ 5]) <<  40) |
                (word128(block[ 6]) <<  48) |
                (word128(block[ 7]) <<  56) |
                (word128(block[ 8]) <<  64) |
                (word128(block[ 9]) <<  72) |
                (word128(block[10]) <<  80) |
                (word128(block[11]) <<  88) |
                (word128(block[12]) <<  96) |
                (word128(block[13]) << 104) |
                (word128(block[14]) << 112) |
                (word128(block[15]) << 120));
}
#endif
 
inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, byte value, const byte *xorBlock)
{
        CRYPTOPP_UNUSED(order);
        block[0] = static_cast<byte>(xorBlock ? (value ^ xorBlock[0]) : value);
}
 
inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, word16 value, const byte *xorBlock)
{
        if (order == BIG_ENDIAN_ORDER)
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
        }
        else
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                }
        }
}
 
inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, word32 value, const byte *xorBlock)
{
        if (order == BIG_ENDIAN_ORDER)
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
        }
        else
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                }
        }
}
 
inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, word64 value, const byte *xorBlock)
{
        if (order == BIG_ENDIAN_ORDER)
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
        }
        else
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                }
        }
}
 
#if defined(CRYPTOPP_WORD128_AVAILABLE)
inline void UnalignedbyteNonTemplate(ByteOrder order, byte *block, word128 value, const byte *xorBlock)
{
        if (order == BIG_ENDIAN_ORDER)
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 15);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 14);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 13);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 12);
                        block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 11);
                        block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 10);
                        block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value,  9);
                        block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value,  8);
 
                        block[ 8] = xorBlock[ 8] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                        block[ 9] = xorBlock[ 9] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[10] = xorBlock[10] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[11] = xorBlock[11] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[12] = xorBlock[12] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[13] = xorBlock[13] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[14] = xorBlock[14] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[15] = xorBlock[15] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 15);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 14);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 13);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 12);
                        block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 11);
                        block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 10);
                        block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value,  9);
                        block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value,  8);
 
                        block[ 8] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
                        block[ 9] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[10] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[11] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[12] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[13] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[14] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[15] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                }
        }
        else
        {
                if (xorBlock)
                {
                        block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
 
                        block[ 8] = xorBlock[ 8] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value,  8);
                        block[ 9] = xorBlock[ 9] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value,  9);
                        block[10] = xorBlock[10] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 10);
                        block[11] = xorBlock[11] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 11);
                        block[12] = xorBlock[12] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 12);
                        block[13] = xorBlock[13] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 13);
                        block[14] = xorBlock[14] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 14);
                        block[15] = xorBlock[15] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 15);
                }
                else
                {
                        block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
                        block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
                        block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
                        block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
                        block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
                        block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
                        block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
                        block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
 
                        block[ 8] = CRYPTOPP_GET_BYTE_AS_BYTE(value,  8);
                        block[ 9] = CRYPTOPP_GET_BYTE_AS_BYTE(value,  9);
                        block[10] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 10);
                        block[11] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 11);
                        block[12] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 12);
                        block[13] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 13);
                        block[14] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 14);
                        block[15] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 15);
                }
        }
}
#endif
 
template <class T>
inline T GetWord(bool assumeAligned, ByteOrder order, const byte *block)
{
        CRYPTOPP_UNUSED(assumeAligned);
 
        T temp = 0;
        if (block != NULLPTR) {std::memcpy(&temp, block, sizeof(T));}
        return ConditionalByteReverse(order, temp);
}
 
template <class T>
inline void GetWord(bool assumeAligned, ByteOrder order, T &result, const byte *block)
{
        result = GetWord<T>(assumeAligned, order, block);
}
 
template <class T>
inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock = NULLPTR)
{
        CRYPTOPP_UNUSED(assumeAligned);
 
        T t1, t2;
        t1 = ConditionalByteReverse(order, value);
        if (xorBlock != NULLPTR) {std::memcpy(&t2, xorBlock, sizeof(T)); t1 ^= t2;}
        if (block != NULLPTR) {std::memcpy(block, &t1, sizeof(T));}
}
 
template <class T, class B, bool A=false>
class GetBlock
{
public:
        GetBlock(const void *block)
                : m_block((const byte *)block) {}
 
        template <class U>
        inline GetBlock<T, B, A> & operator()(U &x)
        {
                CRYPTOPP_COMPILE_ASSERT(sizeof(U) >= sizeof(T));
                x = GetWord<T>(A, B::ToEnum(), m_block);
                m_block += sizeof(T);
                return *this;
        }
 
private:
        const byte *m_block;
};
 
template <class T, class B, bool A=false>
class PutBlock
{
public:
        PutBlock(const void *xorBlock, void *block)
                : m_xorBlock((const byte *)xorBlock), m_block((byte *)block) {}
 
        template <class U>
        inline PutBlock<T, B, A> & operator()(U x)
        {
                PutWord(A, B::ToEnum(), m_block, (T)x, m_xorBlock);
                m_block += sizeof(T);
                if (m_xorBlock)
                        m_xorBlock += sizeof(T);
                return *this;
        }
 
private:
        const byte *m_xorBlock;
        byte *m_block;
};
 
template <class T, class B, bool GA=false, bool PA=false>
struct BlockGetAndPut
{
        // function needed because of C++ grammatical ambiguity between expression-statements and declarations
        static inline GetBlock<T, B, GA> Get(const void *block) {return GetBlock<T, B, GA>(block);}
        typedef PutBlock<T, B, PA> Put;
};
 
template <class T>
std::string WordToString(T value, ByteOrder order = BIG_ENDIAN_ORDER)
{
        if (!NativeByteOrderIs(order))
                value = ByteReverse(value);
 
        return std::string((char *)&value, sizeof(value));
}
 
template <class T>
T StringToWord(const std::string &str, ByteOrder order = BIG_ENDIAN_ORDER)
{
        T value = 0;
        memcpy_s(&value, sizeof(value), str.data(), UnsignedMin(str.size(), sizeof(value)));
        return NativeByteOrderIs(order) ? value : ByteReverse(value);
}
 
// ************** help remove warning on g++ ***************
 
template <bool overflow> struct SafeShifter;
 
template<> struct SafeShifter<true>
{
        template <class T>
        static inline T RightShift(T value, unsigned int bits)
        {
                CRYPTOPP_UNUSED(value); CRYPTOPP_UNUSED(bits);
                return 0;
        }
 
        template <class T>
        static inline T LeftShift(T value, unsigned int bits)
        {
                CRYPTOPP_UNUSED(value); CRYPTOPP_UNUSED(bits);
                return 0;
        }
};
 
template<> struct SafeShifter<false>
{
        template <class T>
        static inline T RightShift(T value, unsigned int bits)
        {
                return value >> bits;
        }
 
        template <class T>
        static inline T LeftShift(T value, unsigned int bits)
        {
                return value << bits;
        }
};
 
template <unsigned int bits, class T>
inline T SafeRightShift(T value)
{
        return SafeShifter<(bits>=(8*sizeof(T)))>::RightShift(value, bits);
}
 
template <unsigned int bits, class T>
inline T SafeLeftShift(T value)
{
        return SafeShifter<(bits>=(8*sizeof(T)))>::LeftShift(value, bits);
}
 
template<typename InputIt, typename T>
inline InputIt FindIfNot(InputIt first, InputIt last, const T &value) {
#ifdef CRYPTOPP_CXX11_LAMBDA
    return std::find_if(first, last, [&value](const T &o) {
        return value!=o;
    });
#else
    return std::find_if(first, last, std::bind2nd(std::not_equal_to<T>(), value));
#endif
}
 
// ************** use one buffer for multiple data members ***************
 
#define CRYPTOPP_BLOCK_1(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+0);}     size_t SS1() {return       sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_2(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS1());} size_t SS2() {return SS1()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_3(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS2());} size_t SS3() {return SS2()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_4(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS3());} size_t SS4() {return SS3()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_5(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS4());} size_t SS5() {return SS4()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_6(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS5());} size_t SS6() {return SS5()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_7(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS6());} size_t SS7() {return SS6()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCK_8(n, t, s) t* m_##n() {return (t *)(void *)(m_aggregate+SS7());} size_t SS8() {return SS7()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);}
#define CRYPTOPP_BLOCKS_END(i) size_t SST() {return SS##i();} void AllocateBlocks() {m_aggregate.New(SST());} AlignedSecByteBlock m_aggregate;
 
NAMESPACE_END
 
#if (CRYPTOPP_MSC_VERSION)
# pragma warning(pop)
#endif
 
#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
# pragma GCC diagnostic pop
#endif
 
#endif