diff --git a/3way.cpp b/3way.cpp
index 60bd0e13..bd610536 100644
--- a/3way.cpp
+++ b/3way.cpp
@@ -36,14 +36,14 @@ static inline word32 reverseBits(word32 a)
 	a2 = t;							\
 }
 
-#define pi_gamma_pi(a0, a1, a2)		\
-{									\
-	word32 b0, b2;					\
-	b2 = rotlFixed(a2, 1U);				\
-	b0 = rotlFixed(a0, 22U);				\
-	a0 = rotlFixed(b0 ^ (a1|(~b2)), 1U);	\
-	a2 = rotlFixed(b2 ^ (b0|(~a1)), 22U);\
-	a1 ^= (b2|(~b0));				\
+#define pi_gamma_pi(a0, a1, a2)   \
+{                                 \
+	word32 b0, b2;                          \
+	b2 = rotlConstant<1>(a2);               \
+	b0 = rotlConstant<22>(a0);				\
+	a0 = rotlConstant<1>(b0 ^ (a1|(~b2)));	\
+	a2 = rotlConstant<22>(b2 ^ (b0|(~a1))); \
+	a1 ^= (b2|(~b0));                       \
 }
 
 // thanks to Paulo Barreto for this optimized theta()
@@ -51,7 +51,7 @@ static inline word32 reverseBits(word32 a)
 { 															\
 	word32 b0, b1, c; 										\
 	c = a0 ^ a1 ^ a2; 										\
-	c = rotlFixed(c, 16U) ^ rotlFixed(c, 8U);				\
+	c = rotlConstant<16>(c) ^ rotlConstant<8>(c);			\
 	b0 = (a0 << 24) ^ (a2 >> 8) ^ (a1 << 8) ^ (a0 >> 24); 	\
 	b1 = (a1 << 24) ^ (a0 >> 8) ^ (a2 << 8) ^ (a1 >> 24); 	\
 	a0 ^= c ^ b0; 											\
diff --git a/aria.cpp b/aria.cpp
index b2985656..a08f7850 100644
--- a/aria.cpp
+++ b/aria.cpp
@@ -65,7 +65,7 @@ inline byte ARIA_BRF(const word32 x, const int y) {
 
 #define ARIA_P(T0,T1,T2,T3) {                                  \
     (T1) = (((T1)<< 8)&0xff00ff00) ^ (((T1)>> 8)&0x00ff00ff);  \
-    (T2) = rotrFixed((T2),16);                                 \
+    (T2) = rotrConstant<16>(T2);                               \
     (T3) = ByteReverse((T3));                                  \
   }
 
diff --git a/camellia.cpp b/camellia.cpp
index be666fd1..07bd38da 100644
--- a/camellia.cpp
+++ b/camellia.cpp
@@ -29,20 +29,20 @@ NAMESPACE_BEGIN(CryptoPP)
 #define SLOW_ROUND(lh, ll, rh, rl, kh, kl)	{							\
 	word32 zr = ll ^ kl;												\
 	word32 zl = lh ^ kh;												\
-	zr=	rotlFixed(s1[GETBYTE(zr, 3)], 1) |								\
-		(rotrFixed(s1[GETBYTE(zr, 2)], 1) << 24) |						\
-		(s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zr, 1),1)] << 16) |		\
+	zr=	rotlConstant<1>(s1[GETBYTE(zr, 3)]) |							\
+		(rotrConstant<1>(s1[GETBYTE(zr, 2)]) << 24) |					\
+		(s1[rotlConstant<1>(CRYPTOPP_GET_BYTE_AS_BYTE(zr, 1))] << 16) |	\
 		(s1[GETBYTE(zr, 0)] << 8);										\
 	zl=	(s1[GETBYTE(zl, 3)] << 24) |									\
-		(rotlFixed(s1[GETBYTE(zl, 2)], 1) << 16) |						\
-		(rotrFixed(s1[GETBYTE(zl, 1)], 1) << 8) |						\
-		s1[rotlFixed(CRYPTOPP_GET_BYTE_AS_BYTE(zl, 0), 1)];				\
+		(rotlConstant<1>(s1[GETBYTE(zl, 2)]) << 16) |					\
+		(rotrConstant<1>(s1[GETBYTE(zl, 1)]) << 8) |					\
+		s1[rotlConstant<1>(CRYPTOPP_GET_BYTE_AS_BYTE(zl, 0))];			\
 	zl ^= zr;															\
-	zr = zl ^ rotlFixed(zr, 8);											\
-	zl = zr ^ rotrFixed(zl, 8);											\
-	rh ^= rotlFixed(zr, 16);											\
+	zr = zl ^ rotlConstant<8>(zr);										\
+	zl = zr ^ rotrConstant<8>(zl);										\
+	rh ^= rotlConstant<16>(zr);											\
 	rh ^= zl;															\
-	rl ^= rotlFixed(zl, 8);												\
+	rl ^= rotlConstant<8>(zl);											\
 	}
 
 // normal round - same output as above but using larger tables for faster speed
@@ -54,7 +54,7 @@ NAMESPACE_BEGIN(CryptoPP)
 	d ^= u;									\
 	rh ^= d;								\
 	rl ^= d;								\
-	rl ^= rotrFixed(u, 8);}
+	rl ^= rotrConstant<8>(u);}
 
 #define DOUBLE_ROUND(lh, ll, rh, rl, k0, k1, k2, k3)	\
 	ROUND(lh, ll, rh, rl, k0, k1)						\
@@ -202,10 +202,10 @@ void Camellia::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBloc
 #define KS(i, j) ks[i*4 + EFI(j/2)*2 + EFI(j%2)]
 
 #define FL(klh, kll, krh, krl)		\
-	ll ^= rotlFixed(lh & klh, 1);	\
+	ll ^= rotlConstant<1>(lh & klh);\
 	lh ^= (ll | kll);				\
 	rh ^= (rl | krl);				\
-	rl ^= rotlFixed(rh & krh, 1);
+	rl ^= rotlConstant<1>(rh & krh);
 
 	word32 lh, ll, rh, rl;
 	typedef BlockGetAndPut<word32, BigEndian> Block;
diff --git a/chacha.cpp b/chacha.cpp
index 4aeed40b..a63998be 100644
--- a/chacha.cpp
+++ b/chacha.cpp
@@ -12,10 +12,10 @@
 NAMESPACE_BEGIN(CryptoPP)
 
 #define CHACHA_QUARTER_ROUND(a,b,c,d) \
-    a += b; d ^= a; d = rotlFixed<word32>(d,16); \
-    c += d; b ^= c; b = rotlFixed<word32>(b,12); \
-    a += b; d ^= a; d = rotlFixed<word32>(d, 8); \
-    c += d; b ^= c; b = rotlFixed<word32>(b, 7);
+    a += b; d ^= a; d = rotlConstant<16,word32>(d); \
+    c += d; b ^= c; b = rotlConstant<12,word32>(b); \
+    a += b; d ^= a; d = rotlConstant<8,word32>(d); \
+    c += d; b ^= c; b = rotlConstant<7,word32>(b);
 
 #if defined(CRYPTOPP_DEBUG) && !defined(CRYPTOPP_DOXYGEN_PROCESSING)
 void ChaCha_TestInstantiations()
diff --git a/des.cpp b/des.cpp
index 7807e752..144897eb 100644
--- a/des.cpp
+++ b/des.cpp
@@ -77,21 +77,21 @@ static inline void IPERM(word32 &left, word32 &right)
 {
 	word32 work;
 
-	right = rotlFixed(right, 4U);
+	right = rotlConstant<4>(right);
 	work = (left ^ right) & 0xf0f0f0f0;
 	left ^= work;
-	right = rotrFixed(right^work, 20U);
+	right = rotrConstant<20>(right^work);
 	work = (left ^ right) & 0xffff0000;
 	left ^= work;
-	right = rotrFixed(right^work, 18U);
+	right = rotrConstant<18>(right^work);
 	work = (left ^ right) & 0x33333333;
 	left ^= work;
-	right = rotrFixed(right^work, 6U);
+	right = rotrConstant<6>(right^work);
 	work = (left ^ right) & 0x00ff00ff;
 	left ^= work;
-	right = rotlFixed(right^work, 9U);
+	right = rotlConstant<9>(right^work);
 	work = (left ^ right) & 0xaaaaaaaa;
-	left = rotlFixed(left^work, 1U);
+	left = rotlConstant<1>(left^work);
 	right ^= work;
 }
 
@@ -99,22 +99,22 @@ static inline void FPERM(word32 &left, word32 &right)
 {
 	word32 work;
 
-	right = rotrFixed(right, 1U);
+	right = rotrConstant<1>(right);
 	work = (left ^ right) & 0xaaaaaaaa;
 	right ^= work;
-	left = rotrFixed(left^work, 9U);
+	left = rotrConstant<9>(left^work);
 	work = (left ^ right) & 0x00ff00ff;
 	right ^= work;
-	left = rotlFixed(left^work, 6U);
+	left = rotlConstant<6>(left^work);
 	work = (left ^ right) & 0x33333333;
 	right ^= work;
-	left = rotlFixed(left^work, 18U);
+	left = rotlConstant<18>(left^work);
 	work = (left ^ right) & 0xffff0000;
 	right ^= work;
-	left = rotlFixed(left^work, 20U);
+	left = rotlConstant<20>(left^work);
 	work = (left ^ right) & 0xf0f0f0f0;
 	right ^= work;
-	left = rotrFixed(left^work, 4U);
+	left = rotrConstant<4>(left^work);
 }
 
 void DES::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs &)
@@ -340,7 +340,7 @@ void RawDES::RawProcessBlock(word32 &l_, word32 &r_) const
 
 	for (unsigned i=0; i<8; i++)
 	{
-		word32 work = rotrFixed(r, 4U) ^ kptr[4*i+0];
+		word32 work = rotrConstant<4>(r) ^ kptr[4 * i + 0];
 		l ^= Spbox[6][(work) & 0x3f]
 		  ^  Spbox[4][(work >> 8) & 0x3f]
 		  ^  Spbox[2][(work >> 16) & 0x3f]
@@ -351,7 +351,7 @@ void RawDES::RawProcessBlock(word32 &l_, word32 &r_) const
 		  ^  Spbox[3][(work >> 16) & 0x3f]
 		  ^  Spbox[1][(work >> 24) & 0x3f];
 
-		work = rotrFixed(l, 4U) ^ kptr[4*i+2];
+		work = rotrConstant<4>(l) ^ kptr[4 * i + 2];
 		r ^= Spbox[6][(work) & 0x3f]
 		  ^  Spbox[4][(work >> 8) & 0x3f]
 		  ^  Spbox[2][(work >> 16) & 0x3f]
diff --git a/gf2_32.cpp b/gf2_32.cpp
index ab4169ca..51d10a49 100644
--- a/gf2_32.cpp
+++ b/gf2_32.cpp
@@ -23,12 +23,12 @@ GF2_32::Element GF2_32::Multiply(Element a, Element b) const
 	}
 
 #if CRYPTOPP_FAST_ROTATE(32)
