Made keyread (key scanning) a key specific attribute.

This avoids using fulltext keys for table scanning.
This also reverts Sinisa's original fix for this problem.


Docs/manual.texi:
  Update of SQL_JOIN_MAX_SIZE information3602
client/mysqldump.c:
  comment cleanup
include/my_aes.h:
  General cleanup for new file
include/rijndael.h:
  General cleanup for new file
include/sha1.h:
  General cleanup for new file
mysys/my_aes.c:
  General cleanup for new file
mysys/rijndael.c:
  General cleanup for new file
mysys/sha1.c:
  General cleanup for new file
sql/ha_berkeley.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_innodb.cc:
  Merge with 3.23.x
sql/ha_innodb.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_isam.cc:
  Moved things to table_flags()
sql/ha_isam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.cc:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisammrg.h:
  Made keyread (key scanning) a key specific attribute.
sql/handler.h:
  Made keyread (key scanning) a key specific attribute.
sql/item_strfunc.cc:
  Cleanup of AES_xxx code
sql/opt_range.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_base.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_cache.cc:
  Removed compiler warning
sql/sql_select.cc:
  Removed wrong patch to fulltext problem
sql/table.cc:
  Made keyread (key scanning) a key specific attribute.
sql/table.h:
  Made keyread (key scanning) a key specific attribute.

1 files changed, 511 insertions, 557 deletions

diff --git a/mysys/rijndael.c b/mysys/rijndael.c
index 4d53beb44cb..dd0c45445d5 100644
--- a/mysys/rijndael.c
+++ b/mysys/rijndael.c
@@ -4,46 +4,38 @@
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  at your option) any later version.
- 
+
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
- 
+
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
-				                                                                                      
+
 /*
- rijndael-alg-fst.c
- 
-  @version 3.0 (December 2000)
- 
+  Based on version 3.0 (December 2000)
+
   Optimised ANSI C code for the Rijndael cipher (now AES)
- 
-  @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
-  @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
-  @author Paulo Barreto <paulo.barreto@terra.com.br>
- 
-  This code is hereby placed in the public domain.
- 
- */
- 
-#include <my_global.h> 
-#include <assert.h>

 
+  author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
+  author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
+  author Paulo Barreto <paulo.barreto@terra.com.br>
+*/
+
+#include <my_global.h>
+#include <assert.h>
 #include "rijndael.h"
 
-/* 
- May be defined to use fastest and much larger code (~10K extra code)
- #define FULL_UNROLL 
+/*
+  Define the following to use fastest and much larger code (~10K extra code)
+  #define FULL_UNROLL
 */
 
 
 #ifdef NOT_USED
-
-/*
 Te0[x] = S [x].[02, 01, 01, 03];
 Te1[x] = S [x].[03, 02, 01, 01];
 Te2[x] = S [x].[01, 03, 02, 01];
@@ -55,10 +47,9 @@ Td1[x] = Si[x].[0b, 0e, 09, 0d];
 Td2[x] = Si[x].[0d, 0b, 0e, 09];
 Td3[x] = Si[x].[09, 0d, 0b, 0e];
 Td4[x] = Si[x].[01, 01, 01, 01];
-*/
-
 #endif
 
+
 static const uint32 Te0[256]=
 {
   0xc66363a5U, 0xf87c7c84U, 0xee777799U, 0xf67b7b8dU,
@@ -126,6 +117,7 @@ static const uint32 Te0[256]=
   0x824141c3U, 0x299999b0U, 0x5a2d2d77U, 0x1e0f0f11U,
   0x7bb0b0cbU, 0xa85454fcU, 0x6dbbbbd6U, 0x2c16163aU,
 };
+
 static const uint32 Te1[256]=
 {
   0xa5c66363U, 0x84f87c7cU, 0x99ee7777U, 0x8df67b7bU,
@@ -194,7 +186,8 @@ static const uint32 Te1[256]=
   0xcb7bb0b0U, 0xfca85454U, 0xd66dbbbbU, 0x3a2c1616U,
 };
 
-static const uint32 Te2[256] = {
+static const uint32 Te2[256]=
+{
   0x63a5c663U, 0x7c84f87cU, 0x7799ee77U, 0x7b8df67bU,
   0xf20dfff2U, 0x6bbdd66bU, 0x6fb1de6fU, 0xc55491c5U,
   0x30506030U, 0x01030201U, 0x67a9ce67U, 0x2b7d562bU,
@@ -738,85 +731,86 @@ static const uint32 Td4[256]=
   0x55555555U, 0x21212121U, 0x0c0c0c0cU, 0x7d7d7d7dU,
 };
 
+
 /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
 static const uint32 rcon[]=
 {
   0x01000000, 0x02000000, 0x04000000, 0x08000000,
   0x10000000, 0x20000000, 0x40000000, 0x80000000,
-  0x1B000000, 0x36000000, 
+  0x1B000000, 0x36000000,
 };
 
-#define RJ_SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
-
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && defined(__i386__)
 
+#define RJ_SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
 #define GETuint32(p) RJ_SWAP(*((uint32 *)(p)))
 #define PUTuint32(ct, st) { *((uint32 *)(ct)) = RJ_SWAP((st)); }
 
 #else
 
 #define GETuint32(pt) (((uint32)(pt)[0] << 24) ^ ((uint32)(pt)[1] << 16)\
-        ^ ((uint32)(pt)[2] <<  8) ^ ((uint32)(pt)[3]))
+	^ ((uint32)(pt)[2] <<  8) ^ ((uint32)(pt)[3]))
 #define PUTuint32(ct, st) { (ct)[0] = (uint8)((st) >> 24); (ct)[1]\
 = (uint8)((st) >> 16); (ct)[2] = (uint8)((st) >>  8); (ct)[3] = (uint8)(st); }
 
-#endif
+#endif /* defined(_MSC_VER) && defined(__i386__) */
 
 
 /*
- Expand the cipher key into the encryption key schedule.
- 
- @return	the number of rounds for the given cipher key size.
+  Expand the cipher key into the encryption key schedule.
+
+ RETURN
+   The number of rounds for the given cipher key size.
 */
 
