#ifndef CRYPTOPP_MISC_H#define CRYPTOPP_MISC_H#include "config.h"#include "cryptlib.h"#include <assert.h>#include <string.h>		// CodeWarrior doesn't have memory.h#include <algorithm>#include <string>#ifdef INTEL_INTRINSICS#include <stdlib.h>#endifNAMESPACE_BEGIN(CryptoPP)// ************** compile-time assertion ***************template <bool b>struct CompileAssert{	static char dummy[2*b-1];};#define CRYPTOPP_COMPILE_ASSERT(assertion) CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, __LINE__)#define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) static CompileAssert<(assertion)> CRYPTOPP_ASSERT_JOIN(cryptopp_assert_, instance)#define CRYPTOPP_ASSERT_JOIN(X, Y) CRYPTOPP_DO_ASSERT_JOIN(X, Y)#define CRYPTOPP_DO_ASSERT_JOIN(X, Y) X##Y// ************** misc classes ***************class Empty{};template <class BASE1, class BASE2>class TwoBases : public BASE1, public BASE2{};template <class BASE1, class BASE2, class BASE3>class ThreeBases : public BASE1, public BASE2, public BASE3{};template <class T>class ObjectHolder{protected:	T m_object;};class NotCopyable{public:	NotCopyable() {}private:    NotCopyable(const NotCopyable &);    void operator=(const NotCopyable &);};// ************** misc functions ***************// can't use std::min or std::max in MSVC60 or Cygwin 1.1.0template <class _Tp> inline const _Tp& STDMIN(const _Tp& __a, const _Tp& __b){	return __b < __a ? __b : __a;}template <class _Tp> inline const _Tp& STDMAX(const _Tp& __a, const _Tp& __b){	return  __a < __b ? __b : __a;}#define RETURN_IF_NONZERO(x) unsigned int 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])unsigned int Parity(unsigned long);unsigned int BytePrecision(unsigned long);unsigned int BitPrecision(unsigned long);unsigned long Crop(unsigned long, unsigned int size);inline unsigned int BitsToBytes(unsigned int bitCount){	return ((bitCount+7)/(8));}inline unsigned int BytesToWords(unsigned int byteCount){	return ((byteCount+WORD_SIZE-1)/WORD_SIZE);}inline unsigned int BitsToWords(unsigned int bitCount){	return ((bitCount+WORD_BITS-1)/(WORD_BITS));}void xorbuf(byte *buf, const byte *mask, unsigned int count);void xorbuf(byte *output, const byte *input, const byte *mask, unsigned int count);template <class T>inline bool IsPowerOf2(T n){	return n > 0 && (n & (n-1)) == 0;}template <class T1, class T2>inline T2 ModPowerOf2(T1 a, T2 b){	assert(IsPowerOf2(b));	return T2(a) & (b-1);}template <class T>inline T RoundDownToMultipleOf(T n, T m){	return n - (IsPowerOf2(m) ? ModPowerOf2(n, m) : (n%m));}template <class T>inline T RoundUpToMultipleOf(T n, T m){	return RoundDownToMultipleOf(n+m-1, m);}template <class T>inline unsigned int GetAlignment(T *dummy=NULL)	// VC60 workaround{#if (_MSC_VER >= 1300)	return __alignof(T);#elif defined(__GNUC__)	return __alignof__(T);#else	return sizeof(T);#endif}inline bool IsAlignedOn(const void *p, unsigned int alignment){	return IsPowerOf2(alignment) ? ModPowerOf2((unsigned int)p, alignment) == 0 : (unsigned int)p % alignment == 0;}template <class T>inline bool IsAligned(const void *p, T *dummy=NULL)	// VC60 workaround{	return IsAlignedOn(p, GetAlignment<T>());}#ifdef IS_LITTLE_ENDIAN	typedef LittleEndian NativeByteOrder;#else	typedef BigEndian NativeByteOrder;#endifinline ByteOrder GetNativeByteOrder(){	return NativeByteOrder::ToEnum();}inline bool NativeByteOrderIs(ByteOrder order){	return order == GetNativeByteOrder();}template <class T>		// can't use <sstream> because GCC 2.95.2 doesn't have itstd::string IntToString(T a, unsigned int base = 10){	if (a == 0)		return "0";	bool negate = false;	if (a < 0)	{		negate = true;		a = 0-a;	// VC .NET does not like -a	}	std::string result;	while (a > 0)	{		T digit = a % base;		result = char((digit < 10 ? '0' : ('a' - 10)) + digit) + result;		a /= base;	}	if (negate)		result = "-" + result;	return result;}template <class T1, class T2>inline T1 SaturatingSubtract(T1 a, T2 b){	CRYPTOPP_COMPILE_ASSERT_INSTANCE(T1(-1)>0, 0);	// T1 is unsigned type	CRYPTOPP_COMPILE_ASSERT_INSTANCE(T2(-1)>0, 1);	// T2 is unsigned type	return T1((a > b) ? (a - b) : 0);}template <class T>inline CipherDir GetCipherDir(const T &obj){	return obj.IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}// ************** rotate functions ***************template <class T> inline T rotlFixed(T x, unsigned int y){	assert(y < sizeof(T)*8);	return (x<<y) | (x>>(sizeof(T)*8-y));}template <class T> inline T rotrFixed(T x, unsigned int y){	assert(y < sizeof(T)*8);	return (x>>y) | (x<<(sizeof(T)*8-y));}template <class T> inline T rotlVariable(T x, unsigned int y){	assert(y < sizeof(T)*8);	return (x<<y) | (x>>(sizeof(T)*8-y));}template <class T> inline T rotrVariable(T x, unsigned int y){	assert(y < sizeof(T)*8);	return (x>>y) | (x<<(sizeof(T)*8-y));}template <class T> inline T rotlMod(T x, unsigned int y){	y %= sizeof(T)*8;	return (x<<y) | (x>>(sizeof(T)*8-y));}template <class T> inline T rotrMod(T x, unsigned int y){	y %= sizeof(T)*8;	return (x>>y) | (x<<(sizeof(T)*8-y));}#ifdef INTEL_INTRINSICS#pragma intrinsic(_lrotl, _lrotr)template<> inline word32 rotlFixed<word32>(word32 x, unsigned int y){	assert(y < 32);	return y ? _lrotl(x, y) : x;}template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y){	assert(y < 32);	return y ? _lrotr(x, y) : x;}template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y){	assert(y < 32);	return _lrotl(x, y);}template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y){	assert(y < 32);	return _lrotr(x, y);}template<> inline word32 rotlMod<word32>(word32 x, unsigned int y){	return _lrotl(x, y);}template<> inline word32 rotrMod<word32>(word32 x, unsigned int y){	return _lrotr(x, y);}#endif // #ifdef INTEL_INTRINSICS#ifdef PPC_INTRINSICStemplate<> inline word32 rotlFixed<word32>(word32 x, unsigned int y){	assert(y < 32);	return y ? __rlwinm(x,y,0,31) : x;}template<> inline word32 rotrFixed<word32>(word32 x, unsigned int y){	assert(y < 32);	return y ? __rlwinm(x,32-y,0,31) : x;}template<> inline word32 rotlVariable<word32>(word32 x, unsigned int y){	assert(y < 32);	return (__rlwnm(x,y,0,31));}template<> inline word32 rotrVariable<word32>(word32 x, unsigned int y){	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 // #ifdef PPC_INTRINSICS// ************** 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){	return rotlFixed(value, 8U);}inline word32 ByteReverse(word32 value){