-	b = rotrFixed(b, 30U);
+	b = rotrConstant<30>(b);
 	word32 result = table[b&2];
 
 	for (int i=29; i>=0; --i)
 	{
-		b = rotlFixed(b, 1U);
+		b = rotlConstant<1>(b);
 		result = (result<<1) ^ table[(b&2) + (result>>31)];
 	}
 
diff --git a/keccak.cpp b/keccak.cpp
index b9abd396..cc1771cf 100644
--- a/keccak.cpp
+++ b/keccak.cpp
@@ -61,22 +61,22 @@ static void KeccakF1600(word64 *state)
             BCu = Abu^Agu^Aku^Amu^Asu;
 
             //thetaRhoPiChiIotaPrepareTheta(round  , A, E)
-            Da = BCu^rotlFixed(BCe, 1);
-            De = BCa^rotlFixed(BCi, 1);
-            Di = BCe^rotlFixed(BCo, 1);
-            Do = BCi^rotlFixed(BCu, 1);
-            Du = BCo^rotlFixed(BCa, 1);
+            Da = BCu^rotlConstant<1>(BCe);
+            De = BCa^rotlConstant<1>(BCi);
+            Di = BCe^rotlConstant<1>(BCo);
+            Do = BCi^rotlConstant<1>(BCu);
+            Du = BCo^rotlConstant<1>(BCa);
 
             Aba ^= Da;
             BCa = Aba;
             Age ^= De;
-            BCe = rotlFixed(Age, 44);
+            BCe = rotlConstant<44>(Age);
             Aki ^= Di;
-            BCi = rotlFixed(Aki, 43);
+            BCi = rotlConstant<43>(Aki);
             Amo ^= Do;
-            BCo = rotlFixed(Amo, 21);
+            BCo = rotlConstant<21>(Amo);
             Asu ^= Du;
-            BCu = rotlFixed(Asu, 14);
+            BCu = rotlConstant<14>(Asu);
             Eba =   BCa ^((~BCe)&  BCi );
             Eba ^= (word64)KeccakF_RoundConstants[round];
             Ebe =   BCe ^((~BCi)&  BCo );
@@ -85,15 +85,15 @@ static void KeccakF1600(word64 *state)
             Ebu =   BCu ^((~BCa)&  BCe );
 
             Abo ^= Do;
-            BCa = rotlFixed(Abo, 28);
+            BCa = rotlConstant<28>(Abo);
             Agu ^= Du;
-            BCe = rotlFixed(Agu, 20);
+            BCe = rotlConstant<20>(Agu);
             Aka ^= Da;
-            BCi = rotlFixed(Aka,  3);
+            BCi = rotlConstant<3>(Aka);
             Ame ^= De;
-            BCo = rotlFixed(Ame, 45);
+            BCo = rotlConstant<45>(Ame);
             Asi ^= Di;
-            BCu = rotlFixed(Asi, 61);
+            BCu = rotlConstant<61>(Asi);
             Ega =   BCa ^((~BCe)&  BCi );
             Ege =   BCe ^((~BCi)&  BCo );
             Egi =   BCi ^((~BCo)&  BCu );
@@ -101,15 +101,15 @@ static void KeccakF1600(word64 *state)
             Egu =   BCu ^((~BCa)&  BCe );
 
             Abe ^= De;
-            BCa = rotlFixed(Abe,  1);
+            BCa = rotlConstant<1>(Abe);
             Agi ^= Di;
-            BCe = rotlFixed(Agi,  6);
+            BCe = rotlConstant<6>(Agi);
             Ako ^= Do;
-            BCi = rotlFixed(Ako, 25);
+            BCi = rotlConstant<25>(Ako);
             Amu ^= Du;
-            BCo = rotlFixed(Amu,  8);
+            BCo = rotlConstant<8>(Amu);
             Asa ^= Da;
-            BCu = rotlFixed(Asa, 18);
+            BCu = rotlConstant<18>(Asa);
             Eka =   BCa ^((~BCe)&  BCi );
             Eke =   BCe ^((~BCi)&  BCo );
             Eki =   BCi ^((~BCo)&  BCu );
@@ -117,15 +117,15 @@ static void KeccakF1600(word64 *state)
             Eku =   BCu ^((~BCa)&  BCe );
 
             Abu ^= Du;
-            BCa = rotlFixed(Abu, 27);
+            BCa = rotlConstant<27>(Abu);
             Aga ^= Da;
-            BCe = rotlFixed(Aga, 36);
+            BCe = rotlConstant<36>(Aga);
             Ake ^= De;
-            BCi = rotlFixed(Ake, 10);
+            BCi = rotlConstant<10>(Ake);
             Ami ^= Di;
-            BCo = rotlFixed(Ami, 15);
+            BCo = rotlConstant<15>(Ami);
             Aso ^= Do;
-            BCu = rotlFixed(Aso, 56);
+            BCu = rotlConstant<56>(Aso);
             Ema =   BCa ^((~BCe)&  BCi );
             Eme =   BCe ^((~BCi)&  BCo );
             Emi =   BCi ^((~BCo)&  BCu );
@@ -133,15 +133,15 @@ static void KeccakF1600(word64 *state)
             Emu =   BCu ^((~BCa)&  BCe );
 
             Abi ^= Di;
-            BCa = rotlFixed(Abi, 62);
+            BCa = rotlConstant<62>(Abi);
             Ago ^= Do;
-            BCe = rotlFixed(Ago, 55);
+            BCe = rotlConstant<55>(Ago);
             Aku ^= Du;
-            BCi = rotlFixed(Aku, 39);
+            BCi = rotlConstant<39>(Aku);
             Ama ^= Da;
-            BCo = rotlFixed(Ama, 41);
+            BCo = rotlConstant<41>(Ama);
             Ase ^= De;
-            BCu = rotlFixed(Ase,  2);
+            BCu = rotlConstant<2>(Ase);
             Esa =   BCa ^((~BCe)&  BCi );
             Ese =   BCe ^((~BCi)&  BCo );
             Esi =   BCi ^((~BCo)&  BCu );
@@ -156,22 +156,22 @@ static void KeccakF1600(word64 *state)
             BCu = Ebu^Egu^Eku^Emu^Esu;
 
             //thetaRhoPiChiIotaPrepareTheta(round+1, E, A)
-            Da = BCu^rotlFixed(BCe, 1);
-            De = BCa^rotlFixed(BCi, 1);
-            Di = BCe^rotlFixed(BCo, 1);
-            Do = BCi^rotlFixed(BCu, 1);
-            Du = BCo^rotlFixed(BCa, 1);
+            Da = BCu^rotlConstant<1>(BCe);
+            De = BCa^rotlConstant<1>(BCi);
+            Di = BCe^rotlConstant<1>(BCo);
+            Do = BCi^rotlConstant<1>(BCu);
+            Du = BCo^rotlConstant<1>(BCa);
 
             Eba ^= Da;
             BCa = Eba;
             Ege ^= De;
-            BCe = rotlFixed(Ege, 44);
+            BCe = rotlConstant<44>(Ege);
             Eki ^= Di;
-            BCi = rotlFixed(Eki, 43);
+            BCi = rotlConstant<43>(Eki);
             Emo ^= Do;
-            BCo = rotlFixed(Emo, 21);
+            BCo = rotlConstant<21>(Emo);
             Esu ^= Du;
-            BCu = rotlFixed(Esu, 14);
+            BCu = rotlConstant<14>(Esu);
             Aba =   BCa ^((~BCe)&  BCi );
             Aba ^= (word64)KeccakF_RoundConstants[round+1];
             Abe =   BCe ^((~BCi)&  BCo );
@@ -180,15 +180,15 @@ static void KeccakF1600(word64 *state)
             Abu =   BCu ^((~BCa)&  BCe );
 
             Ebo ^= Do;
-            BCa = rotlFixed(Ebo, 28);
+            BCa = rotlConstant<28>(Ebo);
             Egu ^= Du;
-            BCe = rotlFixed(Egu, 20);
+            BCe = rotlConstant<20>(Egu);
             Eka ^= Da;
-            BCi = rotlFixed(Eka, 3);
+            BCi = rotlConstant<3>(Eka);
             Eme ^= De;
-            BCo = rotlFixed(Eme, 45);
+            BCo = rotlConstant<45>(Eme);
             Esi ^= Di;
-            BCu = rotlFixed(Esi, 61);
+            BCu = rotlConstant<61>(Esi);
             Aga =   BCa ^((~BCe)&  BCi );
             Age =   BCe ^((~BCi)&  BCo );
             Agi =   BCi ^((~BCo)&  BCu );
@@ -196,15 +196,15 @@ static void KeccakF1600(word64 *state)
             Agu =   BCu ^((~BCa)&  BCe );
 
             Ebe ^= De;
-            BCa = rotlFixed(Ebe, 1);
+            BCa = rotlConstant<1>(Ebe);
             Egi ^= Di;
-            BCe = rotlFixed(Egi, 6);
+            BCe = rotlConstant<6>(Egi);
             Eko ^= Do;
-            BCi = rotlFixed(Eko, 25);
+            BCi = rotlConstant<25>(Eko);
             Emu ^= Du;
-            BCo = rotlFixed(Emu, 8);
+            BCo = rotlConstant<8>(Emu);
             Esa ^= Da;
-            BCu = rotlFixed(Esa, 18);
+            BCu = rotlConstant<18>(Esa);
             Aka =   BCa ^((~BCe)&  BCi );
             Ake =   BCe ^((~BCi)&  BCo );
             Aki =   BCi ^((~BCo)&  BCu );
@@ -212,15 +212,15 @@ static void KeccakF1600(word64 *state)
             Aku =   BCu ^((~BCa)&  BCe );
 
             Ebu ^= Du;
-            BCa = rotlFixed(Ebu, 27);
+            BCa = rotlConstant<27>(Ebu);
             Ega ^= Da;