-int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[], 
-                        int keyBits)
+int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
+			int keyBits)
 {
   int i = 0;
   uint32 temp;
-  
-  rk[0] = GETuint32(cipherKey     );
+
+  rk[0] = GETuint32(cipherKey	  );
   rk[1] = GETuint32(cipherKey +  4);
   rk[2] = GETuint32(cipherKey +  8);
   rk[3] = GETuint32(cipherKey + 12);
   if (keyBits == 128)
   {
-    for (;;) 
+    for (;;)
     {
       temp  = rk[3];
-      rk[4] = rk[0] ^
-      (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-      (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-      (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-      (Te4[(temp >> 24)       ] & 0x000000ff) ^
-      rcon[i];
+      rk[4] = (rk[0] ^
+	       (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+	       (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+	       (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
+	       (Te4[(temp >> 24)       ] & 0x000000ff) ^
+	       rcon[i]);
       rk[5] = rk[1] ^ rk[4];
       rk[6] = rk[2] ^ rk[5];
       rk[7] = rk[3] ^ rk[6];
-      if (++i == 10) 
-        return 10;
+      if (++i == 10)
+	return 10;
       rk += 4;
     }
   }
   rk[4] = GETuint32(cipherKey + 16);
   rk[5] = GETuint32(cipherKey + 20);
-  if (keyBits == 192) 
+  if (keyBits == 192)
   {
-    for (;;) 
+    for (;;)
     {
       temp = rk[ 5];
       rk[ 6] = (rk[ 0] ^
-      (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-      (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-      (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-      (Te4[(temp >> 24)       ] & 0x000000ff) ^
-      rcon[i]);
+		(Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+		(Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+		(Te4[(temp	) & 0xff] & 0x0000ff00) ^
+		(Te4[(temp >> 24)	] & 0x000000ff) ^
+		rcon[i]);
       rk[ 7] = rk[ 1] ^ rk[ 6];
       rk[ 8] = rk[ 2] ^ rk[ 7];
       rk[ 9] = rk[ 3] ^ rk[ 8];
-      if (++i == 8) 
+      if (++i == 8)
       {
-        return 12;
+	return 12;
       }
       rk[10] = rk[ 4] ^ rk[ 9];
       rk[11] = rk[ 5] ^ rk[10];
@@ -825,30 +819,30 @@ int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
   }
   rk[6] = GETuint32(cipherKey + 24);
   rk[7] = GETuint32(cipherKey + 28);
-  if (keyBits == 256) 
+  if (keyBits == 256)
   {
-    for (;;) 
+    for (;;)
     {
       temp = rk[ 7];
       rk[ 8] = (rk[ 0] ^
-      (Te4[(temp >> 16) & 0xff] & 0xff000000) ^
-      (Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
-      (Te4[(temp      ) & 0xff] & 0x0000ff00) ^
-      (Te4[(temp >> 24)       ] & 0x000000ff) ^
-      rcon[i]);
+		(Te4[(temp >> 16) & 0xff] & 0xff000000) ^
+		(Te4[(temp >>  8) & 0xff] & 0x00ff0000) ^
+		(Te4[(temp	) & 0xff] & 0x0000ff00) ^
+		(Te4[(temp >> 24)	] & 0x000000ff) ^
+		rcon[i]);
       rk[ 9] = rk[ 1] ^ rk[ 8];
       rk[10] = rk[ 2] ^ rk[ 9];
       rk[11] = rk[ 3] ^ rk[10];
-      if (++i == 7) 
+      if (++i == 7)
       {
-        return 14;
+	return 14;
       }
       temp = rk[11];
       rk[12] = (rk[ 4] ^
-      (Te4[(temp >> 24)       ] & 0xff000000) ^
-      (Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
-      (Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
-      (Te4[(temp      ) & 0xff] & 0x000000ff));
+		(Te4[(temp >> 24)	] & 0xff000000) ^
+		(Te4[(temp >> 16) & 0xff] & 0x00ff0000) ^
+		(Te4[(temp >>  8) & 0xff] & 0x0000ff00) ^
+		(Te4[(temp	) & 0xff] & 0x000000ff));
       rk[13] = rk[ 5] ^ rk[12];
       rk[14] = rk[ 6] ^ rk[13];
       rk[15] = rk[ 7] ^ rk[14];
@@ -860,584 +854,544 @@ int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
 
 
 /*
-Expand the cipher key into the decryption key schedule.
+  Expand the cipher key into the decryption key schedule.
 
-@return	the number of rounds for the given cipher key size.
+  RETURN
+    The number of rounds for the given cipher key size.
 */
 
 int rijndaelKeySetupDec(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
-                        int keyBits)
+			int keyBits)
 {
-  int Nr, i, j;
+  int nr, i, j;
   uint32 temp;
-  
+
   /* expand the cipher key: */
-  Nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
+  nr = rijndaelKeySetupEnc(rk, cipherKey, keyBits);
   /* invert the order of the round keys: */
-  for (i = 0, j = 4*Nr; i < j; i += 4, j -= 4) 
+  for (i = 0, j = 4*nr; i < j; i += 4, j -= 4)
   {
-    temp = rk[i    ]; rk[i    ] = rk[j    ]; rk[j    ] = temp;
+    temp = rk[i    ]; rk[i    ] = rk[j	  ]; rk[j    ] = temp;
     temp = rk[i + 1]; rk[i + 1] = rk[j + 1]; rk[j + 1] = temp;
     temp = rk[i + 2]; rk[i + 2] = rk[j + 2]; rk[j + 2] = temp;
     temp = rk[i + 3]; rk[i + 3] = rk[j + 3]; rk[j + 3] = temp;
   }
-  /* 
-    apply the inverse MixColumn transform to 
-    all round keys but the first and the last: 
+  /*
+    Apply the inverse MixColumn transform to all round keys but the first
+    and the last:
   */
-  for (i = 1; i < Nr; i++) 
+  for (i = 1; i < nr; i++)
   {
     rk += 4;
-    
-    rk[0] =
-    Td0[Te4[(rk[0] >> 24)       ] & 0xff] ^
-    Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^
-    Td2[Te4[(rk[0] >>  8) & 0xff] & 0xff] ^
-    Td3[Te4[(rk[0]      ) & 0xff] & 0xff];
-    
-    rk[1] =
-    Td0[Te4[(rk[1] >> 24)       ] & 0xff] ^
-    Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^
-    Td2[Te4[(rk[1] >>  8) & 0xff] & 0xff] ^
-    Td3[Te4[(rk[1]      ) & 0xff] & 0xff];
-    
-    rk[2] =
-    Td0[Te4[(rk[2] >> 24)       ] & 0xff] ^
-    Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^
-    Td2[Te4[(rk[2] >>  8) & 0xff] & 0xff] ^
-    Td3[Te4[(rk[2]      ) & 0xff] & 0xff];
-    
-    rk[3] =
-    Td0[Te4[(rk[3] >> 24)       ] & 0xff] ^
-    Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^
-    Td2[Te4[(rk[3] >>  8) & 0xff] & 0xff] ^
-    Td3[Te4[(rk[3]      ) & 0xff] & 0xff];
+
+    rk[0]= (
+	    Td0[Te4[(rk[0] >> 24)	  ] & 0xff] ^
+	    Td1[Te4[(rk[0] >> 16) & 0xff] & 0xff] ^
+	    Td2[Te4[(rk[0] >>  8) & 0xff] & 0xff] ^
+	    Td3[Te4[(rk[0]	  ) & 0xff] & 0xff]);
+
+    rk[1]= (Td0[Te4[(rk[1] >> 24)	  ] & 0xff] ^
+	    Td1[Te4[(rk[1] >> 16) & 0xff] & 0xff] ^
+	    Td2[Te4[(rk[1] >>  8) & 0xff] & 0xff] ^
+	    Td3[Te4[(rk[1]	  ) & 0xff] & 0xff]);
+
+    rk[2]= (Td0[Te4[(rk[2] >> 24)	  ] & 0xff] ^
+	    Td1[Te4[(rk[2] >> 16) & 0xff] & 0xff] ^
+	    Td2[Te4[(rk[2] >>  8) & 0xff] & 0xff] ^
+	    Td3[Te4[(rk[2]	  ) & 0xff] & 0xff]);
+
+    rk[3]= (Td0[Te4[(rk[3] >> 24)	  ] & 0xff] ^
+	    Td1[Te4[(rk[3] >> 16) & 0xff] & 0xff] ^
+	    Td2[Te4[(rk[3] >>  8) & 0xff] & 0xff] ^
+	    Td3[Te4[(rk[3]	  ) & 0xff] & 0xff]);
   }
-  return Nr;
+  return nr;
 }
 
-void rijndaelEncrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, 
-                     const uint8 pt[16], uint8 ct[16])
+
+void rijndaelEncrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr,
+		     const uint8 pt[16], uint8 ct[16])
 {
   uint32 s0, s1, s2, s3, t0, t1, t2, t3;
 #ifndef FULL_UNROLL
-    int r;
-#endif /* ?FULL_UNROLL */
+  int r;
+#endif /* FULL_UNROLL */
 
-  /*
-   map byte array block to cipher state
-   and add initial round key:
-  */
-  s0 = GETuint32(pt     ) ^ rk[0];
+  /* map byte array block to cipher state and add initial round key: */
+  s0 = GETuint32(pt	) ^ rk[0];
   s1 = GETuint32(pt +  4) ^ rk[1];
   s2 = GETuint32(pt +  8) ^ rk[2];
   s3 = GETuint32(pt + 12) ^ rk[3];
-  
+
 #ifdef FULL_UNROLL
   /* round 1: */
-  t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-  ^ Te3[s3 & 0xff] ^ rk[ 4];
-  t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-  ^ Te3[s0 & 0xff] ^ rk[ 5];
-  t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-  ^ Te3[s1 & 0xff] ^ rk[ 6];
-  t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-  ^ Te3[s2 & 0xff] ^ rk[ 7];
-  
+  t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+       ^ Te3[s3 & 0xff] ^ rk[ 4]);
+  t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+       ^ Te3[s0 & 0xff] ^ rk[ 5]);
+  t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+       ^ Te3[s1 & 0xff] ^ rk[ 6]);
+  t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+       ^ Te3[s2 & 0xff] ^ rk[ 7]);
+
   /* round 2: */
-  s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
-  ^ Te3[t3 & 0xff] ^ rk[ 8];
-  s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-  ^ Te3[t0 & 0xff] ^ rk[ 9];
-  s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-  ^ Te3[t1 & 0xff] ^ rk[10];
-  s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-  ^ Te3[t2 & 0xff] ^ rk[11];
-  
+  s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
+       ^ Te3[t3 & 0xff] ^ rk[ 8]);
+  s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
+       ^ Te3[t0 & 0xff] ^ rk[ 9]);
+  s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
+       ^ Te3[t1 & 0xff] ^ rk[10]);
+  s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
+       ^ Te3[t2 & 0xff] ^ rk[11]);
+
   /* round 3: */
-  t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-  ^ Te3[s3 & 0xff] ^ rk[12];
-  t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-  ^ Te3[s0 & 0xff] ^ rk[13];
-  t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-  ^ Te3[s1 & 0xff] ^ rk[14];
-  t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-  ^ Te3[s2 & 0xff] ^ rk[15];
-  
+  t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+       ^ Te3[s3 & 0xff] ^ rk[12]);
+  t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+       ^ Te3[s0 & 0xff] ^ rk[13]);
+  t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+       ^ Te3[s1 & 0xff] ^ rk[14]);
+  t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+       ^ Te3[s2 & 0xff] ^ rk[15]);
+
   /* round 4: */
-  s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
-  ^ Te3[t3 & 0xff] ^ rk[16];
-  s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-  ^ Te3[t0 & 0xff] ^ rk[17];
-  s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-  ^ Te3[t1 & 0xff] ^ rk[18];
-  s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-  ^ Te3[t2 & 0xff] ^ rk[19];
-  
+  s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
+       ^ Te3[t3 & 0xff] ^ rk[16]);
+  s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
+       ^ Te3[t0 & 0xff] ^ rk[17]);
+  s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
+       ^ Te3[t1 & 0xff] ^ rk[18]);
+  s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
+       ^ Te3[t2 & 0xff] ^ rk[19]);
+
   /* round 5: */
-  t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-  ^ Te3[s3 & 0xff] ^ rk[20];
-  t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-  ^ Te3[s0 & 0xff] ^ rk[21];
-  t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-  ^ Te3[s1 & 0xff] ^ rk[22];
-  t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-  ^ Te3[s2 & 0xff] ^ rk[23];
-  
+  t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+       ^ Te3[s3 & 0xff] ^ rk[20]);
+  t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+       ^ Te3[s0 & 0xff] ^ rk[21]);
+  t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+       ^ Te3[s1 & 0xff] ^ rk[22]);
+  t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+       ^ Te3[s2 & 0xff] ^ rk[23]);
+
   /* round 6: */
-  s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
-  ^ Te3[t3 & 0xff] ^ rk[24];
-  s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-  ^ Te3[t0 & 0xff] ^ rk[25];
-  s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-  ^ Te3[t1 & 0xff] ^ rk[26];
-  s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-  ^ Te3[t2 & 0xff] ^ rk[27];
-  
+  s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
+       ^ Te3[t3 & 0xff] ^ rk[24]);
+  s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
+       ^ Te3[t0 & 0xff] ^ rk[25]);
+  s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
+       ^ Te3[t1 & 0xff] ^ rk[26]);
+  s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
+       ^ Te3[t2 & 0xff] ^ rk[27]);
+
   /* round 7: */