-            BCe = rotlFixed(Ega, 36);
+            BCe = rotlConstant<36>(Ega);
             Eke ^= De;
-            BCi = rotlFixed(Eke, 10);
+            BCi = rotlConstant<10>(Eke);
             Emi ^= Di;
-            BCo = rotlFixed(Emi, 15);
+            BCo = rotlConstant<15>(Emi);
             Eso ^= Do;
-            BCu = rotlFixed(Eso, 56);
+            BCu = rotlConstant<56>(Eso);
             Ama =   BCa ^((~BCe)&  BCi );
             Ame =   BCe ^((~BCi)&  BCo );
             Ami =   BCi ^((~BCo)&  BCu );
@@ -228,15 +228,15 @@ static void KeccakF1600(word64 *state)
             Amu =   BCu ^((~BCa)&  BCe );
 
             Ebi ^= Di;
-            BCa = rotlFixed(Ebi, 62);
+            BCa = rotlConstant<62>(Ebi);
             Ego ^= Do;
-            BCe = rotlFixed(Ego, 55);
+            BCe = rotlConstant<55>(Ego);
             Eku ^= Du;
-            BCi = rotlFixed(Eku, 39);
+            BCi = rotlConstant<39>(Eku);
             Ema ^= Da;
-            BCo = rotlFixed(Ema, 41);
+            BCo = rotlConstant<41>(Ema);
             Ese ^= De;
-            BCu = rotlFixed(Ese, 2);
+            BCu = rotlConstant<2>(Ese);
             Asa =   BCa ^((~BCe)&  BCi );
             Ase =   BCe ^((~BCi)&  BCo );
             Asi =   BCi ^((~BCo)&  BCu );
diff --git a/mars.cpp b/mars.cpp
index 9fff388b..a8d69439 100644
--- a/mars.cpp
+++ b/mars.cpp
@@ -22,12 +22,12 @@ void MARS::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const
 		unsigned int i;
 		// Do linear transformation
 		for (i=0; i<15; i++)
-			T[i] = T[i] ^ rotlFixed(T[(i+8)%15] ^ T[(i+13)%15], 3) ^ (4*i+j);
+			T[i] = T[i] ^ rotlConstant<3>(T[(i + 8) % 15] ^ T[(i + 13) % 15]) ^ (4 * i + j);
 
 		// Do four rounds of stirring
 		for (unsigned int k=0; k<4; k++)
 			for (i=0; i<15; i++)
-			   T[i] = rotlFixed(T[i] + Sbox[T[(i+14)%15]%512], 9);
+				T[i] = rotlConstant<9>(T[i] + Sbox[T[(i + 14) % 15] % 512]);
 
 		// Store next 10 key words into K[]
 		for (i=0; i<10; i++)
@@ -67,7 +67,7 @@ void MARS::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 	{
 		b = (b ^ S0(a)) + S1(a>>8);
 		c += S0(a>>16);
-		a = rotrFixed(a, 24);
+		a = rotrConstant<24>(a);
 		d ^= S1(a);
 		a += (i%4==0) ? d : 0;
 		a += (i%4==1) ? b : 0;
@@ -76,11 +76,11 @@ void MARS::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 
 	for (i=0; i<16; i++)
 	{
-		t = rotlFixed(a, 13);
-		r = rotlFixed(t * k[2*i+5], 10);
+		t = rotlConstant<13>(a);
+		r = rotlConstant<10>(t * k[2 * i + 5]);
 		m = a + k[2*i+4];
-		l = rotlMod((S(m) ^ rotrFixed(r, 5) ^ r), r);
-		c += rotlMod(m, rotrFixed(r, 5));
+		l = rotlMod((S(m) ^ rotrConstant<5>(r) ^ r), r);
+		c += rotlMod(m, rotrConstant<5>(r));
 		(i<8 ? b : d) += l;
 		(i<8 ? d : b) ^= r;
 		a = b;	b = c;	c = d;	d = t;
@@ -92,7 +92,7 @@ void MARS::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 		a -= (i%4==3) ? b : 0;
 		b ^= S1(a);
 		c -= S0(a>>24);
-		t = rotlFixed(a, 24);
+		t = rotlConstant<24>(a);
 		d = (d - S1(a>>16)) ^ S0(t);
 		a = b;	b = c;	c = d;	d = t;
 	}
@@ -116,7 +116,7 @@ void MARS::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 	{
 		b = (b ^ S0(a)) + S1(a>>8);
 		c += S0(a>>16);
-		a = rotrFixed(a, 24);
+		a = rotrConstant<24>(a);
 		d ^= S1(a);
 		a += (i%4==0) ? d : 0;
 		a += (i%4==1) ? b : 0;
@@ -125,11 +125,11 @@ void MARS::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 
 	for (i=0; i<16; i++)
 	{
-		t = rotrFixed(a, 13);
-		r = rotlFixed(a * k[35-2*i], 10);
+		t = rotrConstant<13>(a);
+		r = rotlConstant<10>(a * k[35 - 2 * i]);
 		m = t + k[34-2*i];
-		l = rotlMod((S(m) ^ rotrFixed(r, 5) ^ r), r);
-		c -= rotlMod(m, rotrFixed(r, 5));
+		l = rotlMod((S(m) ^ rotrConstant<5>(r) ^ r), r);
+		c -= rotlMod(m, rotrConstant<5>(r));
 		(i<8 ? b : d) -= l;
 		(i<8 ? d : b) ^= r;
 		a = b;	b = c;	c = d;	d = t;
@@ -141,7 +141,7 @@ void MARS::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, by
 		a -= (i%4==3) ? b : 0;
 		b ^= S1(a);
 		c -= S0(a>>24);
-		t = rotlFixed(a, 24);
+		t = rotlConstant<24>(a);
 		d = (d - S1(a>>16)) ^ S0(t);
 		a = b;	b = c;	c = d;	d = t;
 	}
diff --git a/md4.cpp b/md4.cpp
index 713d2143..f14588cc 100644
--- a/md4.cpp
+++ b/md4.cpp
@@ -44,7 +44,7 @@ void MD4::Transform (word32 *digest, const word32 *in)
 	C=digest[2];
 	D=digest[3];
 
-#define function(a,b,c,d,k,s) a=rotlFixed(a+F(b,c,d)+in[k],s);
+#define function(a,b,c,d,k,s) a=rotlVariable(a+F(b,c,d)+in[k],s);
 	  function(A,B,C,D, 0, 3);
 	  function(D,A,B,C, 1, 7);
 	  function(C,D,A,B, 2,11);
@@ -63,7 +63,7 @@ void MD4::Transform (word32 *digest, const word32 *in)
 	  function(B,C,D,A,15,19);
 
 #undef function
-#define function(a,b,c,d,k,s) a=rotlFixed(a+G(b,c,d)+in[k]+0x5a827999,s);
+#define function(a,b,c,d,k,s) a=rotlVariable(a+G(b,c,d)+in[k]+0x5a827999,s);
 	  function(A,B,C,D, 0, 3);
 	  function(D,A,B,C, 4, 5);
 	  function(C,D,A,B, 8, 9);
@@ -82,7 +82,7 @@ void MD4::Transform (word32 *digest, const word32 *in)
 	  function(B,C,D,A,15,13);
 
 #undef function
-#define function(a,b,c,d,k,s) a=rotlFixed(a+H(b,c,d)+in[k]+0x6ed9eba1,s);
+#define function(a,b,c,d,k,s) a=rotlVariable(a+H(b,c,d)+in[k]+0x6ed9eba1,s);
 	  function(A,B,C,D, 0, 3);
 	  function(D,A,B,C, 8, 9);
 	  function(C,D,A,B, 4,11);
diff --git a/rc2.cpp b/rc2.cpp
index a4e0079f..1469cc59 100644
--- a/rc2.cpp
+++ b/rc2.cpp
@@ -61,16 +61,16 @@ void RC2::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byt
 	for (int i = 0; i < 16; i++)
 	{
 		R0 += (R1 & ~R3) + (R2 & R3) + K[4*i+0];
-		R0 = rotlFixed(R0, 1);
+		R0 = rotlConstant<1>(R0);
 
 		R1 += (R2 & ~R0) + (R3 & R0) + K[4*i+1];
-		R1 = rotlFixed(R1, 2);
+		R1 = rotlConstant<2>(R1);
 
 		R2 += (R3 & ~R1) + (R0 & R1) + K[4*i+2];
-		R2 = rotlFixed(R2, 3);
+		R2 = rotlConstant<3>(R2);
 
 		R3 += (R0 & ~R2) + (R1 & R2) + K[4*i+3];
-		R3 = rotlFixed(R3, 5);
+		R3 = rotlConstant<5>(R3);
 
 		if (i == 4 || i == 10)
 		{
@@ -99,16 +99,16 @@ void RC2::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byt
 			R0 = word16(R0 - K[R3 & 63]);
 		}
 
-		R3 = rotrFixed(R3, 5);
+		R3 = rotrConstant<5>(R3);
 		R3 = word16(R3 - ((R0 & ~R2) + (R1 & R2) + K[4*i+3]));
 
-		R2 = rotrFixed(R2, 3);
+		R2 = rotrConstant<3>(R2);
 		R2 = word16(R2 - ((R3 & ~R1) + (R0 & R1) + K[4*i+2]));
 
-		R1 = rotrFixed(R1, 2);
+		R1 = rotrConstant<2>(R1);
 		R1 = word16(R1 - ((R2 & ~R0) + (R3 & R0) + K[4*i+1]));
 
-		R0 = rotrFixed(R0, 1);
+		R0 = rotrConstant<1>(R0);
 		R0 = word16(R0 - ((R1 & ~R3) + (R2 & R3) + K[4*i+0]));
 	}
 
diff --git a/rc5.cpp b/rc5.cpp
index f17667f2..262c9aec 100644
--- a/rc5.cpp
+++ b/rc5.cpp
@@ -32,7 +32,7 @@ void RC5::Base::UncheckedSetKey(const byte *k, unsigned int keylen, const NameVa
 
 	for (unsigned h=0; h < n; h++)
 	{
-		a = sTable[h % sTable.size()] = rotlFixed((sTable[h % sTable.size()] + a + b), 3);
+		a = sTable[h % sTable.size()] = rotlConstant<3>((sTable[h % sTable.size()] + a + b));
 		b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b));
 	}
 }