-  t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-  ^ Te3[s3 & 0xff] ^ rk[28];
-  t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-  ^ Te3[s0 & 0xff] ^ rk[29];
-  t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-  ^ Te3[s1 & 0xff] ^ rk[30];
-  t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-  ^ Te3[s2 & 0xff] ^ rk[31];
-  
+  t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+       ^ Te3[s3 & 0xff] ^ rk[28]);
+  t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+       ^ Te3[s0 & 0xff] ^ rk[29]);
+  t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+       ^ Te3[s1 & 0xff] ^ rk[30]);
+  t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+       ^ Te3[s2 & 0xff] ^ rk[31]);
+
   /* round 8: */
-  s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
-  ^ Te3[t3 & 0xff] ^ rk[32];
-  s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-  ^ Te3[t0 & 0xff] ^ rk[33];
-  s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-  ^ Te3[t1 & 0xff] ^ rk[34];
-  s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-  ^ Te3[t2 & 0xff] ^ rk[35];
-  
+  s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
+       ^ Te3[t3 & 0xff] ^ rk[32]);
+  s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
+       ^ Te3[t0 & 0xff] ^ rk[33]);
+  s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
+       ^ Te3[t1 & 0xff] ^ rk[34]);
+  s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
+       ^ Te3[t2 & 0xff] ^ rk[35]);
+
   /* round 9: */
-  t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-  ^ Te3[s3 & 0xff] ^ rk[36];
-  t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-  ^ Te3[s0 & 0xff] ^ rk[37];
-  t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-  ^ Te3[s1 & 0xff] ^ rk[38];
-  t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-  ^ Te3[s2 & 0xff] ^ rk[39];
-  
-  if (Nr > 10) 
-  {  
+  t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+       ^ Te3[s3 & 0xff] ^ rk[36]);
+  t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+       ^ Te3[s0 & 0xff] ^ rk[37]);
+  t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+       ^ Te3[s1 & 0xff] ^ rk[38]);
+  t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+       ^ Te3[s2 & 0xff] ^ rk[39]);
+
+  if (Nr > 10)
+  {
     /* round 10: */
-    s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff] 
-    ^ Te3[t3 & 0xff] ^ rk[40];
-    s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-    ^ Te3[t0 & 0xff] ^ rk[41];
-    s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-    ^ Te3[t1 & 0xff] ^ rk[42];
-    s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-    ^ Te3[t2 & 0xff] ^ rk[43];
-    
+    s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
+	 ^ Te3[t3 & 0xff] ^ rk[40]);
+    s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
+	 ^ Te3[t0 & 0xff] ^ rk[41]);
+    s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
+	 ^ Te3[t1 & 0xff] ^ rk[42]);
+    s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
+	 ^ Te3[t2 & 0xff] ^ rk[43]);
+
     /* round 11: */
-    t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-    ^ Te3[s3 & 0xff] ^ rk[44];
-    t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-    ^ Te3[s0 & 0xff] ^ rk[45];
-    t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-    ^ Te3[s1 & 0xff] ^ rk[46];
-    t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-    ^ Te3[s2 & 0xff] ^ rk[47];
-  
-    if (Nr > 12) 
+    t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
+	 ^ Te3[s3 & 0xff] ^ rk[44]);
+    t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
+	 ^ Te3[s0 & 0xff] ^ rk[45]);
+    t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
+	 ^ Te3[s1 & 0xff] ^ rk[46]);
+    t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
+	 ^ Te3[s2 & 0xff] ^ rk[47]);
+
+    if (Nr > 12)
     {
       /* round 12: */
-      s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>  8) & 0xff]
-      ^ Te3[t3 & 0xff] ^ rk[48];
-      s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>  8) & 0xff]
-      ^ Te3[t0 & 0xff] ^ rk[49];
-      s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>  8) & 0xff]
-      ^ Te3[t1 & 0xff] ^ rk[50];
-      s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>  8) & 0xff]
-      ^ Te3[t2 & 0xff] ^ rk[51];
-      
-     /* round 13: */
-      t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>  8) & 0xff]
-      ^ Te3[s3 & 0xff] ^ rk[52];
-      t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>  8) & 0xff]
-      ^ Te3[s0 & 0xff] ^ rk[53];
-      t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>  8) & 0xff]
-      ^ Te3[s1 & 0xff] ^ rk[54];
-      t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>  8) & 0xff]
-      ^ Te3[s2 & 0xff] ^ rk[55];
+      s0= (Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >>	8) & 0xff]
+	   ^ Te3[t3 & 0xff] ^ rk[48]);
+      s1= (Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >>	8) & 0xff]
+	   ^ Te3[t0 & 0xff] ^ rk[49]);
+      s2= (Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >>	8) & 0xff]
+	   ^ Te3[t1 & 0xff] ^ rk[50]);
+      s3= (Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >>	8) & 0xff]
+	   ^ Te3[t2 & 0xff] ^ rk[51]);
+
+      /* round 13: */
+      t0= (Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >>	8) & 0xff]
+	   ^ Te3[s3 & 0xff] ^ rk[52]);
+      t1= (Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >>	8) & 0xff]
+	   ^ Te3[s0 & 0xff] ^ rk[53]);
+      t2= (Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >>	8) & 0xff]
+	   ^ Te3[s1 & 0xff] ^ rk[54]);
+      t3= (Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >>	8) & 0xff]
+	   ^ Te3[s2 & 0xff] ^ rk[55]);
     }
   }
   rk += Nr << 2;
 #else  /* !FULL_UNROLL */
 
   /* Nr - 1 full rounds: */
-  
+
   r = Nr >> 1;