diff --git a/rc6.cpp b/rc6.cpp
index b5cd8448..6301cb74 100644
--- a/rc6.cpp
+++ b/rc6.cpp
@@ -33,7 +33,7 @@ void RC6::Base::UncheckedSetKey(const byte *k, unsigned int keylen, const NameVa
 
 	for (unsigned h=0; h < n; h++)
 	{
-		a = sTable[h % sTable.size()] = rotlFixed((sTable[h % sTable.size()] + a + b), 3);
+		a = sTable[h % sTable.size()] = rotlConstant<3>((sTable[h % sTable.size()] + a + b));
 		b = l[h % c] = rotlMod((l[h % c] + a + b), (a+b));
 	}
 }
@@ -52,8 +52,8 @@ void RC6::Enc::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byt
 
 	for(unsigned i=0; i<r; i++)
 	{
-		t = rotlFixed(b*(2*b+1), 5);
-		u = rotlFixed(d*(2*d+1), 5);
+		t = rotlConstant<5>(b*(2*b+1));
+		u = rotlConstant<5>(d*(2*d+1));
 		a = rotlMod(a^t,u) + sptr[0];
 		c = rotlMod(c^u,t) + sptr[1];
 		t = a; a = b; b = c; c = d; d = t;
@@ -81,8 +81,8 @@ void RC6::Dec::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byt
 	{
 		sptr -= 2;
 		t = a; a = d; d = c; c = b; b = t;
-		u = rotlFixed(d*(2*d+1), 5);
-		t = rotlFixed(b*(2*b+1), 5);
+		u = rotlConstant<5>(d*(2 * d + 1));
+		t = rotlConstant<5>(b*(2 * b + 1));
 		c = rotrMod(c-sptr[1], t) ^ u;
 		a = rotrMod(a-sptr[0], u) ^ t;
 	}
diff --git a/rijndael.cpp b/rijndael.cpp
index 55bf6510..9074cec9 100644
--- a/rijndael.cpp
+++ b/rijndael.cpp
@@ -253,7 +253,7 @@ void Rijndael::Base::FillEncTable()
 		for (int j=0; j<4; j++)
 		{
 			Te[i+j*256] = y;
-			y = rotrFixed(y, 8);
+			y = rotrConstant<8>(y);
 		}
 #endif
 	}
@@ -276,7 +276,7 @@ void Rijndael::Base::FillDecTable()
 		for (int j=0; j<4; j++)
 		{
 			Td[i+j*256] = y;
-			y = rotrFixed(y, 8);
+			y = rotrConstant<8>(y);
 		}
 #endif
 	}
diff --git a/ripemd.cpp b/ripemd.cpp
index a9d62391..163b2803 100644
--- a/ripemd.cpp
+++ b/ripemd.cpp
@@ -31,8 +31,8 @@ NAMESPACE_BEGIN(CryptoPP)
 // for 160 and 320
 #define Subround(f, a, b, c, d, e, x, s, k)        \
 	a += f(b, c, d) + x + k;\