-  for (;;) 
+  for (;;)
   {
-    t0 =
-    Te0[(s0 >> 24)       ] ^
-    Te1[(s1 >> 16) & 0xff] ^
-    Te2[(s2 >>  8) & 0xff] ^
-    Te3[(s3      ) & 0xff] ^
-    rk[4];
-    
-    t1 =
-    Te0[(s1 >> 24)       ] ^
-    Te1[(s2 >> 16) & 0xff] ^
-    Te2[(s3 >>  8) & 0xff] ^
-    Te3[(s0      ) & 0xff] ^
-    rk[5];
-    
-    t2 =
-    Te0[(s2 >> 24)       ] ^
-    Te1[(s3 >> 16) & 0xff] ^
-    Te2[(s0 >>  8) & 0xff] ^
-    Te3[(s1      ) & 0xff] ^
-    rk[6];
-    
-    t3 =
-    Te0[(s3 >> 24)       ] ^
-    Te1[(s0 >> 16) & 0xff] ^
-    Te2[(s1 >>  8) & 0xff] ^
-    Te3[(s2      ) & 0xff] ^
-    rk[7];
-
-    rk += 8;
-    if (--r == 0) 
-    {
+    t0= (Te0[(s0 >> 24)  ] ^
+	 Te1[(s1 >> 16) & 0xff] ^
+	 Te2[(s2 >>	8) & 0xff] ^
+	 Te3[(s3	 ) & 0xff] ^
+	 rk[4]);
+
+    t1= (Te0[(s1 >> 24)  ] ^
+	 Te1[(s2 >> 16) & 0xff] ^
+	 Te2[(s3 >>	8) & 0xff] ^
+	 Te3[(s0	 ) & 0xff] ^
+	 rk[5]);
+
+    t2= (Te0[(s2 >> 24)  ] ^
+	 Te1[(s3 >> 16) & 0xff] ^
+	 Te2[(s0 >>	8) & 0xff] ^
+	 Te3[(s1	 ) & 0xff] ^
+	 rk[6]);
+
+    t3= (Te0[(s3 >> 24)  ] ^
+	 Te1[(s0 >> 16) & 0xff] ^
+	 Te2[(s1 >>	8) & 0xff] ^
+	 Te3[(s2	 ) & 0xff] ^
+	 rk[7]);
+
+    rk+= 8;
+    if (--r == 0)
       break;
-    }
-    
-    s0 =
-    Te0[(t0 >> 24)       ] ^
-    Te1[(t1 >> 16) & 0xff] ^
-    Te2[(t2 >>  8) & 0xff] ^
-    Te3[(t3      ) & 0xff] ^
-    rk[0];
-    
-    s1 =
-    Te0[(t1 >> 24)       ] ^
-    Te1[(t2 >> 16) & 0xff] ^
-    Te2[(t3 >>  8) & 0xff] ^
-    Te3[(t0      ) & 0xff] ^
-    rk[1];
-    
-    s2 =
-    Te0[(t2 >> 24)       ] ^
-    Te1[(t3 >> 16) & 0xff] ^
-    Te2[(t0 >>  8) & 0xff] ^
-    Te3[(t1      ) & 0xff] ^
-    rk[2];
-    
-    s3 =
-    Te0[(t3 >> 24)       ] ^
-    Te1[(t0 >> 16) & 0xff] ^
-    Te2[(t1 >>  8) & 0xff] ^
-    Te3[(t2      ) & 0xff] ^
-    rk[3];
+
+    s0= (Te0[(t0 >> 24)  ] ^
+	 Te1[(t1 >> 16) & 0xff] ^
+	 Te2[(t2 >>	8) & 0xff] ^
+	 Te3[(t3	 ) & 0xff] ^
+	 rk[0]);
+
+    s1= (Te0[(t1 >> 24)  ] ^
+	 Te1[(t2 >> 16) & 0xff] ^
+	 Te2[(t3 >>	8) & 0xff] ^
+	 Te3[(t0	 ) & 0xff] ^
+	 rk[1]);
+
+    s2= (Te0[(t2 >> 24)  ] ^
+	 Te1[(t3 >> 16) & 0xff] ^
+	 Te2[(t0 >>	8) & 0xff] ^
+	 Te3[(t1	 ) & 0xff] ^
+	 rk[2]);
+
+    s3= (Te0[(t3 >> 24)  ] ^
+	 Te1[(t0 >> 16) & 0xff] ^
+	 Te2[(t1 >>	8) & 0xff] ^
+	 Te3[(t2	 ) & 0xff] ^
+	 rk[3]);
   }
-#endif /* ?FULL_UNROLL */
+#endif /* FULL_UNROLL */
 
-  /*
-   apply last round and
-   map cipher state to byte array block:
-  */
-  s0 =
-  (Te4[(t0 >> 24)       ] & 0xff000000) ^
-  (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
-  (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
-  (Te4[(t3      ) & 0xff] & 0x000000ff) ^
-  rk[0];
-  PUTuint32(ct     , s0);
-  
-  s1 =
-  (Te4[(t1 >> 24)       ] & 0xff000000) ^
-  (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
-  (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
-  (Te4[(t0      ) & 0xff] & 0x000000ff) ^
-  rk[1];
+  /* Apply last round and map cipher state to byte array block: */
+  s0= ((Te4[(t0 >> 24)	] & 0xff000000) ^
+       (Te4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
+       (Te4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
+       (Te4[(t3 ) & 0xff] & 0x000000ff) ^
+       rk[0]);
+  PUTuint32(ct	   , s0);
+
+  s1= ((Te4[(t1 >> 24)	] & 0xff000000) ^
+       (Te4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
+       (Te4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
+       (Te4[(t0 ) & 0xff] & 0x000000ff) ^
+       rk[1]);
   PUTuint32(ct +  4, s1);
-  
-  s2 =
-  (Te4[(t2 >> 24)       ] & 0xff000000) ^
-  (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
-  (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
-  (Te4[(t1      ) & 0xff] & 0x000000ff) ^
-  rk[2];
+
+  s2= ((Te4[(t2 >> 24)	] & 0xff000000) ^
+       (Te4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
+       (Te4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
+       (Te4[(t1 ) & 0xff] & 0x000000ff) ^
+       rk[2]);
   PUTuint32(ct +  8, s2);
-  
-  s3 =
-  (Te4[(t3 >> 24)       ] & 0xff000000) ^
-  (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
-  (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
-  (Te4[(t2      ) & 0xff] & 0x000000ff) ^
-  rk[3];
+
+  s3= ((Te4[(t3 >> 24)	] & 0xff000000) ^
+       (Te4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
+       (Te4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
+       (Te4[(t2 ) & 0xff] & 0x000000ff) ^
+       rk[3]);
   PUTuint32(ct + 12, s3);
 }
 
-void rijndaelDecrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, 
-                     const uint8 ct[16], uint8 pt[16]) 
+
+void rijndaelDecrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr,
+		     const uint8 ct[16], uint8 pt[16])
 {
   uint32 s0, s1, s2, s3, t0, t1, t2, t3;
 #ifndef FULL_UNROLL
   int r;
-#endif /* ?FULL_UNROLL */
+#endif /* FULL_UNROLL */
 
-  /*
-   map byte array block to cipher state
-   and add initial round key:
-  */
-	 
-  s0 = GETuint32(ct     ) ^ rk[0];
+  /* Map byte array block to cipher state and add initial round key: */
+
+  s0 = GETuint32(ct	) ^ rk[0];
   s1 = GETuint32(ct +  4) ^ rk[1];
   s2 = GETuint32(ct +  8) ^ rk[2];
   s3 = GETuint32(ct + 12) ^ rk[3];
-  
+
 #ifdef FULL_UNROLL
   /* round 1: */
-  t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-  ^ Td3[s1 & 0xff] ^ rk[ 4];
-  t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-  ^ Td3[s2 & 0xff] ^ rk[ 5];
-  t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-  ^ Td3[s3 & 0xff] ^ rk[ 6];
-  t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-  ^ Td3[s0 & 0xff] ^ rk[ 7];
-  
+  t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+       ^ Td3[s1 & 0xff] ^ rk[ 4]);
+  t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+       ^ Td3[s2 & 0xff] ^ rk[ 5]);
+  t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+       ^ Td3[s3 & 0xff] ^ rk[ 6]);
+  t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+       ^ Td3[s0 & 0xff] ^ rk[ 7]);
+
   /* round 2: */
-  s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-  ^ Td3[t1 & 0xff] ^ rk[ 8];
-  s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-  ^ Td3[t2 & 0xff] ^ rk[ 9];
-  s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-  ^ Td3[t3 & 0xff] ^ rk[10];
-  s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-  ^ Td3[t0 & 0xff] ^ rk[11];
-  
+  s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
+       ^ Td3[t1 & 0xff] ^ rk[ 8]);
+  s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
+       ^ Td3[t2 & 0xff] ^ rk[ 9]);
+  s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
+       ^ Td3[t3 & 0xff] ^ rk[10]);
+  s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
+       ^ Td3[t0 & 0xff] ^ rk[11]);
+
   /* round 3: */
-  t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-  ^ Td3[s1 & 0xff] ^ rk[12];
-  t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-  ^ Td3[s2 & 0xff] ^ rk[13];
-  t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-  ^ Td3[s3 & 0xff] ^ rk[14];
-  t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-  ^ Td3[s0 & 0xff] ^ rk[15];
-  
+  t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+       ^ Td3[s1 & 0xff] ^ rk[12]);
+  t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+       ^ Td3[s2 & 0xff] ^ rk[13]);
+  t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+       ^ Td3[s3 & 0xff] ^ rk[14]);
+  t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+       ^ Td3[s0 & 0xff] ^ rk[15]);
+
   /* round 4: */
-  s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-  ^ Td3[t1 & 0xff] ^ rk[16];
-  s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-  ^ Td3[t2 & 0xff] ^ rk[17];
-  s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-  ^ Td3[t3 & 0xff] ^ rk[18];
-  s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-  ^ Td3[t0 & 0xff] ^ rk[19];
-  
+  s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
+       ^ Td3[t1 & 0xff] ^ rk[16]);
+  s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
+       ^ Td3[t2 & 0xff] ^ rk[17]);
+  s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
+       ^ Td3[t3 & 0xff] ^ rk[18]);
+  s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
+       ^ Td3[t0 & 0xff] ^ rk[19]);
+
   /* round 5: */
-  t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-  ^ Td3[s1 & 0xff] ^ rk[20];
-  t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-  ^ Td3[s2 & 0xff] ^ rk[21];
-  t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-  ^ Td3[s3 & 0xff] ^ rk[22];
-  t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-  ^ Td3[s0 & 0xff] ^ rk[23];
-  
+  t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+       ^ Td3[s1 & 0xff] ^ rk[20]);
+  t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+       ^ Td3[s2 & 0xff] ^ rk[21]);
+  t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+       ^ Td3[s3 & 0xff] ^ rk[22]);
+  t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+       ^ Td3[s0 & 0xff] ^ rk[23]);
+
   /* round 6: */
-  s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-  ^ Td3[t1 & 0xff] ^ rk[24];
-  s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-  ^ Td3[t2 & 0xff] ^ rk[25];
-  s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-  ^ Td3[t3 & 0xff] ^ rk[26];
-  s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-  ^ Td3[t0 & 0xff] ^ rk[27];
-  
+  s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
+       ^ Td3[t1 & 0xff] ^ rk[24]);
+  s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
+       ^ Td3[t2 & 0xff] ^ rk[25]);
+  s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
+       ^ Td3[t3 & 0xff] ^ rk[26]);
+  s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
+       ^ Td3[t0 & 0xff] ^ rk[27]);
+
   /* round 7: */
-  t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-  ^ Td3[s1 & 0xff] ^ rk[28];
-  t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-  ^ Td3[s2 & 0xff] ^ rk[29];
-  t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-  ^ Td3[s3 & 0xff] ^ rk[30];
-  t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-  ^ Td3[s0 & 0xff] ^ rk[31];
-  
+  t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+       ^ Td3[s1 & 0xff] ^ rk[28]);
+  t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+       ^ Td3[s2 & 0xff] ^ rk[29]);
+  t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+       ^ Td3[s3 & 0xff] ^ rk[30]);
+  t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+       ^ Td3[s0 & 0xff] ^ rk[31]);
+
   /* round 8: */
-  s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-  ^ Td3[t1 & 0xff] ^ rk[32];
-  s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-  ^ Td3[t2 & 0xff] ^ rk[33];
-  s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-  ^ Td3[t3 & 0xff] ^ rk[34];
-  s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-  ^ Td3[t0 & 0xff] ^ rk[35];
-  
+  s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
+       ^ Td3[t1 & 0xff] ^ rk[32]);
+  s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
+       ^ Td3[t2 & 0xff] ^ rk[33]);
+  s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
+       ^ Td3[t3 & 0xff] ^ rk[34]);
+  s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
+       ^ Td3[t0 & 0xff] ^ rk[35]);
+
   /* round 9: */