-	a = rotlFixed((word32)a, s) + e;\
-	c = rotlFixed((word32)c, 10U)
+	a = rotlVariable((word32)a, s) + e;\
+	c = rotlConstant<10>((word32)c)
 
 void RIPEMD160::InitState(HashWordType *state)
 {
@@ -459,7 +459,7 @@ void RIPEMD320::Transform (word32 *digest, const word32 *X)
 // for 128 and 256
 #define Subround(f, a, b, c, d, x, s, k)        \
 	a += f(b, c, d) + x + k;\
-	a = rotlFixed((word32)a, s);
+	a = rotlVariable((word32)a, s);
 
 void RIPEMD128::InitState(HashWordType *state)
 {
diff --git a/safer.cpp b/safer.cpp
index 583f8b3b..83f41517 100644
--- a/safer.cpp
+++ b/safer.cpp
@@ -74,7 +74,7 @@ void SAFER::Base::UncheckedSetKey(const byte *userkey_1, unsigned int length, co
 	kb[BLOCKSIZE] = 0;
 	for (j = 0; j < BLOCKSIZE; j++)
 	{
-		ka[BLOCKSIZE] ^= ka[j] = rotlFixed(userkey_1[j], 5U);
+		ka[BLOCKSIZE] ^= ka[j] = rotlConstant<5>(userkey_1[j]);
 		kb[BLOCKSIZE] ^= kb[j] = *key++ = userkey_2[j];
 	}
 
@@ -82,8 +82,8 @@ void SAFER::Base::UncheckedSetKey(const byte *userkey_1, unsigned int length, co
 	{
 		for (j = 0; j < BLOCKSIZE + 1; j++)
 		{
-			ka[j] = rotlFixed(ka[j], 6U);
-			kb[j] = rotlFixed(kb[j], 6U);
+			ka[j] = rotlConstant<6>(ka[j]);
+			kb[j] = rotlConstant<6>(kb[j]);
 		}
 		for (j = 0; j < BLOCKSIZE; j++)
 			if (strengthened)
diff --git a/salsa.cpp b/salsa.cpp
index e0f7a085..e42a73bd 100644
--- a/salsa.cpp
+++ b/salsa.cpp
@@ -525,10 +525,10 @@ Salsa20_OperateKeystream ENDP
 			for (int i=m_rounds; i>0; i-=2)
 			{
 				#define QUARTER_ROUND(a, b, c, d)	\
-					b = b ^ rotlFixed(a + d, 7);	\
-					c = c ^ rotlFixed(b + a, 9);	\
-					d = d ^ rotlFixed(c + b, 13);	\
-					a = a ^ rotlFixed(d + c, 18);
+					b = b ^ rotlConstant<7>(a + d);	\
+					c = c ^ rotlConstant<9>(b + a);	\
+					d = d ^ rotlConstant<13>(c + b);	\
+					a = a ^ rotlConstant<18>(d + c);
 
 				QUARTER_ROUND(x0, x4, x8, x12)
 				QUARTER_ROUND(x1, x5, x9, x13)
diff --git a/seal.cpp b/seal.cpp
index fef2656c..fea047e7 100644
--- a/seal.cpp
+++ b/seal.cpp
@@ -101,84 +101,84 @@ void SEAL_Policy<B>::OperateKeystream(KeystreamOperation operation, byte *output
 		#define Ttab(x) *(word32 *)(void*)((byte *)m_T.begin()+x)
 
 		a = m_outsideCounter ^ m_R[4*m_insideCounter];
-		b = rotrFixed(m_outsideCounter, 8U) ^ m_R[4*m_insideCounter+1];
-		c = rotrFixed(m_outsideCounter, 16U) ^ m_R[4*m_insideCounter+2];
-		d = rotrFixed(m_outsideCounter, 24U) ^ m_R[4*m_insideCounter+3];
+		b = rotrConstant<8>(m_outsideCounter) ^ m_R[4*m_insideCounter+1];
+		c = rotrConstant<16>(m_outsideCounter) ^ m_R[4 * m_insideCounter + 2];
+		d = rotrConstant<24>(m_outsideCounter) ^ m_R[4 * m_insideCounter + 3];
 
 		for (unsigned int j=0; j<2; j++)
 		{
 			p = a & 0x7fc;
 			b += Ttab(p);
-			a = rotrFixed(a, 9U);
+			a = rotrConstant<9>(a);
 
 			p = b & 0x7fc;
 			c += Ttab(p);
-			b = rotrFixed(b, 9U);
+			b = rotrConstant<9>(b);
 
 			p = c & 0x7fc;
 			d += Ttab(p);
-			c = rotrFixed(c, 9U);
+			c = rotrConstant<9>(c);
 
 			p = d & 0x7fc;
 			a += Ttab(p);
-			d = rotrFixed(d, 9U);
+			d = rotrConstant<9>(d);
 		}
 
 		n1 = d, n2 = b, n3 = a, n4 = c;
 
 		p = a & 0x7fc;
 		b += Ttab(p);
-		a = rotrFixed(a, 9U);
+		a = rotrConstant<9>(a);
 
 		p = b & 0x7fc;
 		c += Ttab(p);
-		b = rotrFixed(b, 9U);
+		b = rotrConstant<9>(b);
 
 		p = c & 0x7fc;
 		d += Ttab(p);
-		c = rotrFixed(c, 9U);
+		c = rotrConstant<9>(c);
 
 		p = d & 0x7fc;
 		a += Ttab(p);
-		d = rotrFixed(d, 9U);
+		d = rotrConstant<9>(d);
 
 		// generate 8192 bits
 		for (unsigned int i=0; i<64; i++)
 		{
 			p = a & 0x7fc;
-			a = rotrFixed(a, 9U);
+			a = rotrConstant<9>(a);
 			b += Ttab(p);
 			b ^= a;
 
 			q = b & 0x7fc;
-			b = rotrFixed(b, 9U);
+			b = rotrConstant<9>(b);
 			c ^= Ttab(q);
 			c += b;
 
 			p = (p+c) & 0x7fc;
-			c = rotrFixed(c, 9U);
+			c = rotrConstant<9>(c);
 			d += Ttab(p);
 			d ^= c;
 
 			q = (q+d) & 0x7fc;
-			d = rotrFixed(d, 9U);
+			d = rotrConstant<9>(d);
 			a ^= Ttab(q);
 			a += d;
 
 			p = (p+a) & 0x7fc;
 			b ^= Ttab(p);
-			a = rotrFixed(a, 9U);
+			a = rotrConstant<9>(a);
 
 			q = (q+b) & 0x7fc;
 			c += Ttab(q);
-			b = rotrFixed(b, 9U);
+			b = rotrConstant<9>(b);
 
 			p = (p+c) & 0x7fc;
 			d ^= Ttab(p);
-			c = rotrFixed(c, 9U);
+			c = rotrConstant<9>(c);
 
 			q = (q+d) & 0x7fc;
-			d = rotrFixed(d, 9U);
+			d = rotrConstant<9>(d);
 			a += Ttab(q);
 
 #define SEAL_OUTPUT(x)	\
diff --git a/seed.cpp b/seed.cpp
index 75410c01..a610b3e6 100644
--- a/seed.cpp
+++ b/seed.cpp
@@ -75,9 +75,9 @@ void SEED::Base::UncheckedSetKey(const byte *userKey, unsigned int length, const
 		k[1] = G(t1);
 		k+=kInc;
 		if (i&1)
-			key23 = rotlFixed<word64>(key23, 8);
+			key23 = rotlConstant<8,word64>(key23);
 		else
-			key01 = rotrFixed<word64>(key01, 8);
+			key01 = rotrConstant<8,word64>(key01);
 	}
 }
 
diff --git a/serpent.cpp b/serpent.cpp
index 80a59499..351186ce 100644
--- a/serpent.cpp
+++ b/serpent.cpp
@@ -20,9 +20,9 @@ void Serpent_KeySchedule(word32 *k, unsigned int rounds, const byte *userKey, si
 	word32 t = k0[7];
 	unsigned int i;
 	for (i = 0; i < 8; ++i)
-		k[i] = k0[i] = t = rotlFixed(k0[i] ^ k0[(i+3)%8] ^ k0[(i+5)%8] ^ t ^ 0x9e3779b9 ^ i, 11);
+		k[i] = k0[i] = t = rotlConstant<11>(k0[i] ^ k0[(i + 3) % 8] ^ k0[(i + 5) % 8] ^ t ^ 0x9e3779b9 ^ i);
 	for (i = 8; i < 4*(rounds+1); ++i)
-		k[i] = t = rotlFixed(k[i-8] ^ k[i-5] ^ k[i-3] ^ t ^ 0x9e3779b9 ^ i, 11);
+		k[i] = t = rotlConstant<11>(k[i-8] ^ k[i-5] ^ k[i-3] ^ t ^ 0x9e3779b9 ^ i);
 	k -= 20;
 
 	word32 a,b,c,d,e;
diff --git a/serpentp.h b/serpentp.h
index a38b39a7..b0053c17 100644
--- a/serpentp.h
+++ b/serpentp.h
@@ -4,24 +4,24 @@ NAMESPACE_BEGIN(CryptoPP)
 
 // linear transformation
 #define LT(i,a,b,c,d,e)	{\
-	a = rotlFixed(a, 13);	\
-	c = rotlFixed(c, 3); 	\
-	d = rotlFixed(d ^ c ^ (a << 3), 7); 	\
-	b = rotlFixed(b ^ a ^ c, 1); 	\
-	a = rotlFixed(a ^ b ^ d, 5); 		\
-	c = rotlFixed(c ^ d ^ (b << 7), 22);}
+	a = rotlConstant<13>(a);	\
+	c = rotlConstant<3>(c); 	\
+	d = rotlConstant<7>(d ^ c ^ (a << 3)); 	\
+	b = rotlConstant<1>(b ^ a ^ c); 	\
+	a = rotlConstant<5>(a ^ b ^ d); 		\
+	c = rotlConstant<22>(c ^ d ^ (b << 7));}
 
 // inverse linear transformation
 #define ILT(i,a,b,c,d,e)	{\
-	c = rotrFixed(c, 22);	\
-	a = rotrFixed(a, 5); 	\
+	c = rotrConstant<22>(c);	\
+	a = rotrConstant<5>(a); 	\
 	c ^= d ^ (b << 7);	\
 	a ^= b ^ d; 		\
-	b = rotrFixed(b, 1); 	\
-	d = rotrFixed(d, 7) ^ c ^ (a << 3);	\
+	b = rotrConstant<1>(b); 	\
+	d = rotrConstant<7>(d) ^ c ^ (a << 3);	\
 	b ^= a ^ c; 		\
-	c = rotrFixed(c, 3); 	\
-	a = rotrFixed(a, 13);}
+	c = rotrConstant<3>(c); 	\
+	a = rotrConstant<13>(a);}
 
 // order of output from S-box functions
 #define beforeS0(f) f(0,a,b,c,d,e)
diff --git a/sha.cpp b/sha.cpp
index d1c8d454..06e1a640 100644
--- a/sha.cpp
+++ b/sha.cpp
@@ -82,7 +82,7 @@ extern void SHA512_HashMultipleBlocks_POWER8(word64 *state, const word64 *data,
 ANONYMOUS_NAMESPACE_BEGIN
 
 #define blk0(i) (W[i] = data[i])
-#define blk1(i) (W[i&15] = rotlFixed(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15],1))
+#define blk1(i) (W[i&15] = rotlConstant<1>(W[(i+13)&15]^W[(i+8)&15]^W[(i+2)&15]^W[i&15]))
 
 #define f1(x,y,z) (z^(x&(y^z)))
 #define f2(x,y,z) (x^y^z)
@@ -90,11 +90,11 @@ ANONYMOUS_NAMESPACE_BEGIN
 #define f4(x,y,z) (x^y^z)
 
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define R0(v,w,x,y,z,i) z+=f1(w,x,y)+blk0(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
-#define R1(v,w,x,y,z,i) z+=f1(w,x,y)+blk1(i)+0x5A827999+rotlFixed(v,5);w=rotlFixed(w,30);
-#define R2(v,w,x,y,z,i) z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rotlFixed(v,5);w=rotlFixed(w,30);
-#define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlFixed(v,5);w=rotlFixed(w,30);
-#define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlFixed(v,5);w=rotlFixed(w,30);
+#define R0(v,w,x,y,z,i) z+=f1(w,x,y)+blk0(i)+0x5A827999+rotlConstant<5>(v);w=rotlConstant<30>(w);
+#define R1(v,w,x,y,z,i) z+=f1(w,x,y)+blk1(i)+0x5A827999+rotlConstant<5>(v);w=rotlConstant<30>(w);
+#define R2(v,w,x,y,z,i) z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rotlConstant<5>(v);w=rotlConstant<30>(w);
+#define R3(v,w,x,y,z,i) z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rotlConstant<5>(v);w=rotlConstant<30>(w);
+#define R4(v,w,x,y,z,i) z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rotlConstant<5>(v);w=rotlConstant<30>(w);
 
 void SHA1_HashBlock_CXX(word32 *state, const word32 *data)
 {
@@ -271,10 +271,10 @@ ANONYMOUS_NAMESPACE_BEGIN
     d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i))
 
 // for SHA256
-#define s0(x) (rotrFixed(x,7)^rotrFixed(x,18)^(x>>3))
-#define s1(x) (rotrFixed(x,17)^rotrFixed(x,19)^(x>>10))
-#define S0(x) (rotrFixed(x,2)^rotrFixed(x,13)^rotrFixed(x,22))
-#define S1(x) (rotrFixed(x,6)^rotrFixed(x,11)^rotrFixed(x,25))
+#define s0(x) (rotrConstant<7>(x)^rotrConstant<18>(x)^(x>>3))
+#define s1(x) (rotrConstant<17>(x)^rotrConstant<19>(x)^(x>>10))
+#define S0(x) (rotrConstant<2>(x)^rotrConstant<13>(x)^rotrConstant<22>(x))
+#define S1(x) (rotrConstant<6>(x)^rotrConstant<11>(x)^rotrConstant<25>(x))
 
 void SHA256_HashBlock_CXX(word32 *state, const word32 *data)
 {
@@ -1099,10 +1099,10 @@ ANONYMOUS_NAMESPACE_BEGIN
 #define Ch(x,y,z) (z^(x&(y^z)))
 #define Maj(x,y,z) (y^((x^y)&(y^z)))
 
-#define s0(x) (rotrFixed(x,1)^rotrFixed(x,8)^(x>>7))
-#define s1(x) (rotrFixed(x,19)^rotrFixed(x,61)^(x>>6))
-#define S0(x) (rotrFixed(x,28)^rotrFixed(x,34)^rotrFixed(x,39))
-#define S1(x) (rotrFixed(x,14)^rotrFixed(x,18)^rotrFixed(x,41))
+#define s0(x) (rotrConstant<1>(x)^rotrConstant<8>(x)^(x>>7))
+#define s1(x) (rotrConstant<19>(x)^rotrConstant<61>(x)^(x>>6))
+#define S0(x) (rotrConstant<28>(x)^rotrConstant<34>(x)^rotrConstant<39>(x))
+#define S1(x) (rotrConstant<14>(x)^rotrConstant<18>(x)^rotrConstant<41>(x))
 
 #define R(i) h(i)+=S1(e(i))+Ch(e(i),f(i),g(i))+SHA512_K[i+j]+\
     (j?blk2(i):blk0(i));d(i)+=h(i);h(i)+=S0(a(i))+Maj(a(i),b(i),c(i));
diff --git a/sha3.cpp b/sha3.cpp
index 6cfcaa67..ec3b04e3 100644
--- a/sha3.cpp
+++ b/sha3.cpp
@@ -61,22 +61,22 @@ static void KeccakF1600(word64 *state)
             BCu = Abu^Agu^Aku^Amu^Asu;
 
             //thetaRhoPiChiIotaPrepareTheta(round  , A, E)
-            Da = BCu^rotlFixed(BCe, 1);
-            De = BCa^rotlFixed(BCi, 1);
-            Di = BCe^rotlFixed(BCo, 1);
-            Do = BCi^rotlFixed(BCu, 1);
-            Du = BCo^rotlFixed(BCa, 1);
+            Da = BCu^rotlConstant<1>(BCe);
+            De = BCa^rotlConstant<1>(BCi);
+            Di = BCe^rotlConstant<1>(BCo);
+            Do = BCi^rotlConstant<1>(BCu);
+            Du = BCo^rotlConstant<1>(BCa);
 
             Aba ^= Da;
             BCa = Aba;
             Age ^= De;
-            BCe = rotlFixed(Age, 44);
+            BCe = rotlConstant<44>(Age);
             Aki ^= Di;
-            BCi = rotlFixed(Aki, 43);
+            BCi = rotlConstant<43>(Aki);
             Amo ^= Do;
-            BCo = rotlFixed(Amo, 21);
+            BCo = rotlConstant<21>(Amo);
             Asu ^= Du;
-            BCu = rotlFixed(Asu, 14);
+            BCu = rotlConstant<14>(Asu);
             Eba =   BCa ^((~BCe)&  BCi );
             Eba ^= (word64)KeccakF_RoundConstants[round];
             Ebe =   BCe ^((~BCi)&  BCo );
@@ -85,15 +85,15 @@ static void KeccakF1600(word64 *state)
             Ebu =   BCu ^((~BCa)&  BCe );
 
             Abo ^= Do;
-            BCa = rotlFixed(Abo, 28);
+            BCa = rotlConstant<28>(Abo);
             Agu ^= Du;
-            BCe = rotlFixed(Agu, 20);
+            BCe = rotlConstant<20>(Agu);
             Aka ^= Da;
-            BCi = rotlFixed(Aka,  3);
+            BCi = rotlConstant<3>(Aka);
             Ame ^= De;
-            BCo = rotlFixed(Ame, 45);
+            BCo = rotlConstant<45>(Ame);
             Asi ^= Di;
-            BCu = rotlFixed(Asi, 61);
+            BCu = rotlConstant<61>(Asi);
             Ega =   BCa ^((~BCe)&  BCi );
             Ege =   BCe ^((~BCi)&  BCo );
             Egi =   BCi ^((~BCo)&  BCu );
@@ -101,15 +101,15 @@ static void KeccakF1600(word64 *state)
             Egu =   BCu ^((~BCa)&  BCe );
 
             Abe ^= De;
-            BCa = rotlFixed(Abe,  1);
+            BCa = rotlConstant<1>(Abe);
             Agi ^= Di;
-            BCe = rotlFixed(Agi,  6);
+            BCe = rotlConstant<6>(Agi);
             Ako ^= Do;
-            BCi = rotlFixed(Ako, 25);
+            BCi = rotlConstant<25>(Ako);
             Amu ^= Du;
-            BCo = rotlFixed(Amu,  8);
+            BCo = rotlConstant<8>(Amu);
             Asa ^= Da;
-            BCu = rotlFixed(Asa, 18);
+            BCu = rotlConstant<18>(Asa);
             Eka =   BCa ^((~BCe)&  BCi );
             Eke =   BCe ^((~BCi)&  BCo );
             Eki =   BCi ^((~BCo)&  BCu );
@@ -117,15 +117,15 @@ static void KeccakF1600(word64 *state)
             Eku =   BCu ^((~BCa)&  BCe );
 
             Abu ^= Du;
-            BCa = rotlFixed(Abu, 27);
+            BCa = rotlConstant<27>(Abu);
             Aga ^= Da;
-            BCe = rotlFixed(Aga, 36);
+            BCe = rotlConstant<36>(Aga);
             Ake ^= De;
-            BCi = rotlFixed(Ake, 10);
+            BCi = rotlConstant<10>(Ake);
             Ami ^= Di;
-            BCo = rotlFixed(Ami, 15);
+            BCo = rotlConstant<15>(Ami);
             Aso ^= Do;
-            BCu = rotlFixed(Aso, 56);
+            BCu = rotlConstant<56>(Aso);
             Ema =   BCa ^((~BCe)&  BCi );
             Eme =   BCe ^((~BCi)&  BCo );
             Emi =   BCi ^((~BCo)&  BCu );
@@ -133,15 +133,15 @@ static void KeccakF1600(word64 *state)
             Emu =   BCu ^((~BCa)&  BCe );
 
             Abi ^= Di;
-            BCa = rotlFixed(Abi, 62);
+            BCa = rotlConstant<62>(Abi);
             Ago ^= Do;
-            BCe = rotlFixed(Ago, 55);
+            BCe = rotlConstant<55>(Ago);
             Aku ^= Du;
-            BCi = rotlFixed(Aku, 39);
+            BCi = rotlConstant<39>(Aku);
             Ama ^= Da;
-            BCo = rotlFixed(Ama, 41);
+            BCo = rotlConstant<41>(Ama);
             Ase ^= De;
-            BCu = rotlFixed(Ase,  2);
+            BCu = rotlConstant<2>(Ase);
             Esa =   BCa ^((~BCe)&  BCi );
             Ese =   BCe ^((~BCi)&  BCo );
             Esi =   BCi ^((~BCo)&  BCu );
@@ -156,22 +156,22 @@ static void KeccakF1600(word64 *state)
             BCu = Ebu^Egu^Eku^Emu^Esu;
 
             //thetaRhoPiChiIotaPrepareTheta(round+1, E, A)
-            Da = BCu^rotlFixed(BCe, 1);
-            De = BCa^rotlFixed(BCi, 1);
-            Di = BCe^rotlFixed(BCo, 1);
-            Do = BCi^rotlFixed(BCu, 1);
-            Du = BCo^rotlFixed(BCa, 1);
+            Da = BCu^rotlConstant<1>(BCe);
+            De = BCa^rotlConstant<1>(BCi);
+            Di = BCe^rotlConstant<1>(BCo);
+            Do = BCi^rotlConstant<1>(BCu);
+            Du = BCo^rotlConstant<1>(BCa);
 
             Eba ^= Da;
             BCa = Eba;
             Ege ^= De;
-            BCe = rotlFixed(Ege, 44);
+            BCe = rotlConstant<44>(Ege);
             Eki ^= Di;
-            BCi = rotlFixed(Eki, 43);
+            BCi = rotlConstant<43>(Eki);
             Emo ^= Do;
-            BCo = rotlFixed(Emo, 21);
+            BCo = rotlConstant<21>(Emo);
             Esu ^= Du;
-            BCu = rotlFixed(Esu, 14);
+            BCu = rotlConstant<14>(Esu);
             Aba =   BCa ^((~BCe)&  BCi );
             Aba ^= (word64)KeccakF_RoundConstants[round+1];
             Abe =   BCe ^((~BCi)&  BCo );
@@ -180,15 +180,15 @@ static void KeccakF1600(word64 *state)
             Abu =   BCu ^((~BCa)&  BCe );
 
             Ebo ^= Do;
-            BCa = rotlFixed(Ebo, 28);
+            BCa = rotlConstant<28>(Ebo);
             Egu ^= Du;
-            BCe = rotlFixed(Egu, 20);
+            BCe = rotlConstant<20>(Egu);
             Eka ^= Da;
-            BCi = rotlFixed(Eka, 3);
+            BCi = rotlConstant<3>(Eka);
             Eme ^= De;
-            BCo = rotlFixed(Eme, 45);
+            BCo = rotlConstant<45>(Eme);
             Esi ^= Di;
-            BCu = rotlFixed(Esi, 61);
+            BCu = rotlConstant<61>(Esi);
             Aga =   BCa ^((~BCe)&  BCi );
             Age =   BCe ^((~BCi)&  BCo );
             Agi =   BCi ^((~BCo)&  BCu );
@@ -196,15 +196,15 @@ static void KeccakF1600(word64 *state)
             Agu =   BCu ^((~BCa)&  BCe );
 
             Ebe ^= De;
-            BCa = rotlFixed(Ebe, 1);
+            BCa = rotlConstant<1>(Ebe);
             Egi ^= Di;
-            BCe = rotlFixed(Egi, 6);
+            BCe = rotlConstant<6>(Egi);
             Eko ^= Do;
-            BCi = rotlFixed(Eko, 25);
+            BCi = rotlConstant<25>(Eko);
             Emu ^= Du;
-            BCo = rotlFixed(Emu, 8);
+            BCo = rotlConstant<8>(Emu);
             Esa ^= Da;
-            BCu = rotlFixed(Esa, 18);
+            BCu = rotlConstant<18>(Esa);
             Aka =   BCa ^((~BCe)&  BCi );
             Ake =   BCe ^((~BCi)&  BCo );
             Aki =   BCi ^((~BCo)&  BCu );
@@ -212,15 +212,15 @@ static void KeccakF1600(word64 *state)
             Aku =   BCu ^((~BCa)&  BCe );
 
             Ebu ^= Du;
-            BCa = rotlFixed(Ebu, 27);
+            BCa = rotlConstant<27>(Ebu);
             Ega ^= Da;
-            BCe = rotlFixed(Ega, 36);
+            BCe = rotlConstant<36>(Ega);
             Eke ^= De;
-            BCi = rotlFixed(Eke, 10);
+            BCi = rotlConstant<10>(Eke);
             Emi ^= Di;
-            BCo = rotlFixed(Emi, 15);
+            BCo = rotlConstant<15>(Emi);
             Eso ^= Do;
-            BCu = rotlFixed(Eso, 56);
+            BCu = rotlConstant<56>(Eso);
             Ama =   BCa ^((~BCe)&  BCi );
             Ame =   BCe ^((~BCi)&  BCo );
             Ami =   BCi ^((~BCo)&  BCu );
@@ -228,15 +228,15 @@ static void KeccakF1600(word64 *state)
             Amu =   BCu ^((~BCa)&  BCe );
 
             Ebi ^= Di;
-            BCa = rotlFixed(Ebi, 62);
+            BCa = rotlConstant<62>(Ebi);
             Ego ^= Do;
-            BCe = rotlFixed(Ego, 55);
+            BCe = rotlConstant<55>(Ego);
             Eku ^= Du;
-            BCi = rotlFixed(Eku, 39);
+            BCi = rotlConstant<39>(Eku);
             Ema ^= Da;
-            BCo = rotlFixed(Ema, 41);
+            BCo = rotlConstant<41>(Ema);
             Ese ^= De;
-            BCu = rotlFixed(Ese, 2);
+            BCu = rotlConstant<2>(Ese);
             Asa =   BCa ^((~BCe)&  BCi );
             Ase =   BCe ^((~BCi)&  BCo );
             Asi =   BCi ^((~BCo)&  BCu );
diff --git a/shacal2.cpp b/shacal2.cpp
index 2e77dd6f..6cad11ef 100644
--- a/shacal2.cpp
+++ b/shacal2.cpp
@@ -22,10 +22,10 @@ NAMESPACE_BEGIN(CryptoPP)
 
 // SHACAL-2 function and round definitions
 
-#define S0(x) (rotrFixed(x,2)^rotrFixed(x,13)^rotrFixed(x,22))
-#define S1(x) (rotrFixed(x,6)^rotrFixed(x,11)^rotrFixed(x,25))
-#define s0(x) (rotrFixed(x,7)^rotrFixed(x,18)^(x>>3))
-#define s1(x) (rotrFixed(x,17)^rotrFixed(x,19)^(x>>10))
+#define S0(x) (rotrConstant<2>(x)^rotrConstant<13>(x)^rotrConstant<22>(x))
+#define S1(x) (rotrConstant<6>(x)^rotrConstant<11>(x)^rotrConstant<25>(x))
+#define s0(x) (rotrConstant<7>(x)^rotrConstant<18>(x)^(x>>3))
+#define s1(x) (rotrConstant<17>(x)^rotrConstant<19>(x)^(x>>10))
 
 #define Ch(x,y,z) (z^(x&(y^z)))
 #define Maj(x,y,z) ((x&y)|(z&(x|y)))
diff --git a/simon.cpp b/simon.cpp
index c1bee040..a9ea38d7 100644
--- a/simon.cpp
+++ b/simon.cpp
@@ -10,8 +10,8 @@ ANONYMOUS_NAMESPACE_BEGIN
 
 using CryptoPP::word32;
 using CryptoPP::word64;
-using CryptoPP::rotlFixed;
-using CryptoPP::rotrFixed;
+using CryptoPP::rotlConstant;
+using CryptoPP::rotrConstant;
 
 //! \brief Round transformation helper
 //! \tparam W word type
@@ -19,7 +19,7 @@ using CryptoPP::rotrFixed;
 template <class W>
 inline W f(const W v)
 {
-    return (rotlFixed(v, 1) & rotlFixed(v, 8)) ^ rotlFixed(v, 2);
+    return (rotlConstant<1>(v) & rotlConstant<8>(v)) ^ rotlConstant<2>(v);
 }
 
 //! \brief Round transformation
@@ -103,7 +103,7 @@ inline void SPECK64_ExpandKey_42R3K(word32 key[42], const word32 k[3])
     key[0] = k[2]; key[1] = k[1]; key[2] = k[0];
     for (size_t i = 3; i<42; ++i)
     {
-        key[i] = c ^ (z & 1) ^ key[i-3] ^ rotrFixed(key[i-1], 3) ^ rotrFixed(key[i-1], 4);
+        key[i] = c ^ (z & 1) ^ key[i - 3] ^ rotrConstant<3>(key[i - 1]) ^ rotrConstant<4>(key[i - 1]);
         z >>= 1;
     }
 }
@@ -121,7 +121,7 @@ inline void SPECK64_ExpandKey_44R4K(word32 key[44], const word32 k[4])
     key[0] = k[3]; key[1] = k[2]; key[2] = k[1]; key[3] = k[0];
     for (size_t i = 4; i<44; ++i)
     {
-        key[i] = c ^ (z & 1) ^ key[i-4] ^ rotrFixed(key[i-1], 3) ^ key[i-3] ^ rotrFixed(key[i-1], 4) ^ rotrFixed(key[i-3], 1);
+        key[i] = c ^ (z & 1) ^ key[i - 4] ^ rotrConstant<3>(key[i - 1]) ^ key[i - 3] ^ rotrConstant<4>(key[i - 1]) ^ rotrConstant<1>(key[i - 3]);
         z >>= 1;
     }
 }
@@ -139,12 +139,12 @@ inline void SIMON128_ExpandKey_68R2K(word64 key[68], const word64 k[2])
     key[0] = k[1]; key[1] = k[0];
     for (size_t i=2; i<66; ++i)
     {
-        key[i] = c^(z&1)^key[i-2]^rotrFixed(key[i-1],3)^rotrFixed(key[i-1],4);
+        key[i] = c ^ (z & 1) ^ key[i - 2] ^ rotrConstant<3>(key[i - 1]) ^ rotrConstant<4>(key[i - 1]);
         z>>=1;
     }
 
-    key[66] = c^1^key[64]^rotrFixed(key[65],3)^rotrFixed(key[65],4);
-    key[67] = c^key[65]^rotrFixed(key[66],3)^rotrFixed(key[66],4);
+    key[66] = c ^ 1 ^ key[64] ^ rotrConstant<3>(key[65]) ^ rotrConstant<4>(key[65]);
+    key[67] = c^key[65] ^ rotrConstant<3>(key[66]) ^ rotrConstant<4>(key[66]);
 }
 
 //! \brief Subkey generation function
@@ -160,12 +160,12 @@ inline void SIMON128_ExpandKey_69R3K(word64 key[69], const word64 k[3])
     key[0]=k[2]; key[1]=k[1]; key[2]=k[0];
     for (size_t i=3; i<67; ++i)
     {
-        key[i] = c^(z&1)^key[i-3]^rotrFixed(key[i-1],3)^rotrFixed(key[i-1],4);
+        key[i] = c ^ (z & 1) ^ key[i - 3] ^ rotrConstant<3>(key[i - 1]) ^ rotrConstant<4>(key[i - 1]);
         z>>=1;
     }
 
-    key[67] = c^key[64]^rotrFixed(key[66],3)^rotrFixed(key[66],4);
-    key[68] = c^1^key[65]^rotrFixed(key[67],3)^rotrFixed(key[67],4);
+    key[67] = c^key[64] ^ rotrConstant<3>(key[66]) ^ rotrConstant<4>(key[66]);
+    key[68] = c ^ 1 ^ key[65] ^ rotrConstant<3>(key[67]) ^ rotrConstant<4>(key[67]);
 }
 
 //! \brief Subkey generation function
@@ -181,14 +181,14 @@ inline void SIMON128_ExpandKey_72R4K(word64 key[72], const word64 k[4])
     key[0]=k[3]; key[1]=k[2]; key[2]=k[1]; key[3]=k[0];
     for (size_t i=4; i<68; ++i)
     {
-        key[i] = c^(z&1)^key[i-4]^rotrFixed(key[i-1],3)^key[i-3]^rotrFixed(key[i-1],4)^rotrFixed(key[i-3],1);
+        key[i] = c ^ (z & 1) ^ key[i - 4] ^ rotrConstant<3>(key[i - 1]) ^ key[i - 3] ^ rotrConstant<4>(key[i - 1]) ^ rotrConstant<1>(key[i - 3]);
         z>>=1;
     }
 
-    key[68] = c^key[64]^rotrFixed(key[67],3)^key[65]^rotrFixed(key[67],4)^rotrFixed(key[65],1);
-    key[69] = c^1^key[65]^rotrFixed(key[68],3)^key[66]^rotrFixed(key[68],4)^rotrFixed(key[66],1);
-    key[70] = c^key[66]^rotrFixed(key[69],3)^key[67]^rotrFixed(key[69],4)^rotrFixed(key[67],1);
-    key[71] = c^key[67]^rotrFixed(key[70],3)^key[68]^rotrFixed(key[70],4)^rotrFixed(key[68],1);
+    key[68] = c^key[64] ^ rotrConstant<3>(key[67]) ^ key[65] ^ rotrConstant<4>(key[67]) ^ rotrConstant<1>(key[65]);
+    key[69] = c ^ 1 ^ key[65] ^ rotrConstant<3>(key[68]) ^ key[66] ^ rotrConstant<4>(key[68]) ^ rotrConstant<1>(key[66]);
+    key[70] = c^key[66] ^ rotrConstant<3>(key[69]) ^ key[67] ^ rotrConstant<4>(key[69]) ^ rotrConstant<1>(key[67]);
+    key[71] = c^key[67] ^ rotrConstant<3>(key[70]) ^ key[68] ^ rotrConstant<4>(key[70]) ^ rotrConstant<1>(key[68]);
 }
 
 ANONYMOUS_NAMESPACE_END
diff --git a/siphash.h b/siphash.h
index f8418c51..5f36cd39 100644
--- a/siphash.h
+++ b/siphash.h
@@ -90,19 +90,19 @@ protected:
 	inline void SIPROUND()
 	{
 		m_v[0] += m_v[1];
-		m_v[1] = rotlFixed(m_v[1], 13U);
+		m_v[1] = rotlConstant<13>(m_v[1]);
 		m_v[1] ^= m_v[0];
-		m_v[0] = rotlFixed(m_v[0], 32U);
+		m_v[0] = rotlConstant<32>(m_v[0]);
 		m_v[2] += m_v[3];
-		m_v[3] = rotlFixed(m_v[3], 16U);
+		m_v[3] = rotlConstant<16>(m_v[3]);
 		m_v[3] ^= m_v[2];
 		m_v[0] += m_v[3];
-		m_v[3] = rotlFixed(m_v[3], 21U);
+		m_v[3] = rotlConstant<21>(m_v[3]);
 		m_v[3] ^= m_v[0];
 		m_v[2] += m_v[1];
-		m_v[1] = rotlFixed(m_v[1], 17U);
+		m_v[1] = rotlConstant<17>(m_v[1]);
 		m_v[1] ^= m_v[2];
-		m_v[2] = rotlFixed(m_v[2], 32U);
+		m_v[2] = rotlConstant<32>(m_v[2]);
 	}
 
 private:
diff --git a/sosemanuk.cpp b/sosemanuk.cpp
index 0ff37d0c..276ebb2d 100644
--- a/sosemanuk.cpp
+++ b/sosemanuk.cpp
@@ -85,7 +85,7 @@ void SosemanukPolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv,
 
 #define XMUX(c, x, y)   (x ^ (y & (0 - (c & 1))))
 	m_state[11] += XMUX(m_state[10], m_state[1], m_state[8]);
-	m_state[10] = rotlFixed(m_state[10] * 0x54655307, 7);
+	m_state[10] = rotlConstant<7>(m_state[10] * 0x54655307);
 }
 
 extern "C" {
@@ -626,7 +626,7 @@ void SosemanukPolicy::OperateKeystream(KeystreamOperation operation, byte *outpu
 #ifndef CRYPTOPP_GENERATE_X64_MASM
 	{
 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) && !defined(CRYPTOPP_DISABLE_SOSEMANUK_ASM)
-#define MUL_A(x)    (x = rotlFixed(x, 8), x ^ s_sosemanukMulTables[byte(x)])
+#define MUL_A(x)    (x = (rotlConstant<7>(x)), x ^ s_sosemanukMulTables[byte(x)])
 #else
 #define MUL_A(x)    (((x) << 8) ^ s_sosemanukMulTables[(x) >> 24])
 #endif
diff --git a/square.cpp b/square.cpp
index 0b960323..4065a7f3 100644
--- a/square.cpp
+++ b/square.cpp
@@ -58,7 +58,7 @@ void Square::Base::UncheckedSetKey(const byte *userKey, unsigned int length, con
 	/* apply the key evolution function */
 	for (int i = 1; i < ROUNDS+1; i++)
 	{
-		roundkeys(i, 0) = roundkeys(i-1, 0) ^ rotlFixed(roundkeys(i-1, 3), 8U) ^ offset[i-1];
+		roundkeys(i, 0) = roundkeys(i-1, 0) ^ rotlConstant<8>(roundkeys(i-1, 3)) ^ offset[i-1];
 		roundkeys(i, 1) = roundkeys(i-1, 1) ^ roundkeys(i, 0);
 		roundkeys(i, 2) = roundkeys(i-1, 2) ^ roundkeys(i, 1);
 		roundkeys(i, 3) = roundkeys(i-1, 3) ^ roundkeys(i, 2);
diff --git a/threefish.cpp b/threefish.cpp
index 8fff615b..ff74566e 100644
--- a/threefish.cpp
+++ b/threefish.cpp
@@ -12,24 +12,16 @@
 
 ANONYMOUS_NAMESPACE_BEGIN
 
-#if defined(__clang__)
-# define rotatel64(x,y) rotlVariable(x,y)
-# define rotater64(x,y) rotrVariable(x,y)
-#else
-# define rotatel64(x,y) rotlFixed(x,y)
-# define rotater64(x,y) rotrFixed(x,y)
-#endif
-
 #define G256(G0, G1, G2, G3, C0, C1) \
     G0 += G1; \
-    G1 = rotatel64(G1, C0) ^ G0; \
+    G1 = rotlVariable(G1, C0) ^ G0; \
     G2 += G3; \
-    G3 = rotatel64(G3, C1) ^ G2;
+    G3 = rotlVariable(G3, C1) ^ G2;
 
 #define IG256(G0, G1, G2, G3, C0, C1) \
-    G3 = rotater64(G3 ^ G2, C1); \
+    G3 = rotrVariable(G3 ^ G2, C1); \
     G2 -= G3; \
-    G1 = rotater64(G1 ^ G0, C0); \
+    G1 = rotrVariable(G1 ^ G0, C0); \
     G0 -= G1; \
 
 #define KS256(r) \
@@ -69,24 +61,24 @@ ANONYMOUS_NAMESPACE_BEGIN
     IKS256(r - 1);
 
 #define IG512(G0, G1, G2, G3, G4, G5, G6, G7, C0, C1, C2, C3) \
-    G7 = rotater64(G7 ^ G6, C3); \
+    G7 = rotrVariable(G7 ^ G6, C3); \
     G6 -= G7; \
-    G5 = rotater64(G5 ^ G4, C2); \
+    G5 = rotrVariable(G5 ^ G4, C2); \
     G4 -= G5; \
-    G3 = rotater64(G3 ^ G2, C1); \
+    G3 = rotrVariable(G3 ^ G2, C1); \
     G2 -= G3; \
-    G1 = rotater64(G1 ^ G0, C0); \
+    G1 = rotrVariable(G1 ^ G0, C0); \
     G0 -= G1;
 
 #define G512(G0, G1, G2, G3, G4, G5, G6, G7, C0, C1, C2, C3) \
     G0 += G1; \
-    G1 = rotatel64(G1, C0) ^ G0; \
+    G1 = rotlVariable(G1, C0) ^ G0; \
     G2 += G3; \
-    G3 = rotatel64(G3, C1) ^ G2; \
+    G3 = rotlVariable(G3, C1) ^ G2; \
     G4 += G5; \
-    G5 = rotatel64(G5, C2) ^ G4; \
+    G5 = rotlVariable(G5, C2) ^ G4; \
     G6 += G7; \
-    G7 = rotatel64(G7, C3) ^ G6;
+    G7 = rotlVariable(G7, C3) ^ G6;
 
 #define IKS512(r) \
     G0 -= m_rkey[(r + 1) % 9]; \
@@ -133,40 +125,40 @@ ANONYMOUS_NAMESPACE_BEGIN
     KS512(r + 1)
 
 #define IG1024(G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, G10, G11, G12, G13, G14, G15, C1, C2, C3, C4, C5, C6, C7, C8) \
-    G15 = rotater64(G15 ^ G14, C8); \
+    G15 = rotrVariable(G15 ^ G14, C8); \
     G14 -= G15; \
-    G13 = rotater64(G13 ^ G12, C7); \
+    G13 = rotrVariable(G13 ^ G12, C7); \
     G12 -= G13; \
-    G11 = rotater64(G11 ^ G10, C6); \
+    G11 = rotrVariable(G11 ^ G10, C6); \
     G10 -= G11; \
-    G9 = rotater64(G9 ^ G8, C5); \
+    G9 = rotrVariable(G9 ^ G8, C5); \
     G8 -= G9; \
-    G7 = rotater64(G7 ^ G6, C4); \
+    G7 = rotrVariable(G7 ^ G6, C4); \
     G6 -= G7; \
-    G5 = rotater64(G5 ^ G4, C3); \
+    G5 = rotrVariable(G5 ^ G4, C3); \
     G4 -= G5; \
-    G3 = rotater64(G3 ^ G2, C2); \
+    G3 = rotrVariable(G3 ^ G2, C2); \
     G2 -= G3; \
-    G1 = rotater64(G1 ^ G0, C1); \
+    G1 = rotrVariable(G1 ^ G0, C1); \
     G0 -= G1;
 
 #define G1024(G0, G1, G2, G3, G4, G5, G6, G7, G8, G9, G10, G11, G12, G13, G14, G15, C1, C2, C3, C4, C5, C6, C7, C8) \
     G0 += G1; \
-    G1 = rotatel64(G1, C1) ^ G0; \
+    G1 = rotlVariable(G1, C1) ^ G0; \
     G2 += G3; \
-    G3 = rotatel64(G3, C2) ^ G2; \
+    G3 = rotlVariable(G3, C2) ^ G2; \
     G4 += G5; \
-    G5 = rotatel64(G5, C3) ^ G4; \
+    G5 = rotlVariable(G5, C3) ^ G4; \
     G6 += G7; \
-    G7 = rotatel64(G7, C4) ^ G6; \
+    G7 = rotlVariable(G7, C4) ^ G6; \
     G8 += G9; \
-    G9 = rotatel64(G9, C5) ^ G8; \
+    G9 = rotlVariable(G9, C5) ^ G8; \
     G10 += G11; \
-    G11 = rotatel64(G11, C6) ^ G10; \
+    G11 = rotlVariable(G11, C6) ^ G10; \
     G12 += G13; \
-    G13 = rotatel64(G13, C7) ^ G12; \
+    G13 = rotlVariable(G13, C7) ^ G12; \
     G14 += G15; \
-    G15 = rotatel64(G15, C8) ^ G14;
+    G15 = rotlVariable(G15, C8) ^ G14;
 
 #define IKS1024(r) \
     G0 -= m_rkey[(r + 1) % 17]; \
diff --git a/ttmac.cpp b/ttmac.cpp
index 98954370..7bcb9855 100644
--- a/ttmac.cpp
+++ b/ttmac.cpp
@@ -99,8 +99,8 @@ void TTMAC_Base::Transform(word32 *digest, const word32 *X, bool last)
 {
 #define Subround(f, a, b, c, d, e, x, s, k)		\
 	a += f(b, c, d) + x + k;\
-	a = rotlFixed((word32)a, s) + e;\
-	c = rotlFixed((word32)c, 10U)
+	a = rotlVariable((word32)a, s) + e;\
+	c = rotlVariable((word32)c, 10U)
 
 	word32 a1, b1, c1, d1, e1, a2, b2, c2, d2, e2;
 	word32 *trackA, *trackB;
diff --git a/twofish.cpp b/twofish.cpp
index d7104cbd..1097eba5 100644
--- a/twofish.cpp
+++ b/twofish.cpp
@@ -64,9 +64,9 @@ void Twofish::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength,
 	for (i=0; i<40; i+=2)
 	{
 		word32 a = h(i, key, len);
-		word32 b = rotlFixed(h(i+1, key+1, len), 8);
+		word32 b = rotlConstant<8>(h(i + 1, key + 1, len));
 		m_k[i] = a+b;
-		m_k[i+1] = rotlFixed(a+2*b, 9);
+		m_k[i + 1] = rotlConstant<9>(a + 2 * b);
 	}
 
 	SecBlock<word32> svec(2*len);
@@ -89,8 +89,8 @@ void Twofish::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength,
 	x = G1 (a); y = G2 (b); \
 	x += y; y += x + k[2 * (n) + 1]; \
 	(c) ^= x + k[2 * (n)]; \
-	(c) = rotrFixed(c, 1); \
-	(d) = rotlFixed(d, 1) ^ y
+	(c) = rotrConstant<1>(c); \
+	(d) = rotlConstant<1>(d) ^ y
 
 #define ENCCYCLE(n) \
 	ENCROUND (2 * (n), a, b, c, d); \
@@ -100,8 +100,8 @@ void Twofish::Base::UncheckedSetKey(const byte *userKey, unsigned int keylength,
 	x = G1 (a); y = G2 (b); \
 	x += y; y += x; \
 	(d) ^= y + k[2 * (n) + 1]; \
-	(d) = rotrFixed(d, 1); \
-	(c) = rotlFixed(c, 1); \
+	(d) = rotrConstant<1>(d); \
+	(c) = rotlConstant<1>(c); \
 	(c) ^= (x + k[2 * (n)])
 
 #define DECCYCLE(n) \
diff --git a/whrlpool.cpp b/whrlpool.cpp
index 49b030e4..9fb28bda 100644
--- a/whrlpool.cpp
+++ b/whrlpool.cpp
@@ -621,16 +621,16 @@ void Whirlpool::Transform(word64 *digest, const word64 *block)
 
 #define KSH(op, i, a, b, c, d)	\
 	t = (word32)(k[(i+4)%8]>>32);\
-	w##a = Whirlpool_C[3*256 + (byte)t] ^ (op ? w##a : rotrFixed(w##a, 32));\
+	w##a = Whirlpool_C[3*256 + (byte)t] ^ (op ? w##a : rotrConstant<32>(w##a));\
 	if (op==2) k[a] = w##a;\
 	t >>= 8;\
-	w##b = Whirlpool_C[2*256 + (byte)t] ^ (op ? w##b : rotrFixed(w##b, 32));\
+	w##b = Whirlpool_C[2*256 + (byte)t] ^ (op ? w##b : rotrConstant<32>(w##b));\
 	if (op==2) k[b] = w##b;\
 	t >>= 8;\
-	w##c = Whirlpool_C[1*256 + (byte)t] ^ (op ? w##c : rotrFixed(w##c, 32));\
+	w##c = Whirlpool_C[1*256 + (byte)t] ^ (op ? w##c : rotrConstant<32>(w##c));\
 	if (op==2) k[c] = w##c;\
 	t >>= 8;\
-	w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : rotrFixed(w##d, 32));\
+	w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : rotrConstant<32>(w##d));\
 	if (op==2) k[d] = w##d;\
 
 #define TSL(op, i, a, b, c, d)	\
@@ -644,7 +644,7 @@ void Whirlpool::Transform(word64 *digest, const word64 *block)
 	w##d = Whirlpool_C[0*256 + t]       ^ (op ? w##d : 0);
 
 #define TSH_OP(op, a, b)	\
-	w##a = Whirlpool_C[b*256 + (byte)t] ^ (op ? w##a : rotrFixed(w##a, 32) ^ k[a]);\
+	w##a = Whirlpool_C[b*256 + (byte)t] ^ (op ? w##a : rotrConstant<32>(w##a) ^ k[a]);\
 	if (op==2) s[a] = w##a;\
 	if (op==3) digest[a] ^= w##a;\