-  t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-  ^ Td3[s1 & 0xff] ^ rk[36];
-  t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-  ^ Td3[s2 & 0xff] ^ rk[37];
-  t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-  ^ Td3[s3 & 0xff] ^ rk[38];
-  t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-  ^ Td3[s0 & 0xff] ^ rk[39];
-   
-  if (Nr > 10) 
+  t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+       ^ Td3[s1 & 0xff] ^ rk[36]);
+  t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+       ^ Td3[s2 & 0xff] ^ rk[37]);
+  t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+       ^ Td3[s3 & 0xff] ^ rk[38]);
+  t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+       ^ Td3[s0 & 0xff] ^ rk[39]);
+
+  if (Nr > 10)
   {
     /* round 10: */
-    s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-    ^ Td3[t1 & 0xff] ^ rk[40];
-    s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-    ^ Td3[t2 & 0xff] ^ rk[41];
-    s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-    ^ Td3[t3 & 0xff] ^ rk[42];
-    s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-     ^ Td3[t0 & 0xff] ^ rk[43];
-    
+    s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
+	 ^ Td3[t1 & 0xff] ^ rk[40]);
+    s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
+	 ^ Td3[t2 & 0xff] ^ rk[41]);
+    s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
+	 ^ Td3[t3 & 0xff] ^ rk[42]);
+    s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
+	 ^ Td3[t0 & 0xff] ^ rk[43]);
+
     /* round 11: */
-    t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-    ^ Td3[s1 & 0xff] ^ rk[44];
-    t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-    ^ Td3[s2 & 0xff] ^ rk[45];
-    t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-    ^ Td3[s3 & 0xff] ^ rk[46];
-    t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-    ^ Td3[s0 & 0xff] ^ rk[47];
-    
-    if (Nr > 12) 
+    t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
+	 ^ Td3[s1 & 0xff] ^ rk[44]);
+    t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
+	 ^ Td3[s2 & 0xff] ^ rk[45]);
+    t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
+	 ^ Td3[s3 & 0xff] ^ rk[46]);
+    t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
+	 ^ Td3[s0 & 0xff] ^ rk[47]);
+
+    if (Nr > 12)
     {
       /* round 12: */
-      s0 = Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>  8) & 0xff]
-      ^ Td3[t1 & 0xff] ^ rk[48];
-      s1 = Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>  8) & 0xff]
-      ^ Td3[t2 & 0xff] ^ rk[49];
-      s2 = Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>  8) & 0xff]
-      ^ Td3[t3 & 0xff] ^ rk[50];
-      s3 = Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>  8) & 0xff]
-      ^ Td3[t0 & 0xff] ^ rk[51];
-      
+      s0= (Td0[t0 >> 24] ^ Td1[(t3 >> 16) & 0xff] ^ Td2[(t2 >>	8) & 0xff]
+	   ^ Td3[t1 & 0xff] ^ rk[48]);
+      s1= (Td0[t1 >> 24] ^ Td1[(t0 >> 16) & 0xff] ^ Td2[(t3 >>	8) & 0xff]
+	   ^ Td3[t2 & 0xff] ^ rk[49]);
+      s2= (Td0[t2 >> 24] ^ Td1[(t1 >> 16) & 0xff] ^ Td2[(t0 >>	8) & 0xff]
+	   ^ Td3[t3 & 0xff] ^ rk[50]);
+      s3= (Td0[t3 >> 24] ^ Td1[(t2 >> 16) & 0xff] ^ Td2[(t1 >>	8) & 0xff]
+	   ^ Td3[t0 & 0xff] ^ rk[51]);
+
       /* round 13: */
-      t0 = Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>  8) & 0xff]
-      ^ Td3[s1 & 0xff] ^ rk[52];
-      t1 = Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>  8) & 0xff]
-      ^ Td3[s2 & 0xff] ^ rk[53];
-      t2 = Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>  8) & 0xff]
-      ^ Td3[s3 & 0xff] ^ rk[54];
-      t3 = Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>  8) & 0xff]
-      ^ Td3[s0 & 0xff] ^ rk[55];
+      t0= (Td0[s0 >> 24] ^ Td1[(s3 >> 16) & 0xff] ^ Td2[(s2 >>	8) & 0xff]
+	   ^ Td3[s1 & 0xff] ^ rk[52]);
+      t1= (Td0[s1 >> 24] ^ Td1[(s0 >> 16) & 0xff] ^ Td2[(s3 >>	8) & 0xff]
+	   ^ Td3[s2 & 0xff] ^ rk[53]);
+      t2= (Td0[s2 >> 24] ^ Td1[(s1 >> 16) & 0xff] ^ Td2[(s0 >>	8) & 0xff]
+	   ^ Td3[s3 & 0xff] ^ rk[54]);
+      t3= (Td0[s3 >> 24] ^ Td1[(s2 >> 16) & 0xff] ^ Td2[(s1 >>	8) & 0xff]
+	   ^ Td3[s0 & 0xff] ^ rk[55]);
     }
   }
   rk += Nr << 2;
 #else  /* !FULL_UNROLL */
 
   /* Nr - 1 full rounds: */
-  r = Nr >> 1;
-  for (;;) 
+  r= (Nr >> 1);
+  for (;;)
   {
-    t0 =
-    Td0[(s0 >> 24)       ] ^
-    Td1[(s3 >> 16) & 0xff] ^
-    Td2[(s2 >>  8) & 0xff] ^
-    Td3[(s1      ) & 0xff] ^
-    rk[4];
-    
-    t1 =
-    Td0[(s1 >> 24)       ] ^
-    Td1[(s0 >> 16) & 0xff] ^
-    Td2[(s3 >>  8) & 0xff] ^
-    Td3[(s2      ) & 0xff] ^
-    rk[5];
-    
-    t2 =
-    Td0[(s2 >> 24)       ] ^
-    Td1[(s1 >> 16) & 0xff] ^
-    Td2[(s0 >>  8) & 0xff] ^
-    Td3[(s3      ) & 0xff] ^
-    rk[6];
-    
-    t3 =
-    Td0[(s3 >> 24)       ] ^
-    Td1[(s2 >> 16) & 0xff] ^
-    Td2[(s1 >>  8) & 0xff] ^
-    Td3[(s0      ) & 0xff] ^
-    rk[7];
-    
-    rk += 8;
-    if (--r == 0) 
-    {
+    t0= (Td0[(s0 >> 24)  ] ^
+	 Td1[(s3 >> 16) & 0xff] ^
+	 Td2[(s2 >>	8) & 0xff] ^
+	 Td3[(s1	 ) & 0xff] ^
+	 rk[4]);
+
+    t1= (Td0[(s1 >> 24)  ] ^
+	 Td1[(s0 >> 16) & 0xff] ^
+	 Td2[(s3 >>	8) & 0xff] ^
+	 Td3[(s2	 ) & 0xff] ^
+	 rk[5]);
+
+    t2= (Td0[(s2 >> 24)  ] ^
+	 Td1[(s1 >> 16) & 0xff] ^
+	 Td2[(s0 >>	8) & 0xff] ^
+	 Td3[(s3	 ) & 0xff] ^
+	 rk[6]);
+
+    t3= (Td0[(s3 >> 24)  ] ^
+	 Td1[(s2 >> 16) & 0xff] ^
+	 Td2[(s1 >>	8) & 0xff] ^
+	 Td3[(s0	 ) & 0xff] ^
+	 rk[7]);
+
+    rk+= 8;
+    if (--r == 0)
       break;
-    }
 
-    s0 =
-    Td0[(t0 >> 24)       ] ^
-    Td1[(t3 >> 16) & 0xff] ^
-    Td2[(t2 >>  8) & 0xff] ^
-    Td3[(t1      ) & 0xff] ^
-    rk[0];
-    
-    s1 =
-    Td0[(t1 >> 24)       ] ^
-    Td1[(t0 >> 16) & 0xff] ^
-    Td2[(t3 >>  8) & 0xff] ^
-    Td3[(t2      ) & 0xff] ^
-    rk[1];
-    
-    s2 =
-    Td0[(t2 >> 24)       ] ^
-    Td1[(t1 >> 16) & 0xff] ^
-    Td2[(t0 >>  8) & 0xff] ^
-    Td3[(t3      ) & 0xff] ^
-    rk[2];
-    
-    s3 =
-    Td0[(t3 >> 24)       ] ^
-    Td1[(t2 >> 16) & 0xff] ^
-    Td2[(t1 >>  8) & 0xff] ^
-    Td3[(t0      ) & 0xff] ^
-    rk[3];    
+    s0= (Td0[(t0 >> 24)  ] ^
+	 Td1[(t3 >> 16) & 0xff] ^
+	 Td2[(t2 >>	8) & 0xff] ^
+	 Td3[(t1	 ) & 0xff] ^
+	 rk[0]);
+
+    s1= (Td0[(t1 >> 24)  ] ^
+	 Td1[(t0 >> 16) & 0xff] ^
+	 Td2[(t3 >>	8) & 0xff] ^
+	 Td3[(t2	 ) & 0xff] ^
+	 rk[1]);
+
+    s2= (Td0[(t2 >> 24)  ] ^
+	 Td1[(t1 >> 16) & 0xff] ^
+	 Td2[(t0 >>	8) & 0xff] ^
+	 Td3[(t3	 ) & 0xff] ^
+	 rk[2]);
+
+    s3= (Td0[(t3 >> 24)  ] ^
+	 Td1[(t2 >> 16) & 0xff] ^
+	 Td2[(t1 >>	8) & 0xff] ^
+	 Td3[(t0	 ) & 0xff] ^
+	 rk[3]);
   }
-  
-#endif /* ?FULL_UNROLL */
 
-  /*
-   apply last round and
-   map cipher state to byte array block:
-  */
-  
-  s0 =
-  (Td4[(t0 >> 24)       ] & 0xff000000) ^
-  (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
-  (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
-  (Td4[(t1      ) & 0xff] & 0x000000ff) ^
-  rk[0];
-  PUTuint32(pt     , s0);
-  
-  s1 =
-  (Td4[(t1 >> 24)       ] & 0xff000000) ^
-  (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
-  (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
-  (Td4[(t2      ) & 0xff] & 0x000000ff) ^
-  rk[1];  
+#endif /* FULL_UNROLL */
+
+  /* Apply last round and map cipher state to byte array block: */
+
+  s0= ((Td4[(t0 >> 24)	] & 0xff000000) ^
+       (Td4[(t3 >> 16) & 0xff] & 0x00ff0000) ^
+       (Td4[(t2 >>  8) & 0xff] & 0x0000ff00) ^
+       (Td4[(t1 ) & 0xff] & 0x000000ff) ^
+       rk[0]);
+  PUTuint32(pt	   , s0);
+
+  s1= ((Td4[(t1 >> 24)	] & 0xff000000) ^
+       (Td4[(t0 >> 16) & 0xff] & 0x00ff0000) ^
+       (Td4[(t3 >>  8) & 0xff] & 0x0000ff00) ^
+       (Td4[(t2 ) & 0xff] & 0x000000ff) ^
+       rk[1]);
   PUTuint32(pt +  4, s1);
-  
-  s2 =
-  (Td4[(t2 >> 24)       ] & 0xff000000) ^
-  (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
-  (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
-  (Td4[(t3      ) & 0xff] & 0x000000ff) ^
-  rk[2];
-  
+
+  s2= ((Td4[(t2 >> 24)	] & 0xff000000) ^
+       (Td4[(t1 >> 16) & 0xff] & 0x00ff0000) ^
+       (Td4[(t0 >>  8) & 0xff] & 0x0000ff00) ^
+       (Td4[(t3 ) & 0xff] & 0x000000ff) ^
+       rk[2]);
   PUTuint32(pt +  8, s2);
-  s3 =
-  (Td4[(t3 >> 24)       ] & 0xff000000) ^
-  (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
-  (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
-  (Td4[(t0      ) & 0xff] & 0x000000ff) ^
-  rk[3];
-  PUTuint32(pt + 12, s3);  
+
+  s3= ((Td4[(t3 >> 24)	] & 0xff000000) ^
+       (Td4[(t2 >> 16) & 0xff] & 0x00ff0000) ^
+       (Td4[(t1 >>  8) & 0xff] & 0x0000ff00) ^
+       (Td4[(t0 ) & 0xff] & 0x000000ff) ^
+       rk[3]);
+  PUTuint32(pt + 12, s3);
 }