* Patches by Xianghua Xiao, 15 Oct 2003:LABEL_2003_10_16_0200

  - Added Motorola CPU 8540/8560 support (cpu/85xx)
  - Added Motorola MPC8540ADS board support (board/mpc8540ads)
  - Added Motorola MPC8560ADS board support (board/mpc8560ads)

* Minor code cleanup

4 files changed, 692 insertions, 706 deletions

diff --git a/lib_generic/bzlib.c b/lib_generic/bzlib.c
index 4139c5b4bb2..8a64b799e4a 100644
--- a/lib_generic/bzlib.c
+++ b/lib_generic/bzlib.c
@@ -77,7 +77,7 @@
       * fixed bzWrite/bzRead to ignore zero-length requests.
       * fixed bzread to correctly handle read requests after EOF.
       * wrong parameter order in call to bzDecompressInit in
-        bzBuffToBuffDecompress.  Fixed.
+	bzBuffToBuffDecompress.  Fixed.
 --*/
 
 #include "bzlib_private.h"
@@ -196,10 +196,10 @@ Bool isempty_RL ( EState* s )
 
 /*---------------------------------------------------*/
 int BZ_API(BZ2_bzCompressInit)
-                    ( bz_stream* strm,
-                     int        blockSize100k,
-                     int        verbosity,
-                     int        workFactor )
+		    ( bz_stream* strm,
+		     int        blockSize100k,
+		     int        verbosity,
+		     int        workFactor )
 {
    Int32   n;
    EState* s;
@@ -273,26 +273,26 @@ void add_pair_to_block ( EState* s )
    s->inUse[s->state_in_ch] = True;
    switch (s->state_in_len) {
       case 1:
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         break;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 break;
       case 2:
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         break;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 break;
       case 3:
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         break;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 break;
       default:
-         s->inUse[s->state_in_len-4] = True;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = (UChar)ch; s->nblock++;
-         s->block[s->nblock] = ((UChar)(s->state_in_len-4));
-         s->nblock++;
-         break;
+	 s->inUse[s->state_in_len-4] = True;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = (UChar)ch; s->nblock++;
+	 s->block[s->nblock] = ((UChar)(s->state_in_len-4));
+	 s->nblock++;
+	 break;
    }
 }
 
@@ -325,7 +325,7 @@ void flush_RL ( EState* s )
    if (zchh != zs->state_in_ch ||                 \
       zs->state_in_len == 255) {                  \
       if (zs->state_in_ch < 256)                  \
-         add_pair_to_block ( zs );                \
+	 add_pair_to_block ( zs );                \
       zs->state_in_ch = zchh;                     \
       zs->state_in_len = 1;                       \
    } else {                                       \
@@ -344,35 +344,35 @@ Bool copy_input_until_stop ( EState* s )
 
       /*-- fast track the common case --*/
       while (True) {
-         /*-- block full? --*/
-         if (s->nblock >= s->nblockMAX) break;
-         /*-- no input? --*/
-         if (s->strm->avail_in == 0) break;
-         progress_in = True;
-         ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
-         s->strm->next_in++;
-         s->strm->avail_in--;
-         s->strm->total_in_lo32++;
-         if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
+	 /*-- block full? --*/
+	 if (s->nblock >= s->nblockMAX) break;
+	 /*-- no input? --*/
+	 if (s->strm->avail_in == 0) break;
+	 progress_in = True;
+	 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
+	 s->strm->next_in++;
+	 s->strm->avail_in--;
+	 s->strm->total_in_lo32++;
+	 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
       }
 
    } else {
 
       /*-- general, uncommon case --*/
       while (True) {
-         /*-- block full? --*/
-         if (s->nblock >= s->nblockMAX) break;
-         /*-- no input? --*/
-         if (s->strm->avail_in == 0) break;
-         /*-- flush/finish end? --*/
-         if (s->avail_in_expect == 0) break;
-         progress_in = True;
-         ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
-         s->strm->next_in++;
-         s->strm->avail_in--;
-         s->strm->total_in_lo32++;
-         if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
-         s->avail_in_expect--;
+	 /*-- block full? --*/
+	 if (s->nblock >= s->nblockMAX) break;
+	 /*-- no input? --*/
+	 if (s->strm->avail_in == 0) break;
+	 /*-- flush/finish end? --*/
+	 if (s->avail_in_expect == 0) break;
+	 progress_in = True;
+	 ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
+	 s->strm->next_in++;
+	 s->strm->avail_in--;
+	 s->strm->total_in_lo32++;
+	 if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++;
+	 s->avail_in_expect--;
       }
    }
    return progress_in;
@@ -417,34 +417,34 @@ Bool handle_compress ( bz_stream* strm )
    while (True) {
 
       if (s->state == BZ_S_OUTPUT) {
-         progress_out |= copy_output_until_stop ( s );
-         if (s->state_out_pos < s->numZ) break;
-         if (s->mode == BZ_M_FINISHING &&
-             s->avail_in_expect == 0 &&
-             isempty_RL(s)) break;
-         prepare_new_block ( s );
-         s->state = BZ_S_INPUT;
-         if (s->mode == BZ_M_FLUSHING &&
-             s->avail_in_expect == 0 &&
-             isempty_RL(s)) break;
+	 progress_out |= copy_output_until_stop ( s );
+	 if (s->state_out_pos < s->numZ) break;
+	 if (s->mode == BZ_M_FINISHING &&
+	     s->avail_in_expect == 0 &&
+	     isempty_RL(s)) break;
+	 prepare_new_block ( s );
+	 s->state = BZ_S_INPUT;
+	 if (s->mode == BZ_M_FLUSHING &&
+	     s->avail_in_expect == 0 &&
+	     isempty_RL(s)) break;
       }
 
       if (s->state == BZ_S_INPUT) {
-         progress_in |= copy_input_until_stop ( s );
-         if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
-            flush_RL ( s );
-            BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
-            s->state = BZ_S_OUTPUT;
-         }
-         else
-         if (s->nblock >= s->nblockMAX) {
-            BZ2_compressBlock ( s, False );
-            s->state = BZ_S_OUTPUT;
-         }
-         else
-         if (s->strm->avail_in == 0) {
-            break;
-         }
+	 progress_in |= copy_input_until_stop ( s );
+	 if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) {
+	    flush_RL ( s );
+	    BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) );
+	    s->state = BZ_S_OUTPUT;
+	 }
+	 else
+	 if (s->nblock >= s->nblockMAX) {
+	    BZ2_compressBlock ( s, False );
+	    s->state = BZ_S_OUTPUT;
+	 }
+	 else
+	 if (s->strm->avail_in == 0) {
+	    break;
+	 }
       }
 
    }
@@ -467,48 +467,48 @@ int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
    switch (s->mode) {
 
       case BZ_M_IDLE:
-         return BZ_SEQUENCE_ERROR;
+	 return BZ_SEQUENCE_ERROR;
 
       case BZ_M_RUNNING:
-         if (action == BZ_RUN) {
-            progress = handle_compress ( strm );
-            return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
-         }
-         else
+	 if (action == BZ_RUN) {
+	    progress = handle_compress ( strm );
+	    return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
+	 }
+	 else
 	 if (action == BZ_FLUSH) {
-            s->avail_in_expect = strm->avail_in;
-            s->mode = BZ_M_FLUSHING;
-            goto preswitch;
-         }
-         else
-         if (action == BZ_FINISH) {
-            s->avail_in_expect = strm->avail_in;
-            s->mode = BZ_M_FINISHING;
-            goto preswitch;
-         }
-         else
-            return BZ_PARAM_ERROR;
+	    s->avail_in_expect = strm->avail_in;
+	    s->mode = BZ_M_FLUSHING;
+	    goto preswitch;
+	 }
+	 else
+	 if (action == BZ_FINISH) {
+	    s->avail_in_expect = strm->avail_in;
+	    s->mode = BZ_M_FINISHING;
+	    goto preswitch;
+	 }
+	 else
+	    return BZ_PARAM_ERROR;
 
       case BZ_M_FLUSHING:
-         if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
-         if (s->avail_in_expect != s->strm->avail_in)
-            return BZ_SEQUENCE_ERROR;
-         progress = handle_compress ( strm );
-         if (s->avail_in_expect > 0 || !isempty_RL(s) ||
-             s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
-         s->mode = BZ_M_RUNNING;
-         return BZ_RUN_OK;
+	 if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
+	 if (s->avail_in_expect != s->strm->avail_in)
+	    return BZ_SEQUENCE_ERROR;
+	 progress = handle_compress ( strm );
+	 if (s->avail_in_expect > 0 || !isempty_RL(s) ||
+	     s->state_out_pos < s->numZ) return BZ_FLUSH_OK;
+	 s->mode = BZ_M_RUNNING;
+	 return BZ_RUN_OK;
 
       case BZ_M_FINISHING:
-         if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
-         if (s->avail_in_expect != s->strm->avail_in)
-            return BZ_SEQUENCE_ERROR;
-         progress = handle_compress ( strm );
-         if (!progress) return BZ_SEQUENCE_ERROR;
-         if (s->avail_in_expect > 0 || !isempty_RL(s) ||
-             s->state_out_pos < s->numZ) return BZ_FINISH_OK;
-         s->mode = BZ_M_IDLE;
-         return BZ_STREAM_END;
+	 if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
+	 if (s->avail_in_expect != s->strm->avail_in)
+	    return BZ_SEQUENCE_ERROR;
+	 progress = handle_compress ( strm );
+	 if (!progress) return BZ_SEQUENCE_ERROR;
+	 if (s->avail_in_expect > 0 || !isempty_RL(s) ||
+	     s->state_out_pos < s->numZ) return BZ_FINISH_OK;
+	 s->mode = BZ_M_IDLE;
+	 return BZ_STREAM_END;
    }
    return BZ_OK; /*--not reached--*/
 }
@@ -540,9 +540,9 @@ int BZ_API(BZ2_bzCompressEnd)  ( bz_stream *strm )
 
 /*---------------------------------------------------*/
 int BZ_API(BZ2_bzDecompressInit)
-                     ( bz_stream* strm,
-                       int        verbosity,
-                       int        small )
+		     ( bz_stream* strm,
+		       int        verbosity,
+		       int        small )
 {
    DState* s;
 
@@ -587,47 +587,47 @@ void unRLE_obuf_to_output_FAST ( DState* s )
    if (s->blockRandomised) {
 
       while (True) {
-         /* try to finish existing run */
-         while (True) {
-            if (s->strm->avail_out == 0) return;
-            if (s->state_out_len == 0) break;
-            *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
-            BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
-            s->state_out_len--;
-            s->strm->next_out++;
-            s->strm->avail_out--;
-            s->strm->total_out_lo32++;
-            if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
-         }
-
-         /* can a new run be started? */
-         if (s->nblock_used == s->save_nblock+1) return;
-
-
-         s->state_out_len = 1;
-         s->state_out_ch = s->k0;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 2;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 3;
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         s->state_out_len = ((Int32)k1) + 4;
-         BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
-         s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
+	 /* try to finish existing run */
+	 while (True) {
+	    if (s->strm->avail_out == 0) return;
+	    if (s->state_out_len == 0) break;
+	    *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
+	    BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
+	    s->state_out_len--;
+	    s->strm->next_out++;
+	    s->strm->avail_out--;
+	    s->strm->total_out_lo32++;
+	    if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
+	 }
+
+	 /* can a new run be started? */
+	 if (s->nblock_used == s->save_nblock+1) return;
+
+
+	 s->state_out_len = 1;
+	 s->state_out_ch = s->k0;
+	 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 2;
+	 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 3;
+	 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 s->state_out_len = ((Int32)k1) + 4;
+	 BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
+	 s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
       }
 
    } else {
@@ -650,60 +650,60 @@ void unRLE_obuf_to_output_FAST ( DState* s )
 
       while (True) {
 
-         /* try to finish existing run */
-         if (c_state_out_len > 0) {
-            while (True) {
-               if (cs_avail_out == 0) goto return_notr;
-               if (c_state_out_len == 1) break;
-               *( (UChar*)(cs_next_out) ) = c_state_out_ch;
-               BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
-               c_state_out_len--;
-               cs_next_out++;
-               cs_avail_out--;
-            }
-            s_state_out_len_eq_one:
-            {
-               if (cs_avail_out == 0) {
-                  c_state_out_len = 1; goto return_notr;
-               };
-               *( (UChar*)(cs_next_out) ) = c_state_out_ch;
-               BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
-               cs_next_out++;
-               cs_avail_out--;
-            }
-         }
-         /* can a new run be started? */
-         if (c_nblock_used == s_save_nblockPP) {
-            c_state_out_len = 0; goto return_notr;
-         };
-         c_state_out_ch = c_k0;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
-         if (k1 != c_k0) {
-            c_k0 = k1; goto s_state_out_len_eq_one;
-         };
-         if (c_nblock_used == s_save_nblockPP)
-            goto s_state_out_len_eq_one;
-
-         c_state_out_len = 2;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
-         if (c_nblock_used == s_save_nblockPP) continue;
-         if (k1 != c_k0) { c_k0 = k1; continue; };
-
-         c_state_out_len = 3;
-         BZ_GET_FAST_C(k1); c_nblock_used++;
-         if (c_nblock_used == s_save_nblockPP) continue;
-         if (k1 != c_k0) { c_k0 = k1; continue; };
-
-         BZ_GET_FAST_C(k1); c_nblock_used++;
-         c_state_out_len = ((Int32)k1) + 4;
-         BZ_GET_FAST_C(c_k0); c_nblock_used++;
+	 /* try to finish existing run */
+	 if (c_state_out_len > 0) {
+	    while (True) {
+	       if (cs_avail_out == 0) goto return_notr;
+	       if (c_state_out_len == 1) break;
+	       *( (UChar*)(cs_next_out) ) = c_state_out_ch;
+	       BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
+	       c_state_out_len--;
+	       cs_next_out++;
+	       cs_avail_out--;
+	    }
+	    s_state_out_len_eq_one:
+	    {
+	       if (cs_avail_out == 0) {
+		  c_state_out_len = 1; goto return_notr;
+	       };
+	       *( (UChar*)(cs_next_out) ) = c_state_out_ch;
+	       BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
+	       cs_next_out++;
+	       cs_avail_out--;
+	    }
+	 }
+	 /* can a new run be started? */
+	 if (c_nblock_used == s_save_nblockPP) {
+	    c_state_out_len = 0; goto return_notr;
+	 };
+	 c_state_out_ch = c_k0;
+	 BZ_GET_FAST_C(k1); c_nblock_used++;
+	 if (k1 != c_k0) {
+	    c_k0 = k1; goto s_state_out_len_eq_one;
+	 };
+	 if (c_nblock_used == s_save_nblockPP)
+	    goto s_state_out_len_eq_one;
+
+	 c_state_out_len = 2;
+	 BZ_GET_FAST_C(k1); c_nblock_used++;
+	 if (c_nblock_used == s_save_nblockPP) continue;
+	 if (k1 != c_k0) { c_k0 = k1; continue; };
+
+	 c_state_out_len = 3;
+	 BZ_GET_FAST_C(k1); c_nblock_used++;
+	 if (c_nblock_used == s_save_nblockPP) continue;
+	 if (k1 != c_k0) { c_k0 = k1; continue; };
+
+	 BZ_GET_FAST_C(k1); c_nblock_used++;
+	 c_state_out_len = ((Int32)k1) + 4;
+	 BZ_GET_FAST_C(c_k0); c_nblock_used++;
       }
 
       return_notr:
       total_out_lo32_old = s->strm->total_out_lo32;
       s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
       if (s->strm->total_out_lo32 < total_out_lo32_old)
-         s->strm->total_out_hi32++;
+	 s->strm->total_out_hi32++;
 
       /* save */
       s->calculatedBlockCRC = c_calculatedBlockCRC;
@@ -720,7 +720,6 @@ void unRLE_obuf_to_output_FAST ( DState* s )
 }
 
 
-
 /*---------------------------------------------------*/
 __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
 {
@@ -745,87 +744,87 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
    if (s->blockRandomised) {
 
       while (True) {
-         /* try to finish existing run */
-         while (True) {
-            if (s->strm->avail_out == 0) return;
-            if (s->state_out_len == 0) break;
-            *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
-            BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
-            s->state_out_len--;
-            s->strm->next_out++;
-            s->strm->avail_out--;
-            s->strm->total_out_lo32++;
-            if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
-         }
-
-         /* can a new run be started? */
-         if (s->nblock_used == s->save_nblock+1) return;
-
-
-         s->state_out_len = 1;
-         s->state_out_ch = s->k0;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 2;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 3;
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
-         k1 ^= BZ_RAND_MASK; s->nblock_used++;
-         s->state_out_len = ((Int32)k1) + 4;
-         BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
-         s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
+	 /* try to finish existing run */
+	 while (True) {
+	    if (s->strm->avail_out == 0) return;
+	    if (s->state_out_len == 0) break;
+	    *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
+	    BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
+	    s->state_out_len--;
+	    s->strm->next_out++;
+	    s->strm->avail_out--;
+	    s->strm->total_out_lo32++;
+	    if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
+	 }
+
+	 /* can a new run be started? */
+	 if (s->nblock_used == s->save_nblock+1) return;
+
+
+	 s->state_out_len = 1;
+	 s->state_out_ch = s->k0;
+	 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 2;
+	 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 3;
+	 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+	 k1 ^= BZ_RAND_MASK; s->nblock_used++;
+	 s->state_out_len = ((Int32)k1) + 4;
+	 BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
+	 s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
       }
 
    } else {
 
       while (True) {
-         /* try to finish existing run */
-         while (True) {
-            if (s->strm->avail_out == 0) return;
-            if (s->state_out_len == 0) break;
-            *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
-            BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
-            s->state_out_len--;
-            s->strm->next_out++;
-            s->strm->avail_out--;
-            s->strm->total_out_lo32++;
-            if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
-         }
-
-         /* can a new run be started? */
-         if (s->nblock_used == s->save_nblock+1) return;
-
-         s->state_out_len = 1;
-         s->state_out_ch = s->k0;
-         BZ_GET_SMALL(k1); s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 2;
-         BZ_GET_SMALL(k1); s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         s->state_out_len = 3;
-         BZ_GET_SMALL(k1); s->nblock_used++;
-         if (s->nblock_used == s->save_nblock+1) continue;
-         if (k1 != s->k0) { s->k0 = k1; continue; };
-
-         BZ_GET_SMALL(k1); s->nblock_used++;
-         s->state_out_len = ((Int32)k1) + 4;
-         BZ_GET_SMALL(s->k0); s->nblock_used++;
+	 /* try to finish existing run */
+	 while (True) {
+	    if (s->strm->avail_out == 0) return;
+	    if (s->state_out_len == 0) break;
+	    *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
+	    BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
+	    s->state_out_len--;
+	    s->strm->next_out++;
+	    s->strm->avail_out--;
+	    s->strm->total_out_lo32++;
+	    if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
+	 }
+
+	 /* can a new run be started? */
+	 if (s->nblock_used == s->save_nblock+1) return;
+
+	 s->state_out_len = 1;
+	 s->state_out_ch = s->k0;
+	 BZ_GET_SMALL(k1); s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 2;
+	 BZ_GET_SMALL(k1); s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 s->state_out_len = 3;
+	 BZ_GET_SMALL(k1); s->nblock_used++;
+	 if (s->nblock_used == s->save_nblock+1) continue;
+	 if (k1 != s->k0) { s->k0 = k1; continue; };
+
+	 BZ_GET_SMALL(k1); s->nblock_used++;
+	 s->state_out_len = ((Int32)k1) + 4;
+	 BZ_GET_SMALL(s->k0); s->nblock_used++;
       }
 
    }
@@ -844,37 +843,37 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
    while (True) {
       if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
       if (s->state == BZ_X_OUTPUT) {
-         if (s->smallDecompress)
-            unRLE_obuf_to_output_SMALL ( s ); else
-            unRLE_obuf_to_output_FAST  ( s );
-         if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
-            BZ_FINALISE_CRC ( s->calculatedBlockCRC );
-            if (s->verbosity >= 3)
-               VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
-                          s->calculatedBlockCRC );
-            if (s->verbosity >= 2) VPrintf0 ( "]" );
-            if (s->calculatedBlockCRC != s->storedBlockCRC)
-               return BZ_DATA_ERROR;
-            s->calculatedCombinedCRC
-               = (s->calculatedCombinedCRC << 1) |
-                    (s->calculatedCombinedCRC >> 31);
-            s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
-            s->state = BZ_X_BLKHDR_1;
-         } else {
-            return BZ_OK;
-         }
+	 if (s->smallDecompress)
+	    unRLE_obuf_to_output_SMALL ( s ); else
+	    unRLE_obuf_to_output_FAST  ( s );
+	 if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
+	    BZ_FINALISE_CRC ( s->calculatedBlockCRC );
+	    if (s->verbosity >= 3)
+	       VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
+			  s->calculatedBlockCRC );
+	    if (s->verbosity >= 2) VPrintf0 ( "]" );
+	    if (s->calculatedBlockCRC != s->storedBlockCRC)
+	       return BZ_DATA_ERROR;
+	    s->calculatedCombinedCRC
+	       = (s->calculatedCombinedCRC << 1) |
+		    (s->calculatedCombinedCRC >> 31);
+	    s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
+	    s->state = BZ_X_BLKHDR_1;
+	 } else {
+	    return BZ_OK;
+	 }
       }
       if (s->state >= BZ_X_MAGIC_1) {
-         Int32 r = BZ2_decompress ( s );
-         if (r == BZ_STREAM_END) {
-            if (s->verbosity >= 3)
-               VPrintf2 ( "\n    combined CRCs: stored = 0x%x, computed = 0x%x",
-                          s->storedCombinedCRC, s->calculatedCombinedCRC );
-            if (s->calculatedCombinedCRC != s->storedCombinedCRC)
-               return BZ_DATA_ERROR;
-            return r;
-         }
-         if (s->state != BZ_X_OUTPUT) return r;
+	 Int32 r = BZ2_decompress ( s );
+	 if (r == BZ_STREAM_END) {
+	    if (s->verbosity >= 3)
+	       VPrintf2 ( "\n    combined CRCs: stored = 0x%x, computed = 0x%x",
+			  s->storedCombinedCRC, s->calculatedCombinedCRC );
+	    if (s->calculatedCombinedCRC != s->storedCombinedCRC)
+	       return BZ_DATA_ERROR;
+	    return r;
+	 }
+	 if (s->state != BZ_X_OUTPUT) return r;
       }
    }
 
@@ -940,11 +939,11 @@ static Bool myfeof ( FILE* f )
 
 /*---------------------------------------------------*/
 BZFILE* BZ_API(BZ2_bzWriteOpen)
-                    ( int*  bzerror,
-                      FILE* f,
-                      int   blockSize100k,
-                      int   verbosity,
-                      int   workFactor )
+		    ( int*  bzerror,
+		      FILE* f,
+		      int   blockSize100k,
+		      int   verbosity,
+		      int   workFactor )
 {
    Int32   ret;
    bzFile* bzf = NULL;
@@ -975,7 +974,7 @@ BZFILE* BZ_API(BZ2_bzWriteOpen)
 
    if (workFactor == 0) workFactor = 30;
    ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
-                              verbosity, workFactor );
+			      verbosity, workFactor );
    if (ret != BZ_OK)
       { BZ_SETERR(ret); free(bzf); return NULL; };
 
@@ -985,13 +984,12 @@ BZFILE* BZ_API(BZ2_bzWriteOpen)
 }
 
 
-
 /*---------------------------------------------------*/
 void BZ_API(BZ2_bzWrite)
-             ( int*    bzerror,
-               BZFILE* b,
-               void*   buf,
-               int     len )
+	     ( int*    bzerror,
+	       BZFILE* b,
+	       void*   buf,
+	       int     len )
 {
    Int32 n, n2, ret;
    bzFile* bzf = (bzFile*)b;
@@ -1015,43 +1013,43 @@ void BZ_API(BZ2_bzWrite)
       bzf->strm.next_out = bzf->buf;
       ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
       if (ret != BZ_RUN_OK)
-         { BZ_SETERR(ret); return; };
+	 { BZ_SETERR(ret); return; };
 
       if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
-         n = BZ_MAX_UNUSED - bzf->strm.avail_out;
-         n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
-                       n, bzf->handle );
-         if (n != n2 || ferror(bzf->handle))
-            { BZ_SETERR(BZ_IO_ERROR); return; };
+	 n = BZ_MAX_UNUSED - bzf->strm.avail_out;
+	 n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
+		       n, bzf->handle );
+	 if (n != n2 || ferror(bzf->handle))
+	    { BZ_SETERR(BZ_IO_ERROR); return; };
       }
 
       if (bzf->strm.avail_in == 0)
-         { BZ_SETERR(BZ_OK); return; };
+	 { BZ_SETERR(BZ_OK); return; };
    }
 }
 
 
 /*---------------------------------------------------*/
 void BZ_API(BZ2_bzWriteClose)
-                  ( int*          bzerror,
-                    BZFILE*       b,
-                    int           abandon,
-                    unsigned int* nbytes_in,
-                    unsigned int* nbytes_out )
+		  ( int*          bzerror,
+		    BZFILE*       b,
+		    int           abandon,
+		    unsigned int* nbytes_in,
+		    unsigned int* nbytes_out )
 {
    BZ2_bzWriteClose64 ( bzerror, b, abandon,
-                        nbytes_in, NULL, nbytes_out, NULL );
+			nbytes_in, NULL, nbytes_out, NULL );
 }
 
 
 void BZ_API(BZ2_bzWriteClose64)
-                  ( int*          bzerror,
-                    BZFILE*       b,
-                    int           abandon,
-                    unsigned int* nbytes_in_lo32,
-                    unsigned int* nbytes_in_hi32,
-                    unsigned int* nbytes_out_lo32,
-                    unsigned int* nbytes_out_hi32 )
+		  ( int*          bzerror,
+		    BZFILE*       b,
+		    int           abandon,
+		    unsigned int* nbytes_in_lo32,
+		    unsigned int* nbytes_in_hi32,
+		    unsigned int* nbytes_out_lo32,
+		    unsigned int* nbytes_out_hi32 )
 {
    Int32   n, n2, ret;
    bzFile* bzf = (bzFile*)b;
@@ -1070,28 +1068,28 @@ void BZ_API(BZ2_bzWriteClose64)
 
    if ((!abandon) && bzf->lastErr == BZ_OK) {
       while (True) {
-         bzf->strm.avail_out = BZ_MAX_UNUSED;
-         bzf->strm.next_out = bzf->buf;
-         ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
-         if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
-            { BZ_SETERR(ret); return; };
-
-         if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
-            n = BZ_MAX_UNUSED - bzf->strm.avail_out;
-            n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
-                          n, bzf->handle );
-            if (n != n2 || ferror(bzf->handle))
-               { BZ_SETERR(BZ_IO_ERROR); return; };
-         }
-
-         if (ret == BZ_STREAM_END) break;
+	 bzf->strm.avail_out = BZ_MAX_UNUSED;
+	 bzf->strm.next_out = bzf->buf;
+	 ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
+	 if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
+	    { BZ_SETERR(ret); return; };
+
+	 if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
+	    n = BZ_MAX_UNUSED - bzf->strm.avail_out;
+	    n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
+			  n, bzf->handle );
+	    if (n != n2 || ferror(bzf->handle))
+	       { BZ_SETERR(BZ_IO_ERROR); return; };
+	 }
+
+	 if (ret == BZ_STREAM_END) break;
       }
    }
 
    if ( !abandon && !ferror ( bzf->handle ) ) {
       fflush ( bzf->handle );
       if (ferror(bzf->handle))
-         { BZ_SETERR(BZ_IO_ERROR); return; };
+	 { BZ_SETERR(BZ_IO_ERROR); return; };
    }
 
    if (nbytes_in_lo32 != NULL)
@@ -1111,12 +1109,12 @@ void BZ_API(BZ2_bzWriteClose64)
 
 /*---------------------------------------------------*/
 BZFILE* BZ_API(BZ2_bzReadOpen)
-                   ( int*  bzerror,
-                     FILE* f,
-                     int   verbosity,
-                     int   small,
-                     void* unused,
-                     int   nUnused )
+		   ( int*  bzerror,
+		     FILE* f,
+		     int   verbosity,
+		     int   small,
+		     void* unused,
+		     int   nUnused )
 {
    bzFile* bzf = NULL;
    int     ret;
@@ -1185,10 +1183,10 @@ void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
 
 /*---------------------------------------------------*/
 int BZ_API(BZ2_bzRead)
-           ( int*    bzerror,
-             BZFILE* b,
-             void*   buf,
-             int     len )
+	   ( int*    bzerror,
+	     BZFILE* b,
+	     void*   buf,
+	     int     len )
 {
    Int32   n, ret;
    bzFile* bzf = (bzFile*)b;
@@ -1210,32 +1208,32 @@ int BZ_API(BZ2_bzRead)
    while (True) {
 
       if (ferror(bzf->handle))
-         { BZ_SETERR(BZ_IO_ERROR); return 0; };
+	 { BZ_SETERR(BZ_IO_ERROR); return 0; };
 
       if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
-         n = fread ( bzf->buf, sizeof(UChar),
-                     BZ_MAX_UNUSED, bzf->handle );
-         if (ferror(bzf->handle))
-            { BZ_SETERR(BZ_IO_ERROR); return 0; };
-         bzf->bufN = n;
-         bzf->strm.avail_in = bzf->bufN;
-         bzf->strm.next_in = bzf->buf;
+	 n = fread ( bzf->buf, sizeof(UChar),
+		     BZ_MAX_UNUSED, bzf->handle );
+	 if (ferror(bzf->handle))
+	    { BZ_SETERR(BZ_IO_ERROR); return 0; };
+	 bzf->bufN = n;
+	 bzf->strm.avail_in = bzf->bufN;
+	 bzf->strm.next_in = bzf->buf;
       }
 
       ret = BZ2_bzDecompress ( &(bzf->strm) );
 
       if (ret != BZ_OK && ret != BZ_STREAM_END)
-         { BZ_SETERR(ret); return 0; };
+	 { BZ_SETERR(ret); return 0; };
 
       if (ret == BZ_OK && myfeof(bzf->handle) &&
-          bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
-         { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
+	  bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
+	 { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
 
       if (ret == BZ_STREAM_END)
-         { BZ_SETERR(BZ_STREAM_END);
-           return len - bzf->strm.avail_out; };
+	 { BZ_SETERR(BZ_STREAM_END);
+	   return len - bzf->strm.avail_out; };
       if (bzf->strm.avail_out == 0)
-         { BZ_SETERR(BZ_OK); return len; };
+	 { BZ_SETERR(BZ_OK); return len; };
 
    }
 
@@ -1245,10 +1243,10 @@ int BZ_API(BZ2_bzRead)
 
 /*---------------------------------------------------*/
 void BZ_API(BZ2_bzReadGetUnused)
-                     ( int*    bzerror,
-                       BZFILE* b,
-                       void**  unused,
-                       int*    nUnused )
+		     ( int*    bzerror,
+		       BZFILE* b,
+		       void**  unused,
+		       int*    nUnused )
 {
    bzFile* bzf = (bzFile*)b;
    if (bzf == NULL)
@@ -1271,13 +1269,13 @@ void BZ_API(BZ2_bzReadGetUnused)
 #ifndef BZ_NO_COMPRESS
 /*---------------------------------------------------*/
 int BZ_API(BZ2_bzBuffToBuffCompress)
-                         ( char*         dest,
-                           unsigned int* destLen,
-                           char*         source,
-                           unsigned int  sourceLen,
-                           int           blockSize100k,
-                           int           verbosity,
-                           int           workFactor )
+			 ( char*         dest,
+			   unsigned int* destLen,
+			   char*         source,
+			   unsigned int  sourceLen,
+			   int           blockSize100k,
+			   int           verbosity,
+			   int           workFactor )
 {
    bz_stream strm;
    int ret;
@@ -1294,7 +1292,7 @@ int BZ_API(BZ2_bzBuffToBuffCompress)
    strm.bzfree = NULL;
    strm.opaque = NULL;
    ret = BZ2_bzCompressInit ( &strm, blockSize100k,
-                              verbosity, workFactor );
+			      verbosity, workFactor );
    if (ret != BZ_OK) return ret;
 
    strm.next_in = source;
@@ -1323,18 +1321,18 @@ int BZ_API(BZ2_bzBuffToBuffCompress)
 
 /*---------------------------------------------------*/
 int BZ_API(BZ2_bzBuffToBuffDecompress)
-                           ( char*         dest,
-                             unsigned int* destLen,
-                             char*         source,
-                             unsigned int  sourceLen,
-                             int           small,
-                             int           verbosity )
+			   ( char*         dest,
+			     unsigned int* destLen,
+			     char*         source,
+			     unsigned int  sourceLen,
+			     int           small,
+			     int           verbosity )
 {
    bz_stream strm;
    int ret;
 
    if (destLen == NULL || source == NULL)
-          return BZ_PARAM_ERROR;
+	  return BZ_PARAM_ERROR;
 
    strm.bzalloc = NULL;
    strm.bzfree = NULL;
@@ -1405,10 +1403,10 @@ const char * BZ_API(BZ2_bzlibVersion)(void)
 #endif
 static
 BZFILE * bzopen_or_bzdopen
-               ( const char *path,   /* no use when bzdopen */
-                 int fd,             /* no use when bzdopen */
-                 const char *mode,
-                 int open_mode)      /* bzopen: 0, bzdopen:1 */
+	       ( const char *path,   /* no use when bzdopen */
+		 int fd,             /* no use when bzdopen */
+		 const char *mode,
+		 int open_mode)      /* bzopen: 0, bzdopen:1 */
 {
    int    bzerr;
    char   unused[BZ_MAX_UNUSED];
@@ -1426,15 +1424,15 @@ BZFILE * bzopen_or_bzdopen
    while (*mode) {
       switch (*mode) {
       case 'r':
-         writing = 0; break;
+	 writing = 0; break;
       case 'w':
-         writing = 1; break;
+	 writing = 1; break;
       case 's':
-         smallMode = 1; break;
+	 smallMode = 1; break;
       default:
-         if (isdigit((int)(*mode))) {
-            blockSize100k = *mode-BZ_HDR_0;
-         }
+	 if (isdigit((int)(*mode))) {
+	    blockSize100k = *mode-BZ_HDR_0;
+	 }
       }
       mode++;
    }
@@ -1443,10 +1441,10 @@ BZFILE * bzopen_or_bzdopen
 
    if (open_mode==0) {
       if (path==NULL || strcmp(path,"")==0) {
-        fp = (writing ? stdout : stdin);
-        SET_BINARY_MODE(fp);
+	fp = (writing ? stdout : stdin);
+	SET_BINARY_MODE(fp);
       } else {
-        fp = fopen(path,mode2);
+	fp = fopen(path,mode2);
       }
    } else {
 #ifdef BZ_STRICT_ANSI
@@ -1462,10 +1460,10 @@ BZFILE * bzopen_or_bzdopen
       if (blockSize100k < 1) blockSize100k = 1;
       if (blockSize100k > 9) blockSize100k = 9;
       bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
-                             verbosity,workFactor);
+			     verbosity,workFactor);
    } else {
       bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
-                            unused,nUnused);
+			    unused,nUnused);
    }
    if (bzfp == NULL) {
       if (fp != stdin && fp != stdout) fclose(fp);
@@ -1482,8 +1480,8 @@ BZFILE * bzopen_or_bzdopen
       case path="" or NULL => use stdin or stdout.
 --*/
 BZFILE * BZ_API(BZ2_bzopen)
-               ( const char *path,
-                 const char *mode )
+	       ( const char *path,
+		 const char *mode )
 {
    return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
 }
@@ -1491,8 +1489,8 @@ BZFILE * BZ_API(BZ2_bzopen)
 
 /*---------------------------------------------------*/
 BZFILE * BZ_API(BZ2_bzdopen)
-               ( int fd,
-                 const char *mode )
+	       ( int fd,
+		 const char *mode )
 {
    return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
 }
@@ -1544,7 +1542,7 @@ void BZ_API(BZ2_bzclose) (BZFILE* b)
    if(((bzFile*)b)->writing){
       BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
       if(bzerr != BZ_OK){
-         BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
+	 BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
       }
    }else{
       BZ2_bzReadClose(&bzerr,b);
diff --git a/lib_generic/bzlib_decompress.c b/lib_generic/bzlib_decompress.c
index 70387cdb91d..a4a16879e7d 100644
--- a/lib_generic/bzlib_decompress.c
+++ b/lib_generic/bzlib_decompress.c
@@ -72,8 +72,8 @@ void makeMaps_d ( DState* s )
    s->nInUse = 0;
    for (i = 0; i < 256; i++)
       if (s->inUse[i]) {
-         s->seqToUnseq[s->nInUse] = i;
-         s->nInUse++;
+	 s->seqToUnseq[s->nInUse] = i;
+	 s->nInUse++;
       }
 }
 
@@ -86,24 +86,24 @@ void makeMaps_d ( DState* s )
    case lll: s->state = lll;                      \
    while (True) {                                 \
       if (s->bsLive >= nnn) {                     \
-         UInt32 v;                                \
-         v = (s->bsBuff >>                        \
-             (s->bsLive-nnn)) & ((1 << nnn)-1);   \
-         s->bsLive -= nnn;                        \
-         vvv = v;                                 \
-         break;                                   \
+	 UInt32 v;                                \
+	 v = (s->bsBuff >>                        \
+	     (s->bsLive-nnn)) & ((1 << nnn)-1);   \
+	 s->bsLive -= nnn;                        \
+	 vvv = v;                                 \
+	 break;                                   \
       }                                           \
       if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
       s->bsBuff                                   \
-         = (s->bsBuff << 8) |                     \
-           ((UInt32)                              \
-              (*((UChar*)(s->strm->next_in))));   \
+	 = (s->bsBuff << 8) |                     \
+	   ((UInt32)                              \
+	      (*((UChar*)(s->strm->next_in))));   \
       s->bsLive += 8;                             \
       s->strm->next_in++;                         \
       s->strm->avail_in--;                        \
       s->strm->total_in_lo32++;                   \
       if (s->strm->total_in_lo32 == 0)            \
-         s->strm->total_in_hi32++;                \
+	 s->strm->total_in_hi32++;                \
    }
 
 #define GET_UCHAR(lll,uuu)                        \
@@ -118,7 +118,7 @@ void makeMaps_d ( DState* s )
    if (groupPos == 0) {                           \
       groupNo++;                                  \
       if (groupNo >= nSelectors)                  \
-         RETURN(BZ_DATA_ERROR);                   \
+	 RETURN(BZ_DATA_ERROR);                   \
       groupPos = BZ_G_SIZE;                       \
       gSel = s->selector[groupNo];                \
       gMinlen = s->minLens[gSel];                 \
@@ -131,7 +131,7 @@ void makeMaps_d ( DState* s )
    GET_BITS(label1, zvec, zn);                    \
    while (1) {                                    \
       if (zn > 20 /* the longest code */)         \
-         RETURN(BZ_DATA_ERROR);                   \
+	 RETURN(BZ_DATA_ERROR);                   \
       if (zvec <= gLimit[zn]) break;              \
       zn++;                                       \
       GET_BIT(label2, zj);                        \
@@ -247,18 +247,18 @@ Int32 BZ2_decompress ( DState* s )
 
       GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
       if (s->blockSize100k < (BZ_HDR_0 + 1) ||
-          s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
+	  s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
       s->blockSize100k -= BZ_HDR_0;
 
       if (s->smallDecompress) {
-         s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
-         s->ll4  = BZALLOC(
-                      ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
-                   );
-         if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
+	 s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
+	 s->ll4  = BZALLOC(
+		      ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
+		   );
+	 if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
       } else {
-         s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
-         if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
+	 s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
+	 if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
       }
 
       GET_UCHAR(BZ_X_BLKHDR_1, uc);
@@ -278,7 +278,7 @@ Int32 BZ2_decompress ( DState* s )
 
       s->currBlockNo++;
       if (s->verbosity >= 2)
-         VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
+	 VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
 
       s->storedBlockCRC = 0;
       GET_UCHAR(BZ_X_BCRC_1, uc);
@@ -301,26 +301,26 @@ Int32 BZ2_decompress ( DState* s )
       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
 
       if (s->origPtr < 0)
-         RETURN(BZ_DATA_ERROR);
+	 RETURN(BZ_DATA_ERROR);
       if (s->origPtr > 10 + 100000*s->blockSize100k)
-         RETURN(BZ_DATA_ERROR);
+	 RETURN(BZ_DATA_ERROR);
 
       /*--- Receive the mapping table ---*/
       for (i = 0; i < 16; i++) {
-         GET_BIT(BZ_X_MAPPING_1, uc);
-         if (uc == 1)
-            s->inUse16[i] = True; else
-            s->inUse16[i] = False;
+	 GET_BIT(BZ_X_MAPPING_1, uc);
+	 if (uc == 1)
+	    s->inUse16[i] = True; else
+	    s->inUse16[i] = False;
       }
 
       for (i = 0; i < 256; i++) s->inUse[i] = False;
 
       for (i = 0; i < 16; i++)
-         if (s->inUse16[i])
-            for (j = 0; j < 16; j++) {
-               GET_BIT(BZ_X_MAPPING_2, uc);
-               if (uc == 1) s->inUse[i * 16 + j] = True;
-            }
+	 if (s->inUse16[i])
+	    for (j = 0; j < 16; j++) {
+	       GET_BIT(BZ_X_MAPPING_2, uc);
+	       if (uc == 1) s->inUse[i * 16 + j] = True;
+	    }
       makeMaps_d ( s );
       if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
       alphaSize = s->nInUse+2;
@@ -331,61 +331,61 @@ Int32 BZ2_decompress ( DState* s )
       GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
       if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
       for (i = 0; i < nSelectors; i++) {
-         j = 0;
-         while (True) {
-            GET_BIT(BZ_X_SELECTOR_3, uc);
-            if (uc == 0) break;
-            j++;
-            if (j >= nGroups) RETURN(BZ_DATA_ERROR);
-         }
-         s->selectorMtf[i] = j;
+	 j = 0;
+	 while (True) {
+	    GET_BIT(BZ_X_SELECTOR_3, uc);
+	    if (uc == 0) break;
+	    j++;
+	    if (j >= nGroups) RETURN(BZ_DATA_ERROR);
+	 }
+	 s->selectorMtf[i] = j;
       }
 
       /*--- Undo the MTF values for the selectors. ---*/
       {
-         UChar pos[BZ_N_GROUPS], tmp, v;
-         for (v = 0; v < nGroups; v++) pos[v] = v;
-
-         for (i = 0; i < nSelectors; i++) {
-            v = s->selectorMtf[i];
-            tmp = pos[v];
-            while (v > 0) { pos[v] = pos[v-1]; v--; }
-            pos[0] = tmp;
-            s->selector[i] = tmp;
-         }
+	 UChar pos[BZ_N_GROUPS], tmp, v;
+	 for (v = 0; v < nGroups; v++) pos[v] = v;
+
+	 for (i = 0; i < nSelectors; i++) {
+	    v = s->selectorMtf[i];
+	    tmp = pos[v];
+	    while (v > 0) { pos[v] = pos[v-1]; v--; }
+	    pos[0] = tmp;
+	    s->selector[i] = tmp;
+	 }
       }
 
       /*--- Now the coding tables ---*/
       for (t = 0; t < nGroups; t++) {
-         GET_BITS(BZ_X_CODING_1, curr, 5);
-         for (i = 0; i < alphaSize; i++) {
-            while (True) {
-               if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
-               GET_BIT(BZ_X_CODING_2, uc);
-               if (uc == 0) break;
-               GET_BIT(BZ_X_CODING_3, uc);
-               if (uc == 0) curr++; else curr--;
-            }
-            s->len[t][i] = curr;
-         }
+	 GET_BITS(BZ_X_CODING_1, curr, 5);
+	 for (i = 0; i < alphaSize; i++) {
+	    while (True) {
+	       if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
+	       GET_BIT(BZ_X_CODING_2, uc);
+	       if (uc == 0) break;
+	       GET_BIT(BZ_X_CODING_3, uc);
+	       if (uc == 0) curr++; else curr--;
+	    }
+	    s->len[t][i] = curr;
+	 }
       }
 
       /*--- Create the Huffman decoding tables ---*/
       for (t = 0; t < nGroups; t++) {
-         minLen = 32;
-         maxLen = 0;
-         for (i = 0; i < alphaSize; i++) {
-            if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
-            if (s->len[t][i] < minLen) minLen = s->len[t][i];
-         }
-         BZ2_hbCreateDecodeTables (
-            &(s->limit[t][0]),
-            &(s->base[t][0]),
-            &(s->perm[t][0]),
-            &(s->len[t][0]),
-            minLen, maxLen, alphaSize
-         );
-         s->minLens[t] = minLen;
+	 minLen = 32;
+	 maxLen = 0;
+	 for (i = 0; i < alphaSize; i++) {
+	    if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
+	    if (s->len[t][i] < minLen) minLen = s->len[t][i];
+	 }
+	 BZ2_hbCreateDecodeTables (
+	    &(s->limit[t][0]),
+	    &(s->base[t][0]),
+	    &(s->perm[t][0]),
+	    &(s->len[t][0]),
+	    minLen, maxLen, alphaSize
+	 );
+	 s->minLens[t] = minLen;
       }
 
       /*--- Now the MTF values ---*/
@@ -399,15 +399,15 @@ Int32 BZ2_decompress ( DState* s )
 
       /*-- MTF init --*/
       {
-         Int32 ii, jj, kk;
-         kk = MTFA_SIZE-1;
-         for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
-            for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
-               s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
-               kk--;
-            }
-            s->mtfbase[ii] = kk + 1;
-         }
+	 Int32 ii, jj, kk;
+	 kk = MTFA_SIZE-1;
+	 for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
+	    for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
+	       s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
+	       kk--;
+	    }
+	    s->mtfbase[ii] = kk + 1;
+	 }
       }
       /*-- end MTF init --*/
 
@@ -416,115 +416,115 @@ Int32 BZ2_decompress ( DState* s )
 
       while (True) {
 
-         if (nextSym == EOB) break;
-
-         if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
-
-            es = -1;
-            N = 1;
-            do {
-               if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
-               if (nextSym == BZ_RUNB) es = es + (1+1) * N;
-               N = N * 2;
-               GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
-            }
-               while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
-
-            es++;
-            uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
-            s->unzftab[uc] += es;
-
-            if (s->smallDecompress)
-               while (es > 0) {
-                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
-                  s->ll16[nblock] = (UInt16)uc;
-                  nblock++;
-                  es--;
-               }
-            else
-               while (es > 0) {
-                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
-                  s->tt[nblock] = (UInt32)uc;
-                  nblock++;
-                  es--;
-               };
-
-            continue;
-
-         } else {
-
-            if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
-
-            /*-- uc = MTF ( nextSym-1 ) --*/
-            {
-               Int32 ii, jj, kk, pp, lno, off;
-               UInt32 nn;
-               nn = (UInt32)(nextSym - 1);
-
-               if (nn < MTFL_SIZE) {
-                  /* avoid general-case expense */
-                  pp = s->mtfbase[0];
-                  uc = s->mtfa[pp+nn];
-                  while (nn > 3) {
-                     Int32 z = pp+nn;
-                     s->mtfa[(z)  ] = s->mtfa[(z)-1];
-                     s->mtfa[(z)-1] = s->mtfa[(z)-2];
-                     s->mtfa[(z)-2] = s->mtfa[(z)-3];
-                     s->mtfa[(z)-3] = s->mtfa[(z)-4];
-                     nn -= 4;
-                  }
-                  while (nn > 0) {
-                     s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
-                  };
-                  s->mtfa[pp] = uc;
-               } else {
-                  /* general case */
-                  lno = nn / MTFL_SIZE;
-                  off = nn % MTFL_SIZE;
-                  pp = s->mtfbase[lno] + off;
-                  uc = s->mtfa[pp];
-                  while (pp > s->mtfbase[lno]) {
-                     s->mtfa[pp] = s->mtfa[pp-1]; pp--;
-                  };
-                  s->mtfbase[lno]++;
-                  while (lno > 0) {
-                     s->mtfbase[lno]--;
-                     s->mtfa[s->mtfbase[lno]]
-                        = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
-                     lno--;
-                  }
-                  s->mtfbase[0]--;
-                  s->mtfa[s->mtfbase[0]] = uc;
-                  if (s->mtfbase[0] == 0) {
-                     kk = MTFA_SIZE-1;
-                     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
-                        for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
-                           s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
-                           kk--;
-                        }
-                        s->mtfbase[ii] = kk + 1;
-                     }
-                  }
-               }
-            }
-            /*-- end uc = MTF ( nextSym-1 ) --*/
-
-            s->unzftab[s->seqToUnseq[uc]]++;
-            if (s->smallDecompress)
-               s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
-               s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
-            nblock++;
-
-            GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
-            continue;
-         }
+	 if (nextSym == EOB) break;
+
+	 if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
+
+	    es = -1;
+	    N = 1;
+	    do {
+	       if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
+	       if (nextSym == BZ_RUNB) es = es + (1+1) * N;
+	       N = N * 2;
+	       GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
+	    }
+	       while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
+
+	    es++;
+	    uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
+	    s->unzftab[uc] += es;
+
+	    if (s->smallDecompress)
+	       while (es > 0) {
+		  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
+		  s->ll16[nblock] = (UInt16)uc;
+		  nblock++;
+		  es--;
+	       }
+	    else
+	       while (es > 0) {
+		  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
+		  s->tt[nblock] = (UInt32)uc;
+		  nblock++;
+		  es--;
+	       };
+
+	    continue;
+
+	 } else {
+
+	    if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
+
+	    /*-- uc = MTF ( nextSym-1 ) --*/
+	    {
+	       Int32 ii, jj, kk, pp, lno, off;
+	       UInt32 nn;
+	       nn = (UInt32)(nextSym - 1);
+
+	       if (nn < MTFL_SIZE) {
+		  /* avoid general-case expense */
+		  pp = s->mtfbase[0];
+		  uc = s->mtfa[pp+nn];
+		  while (nn > 3) {
+		     Int32 z = pp+nn;
+		     s->mtfa[(z)  ] = s->mtfa[(z)-1];
+		     s->mtfa[(z)-1] = s->mtfa[(z)-2];
+		     s->mtfa[(z)-2] = s->mtfa[(z)-3];
+		     s->mtfa[(z)-3] = s->mtfa[(z)-4];
+		     nn -= 4;
+		  }
+		  while (nn > 0) {
+		     s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
+		  };
+		  s->mtfa[pp] = uc;
+	       } else {
+		  /* general case */
+		  lno = nn / MTFL_SIZE;
+		  off = nn % MTFL_SIZE;
+		  pp = s->mtfbase[lno] + off;
+		  uc = s->mtfa[pp];
+		  while (pp > s->mtfbase[lno]) {
+		     s->mtfa[pp] = s->mtfa[pp-1]; pp--;
+		  };
+		  s->mtfbase[lno]++;
+		  while (lno > 0) {
+		     s->mtfbase[lno]--;
+		     s->mtfa[s->mtfbase[lno]]
+			= s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
+		     lno--;
+		  }
+		  s->mtfbase[0]--;
+		  s->mtfa[s->mtfbase[0]] = uc;
+		  if (s->mtfbase[0] == 0) {
+		     kk = MTFA_SIZE-1;
+		     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
+			for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
+			   s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
+			   kk--;
+			}
+			s->mtfbase[ii] = kk + 1;
+		     }
+		  }
+	       }
+	    }
+	    /*-- end uc = MTF ( nextSym-1 ) --*/
+
+	    s->unzftab[s->seqToUnseq[uc]]++;
+	    if (s->smallDecompress)
+	       s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
+	       s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
+	    nblock++;
+
+	    GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
+	    continue;
+	 }
       }
 
       /* Now we know what nblock is, we can do a better sanity
-         check on s->origPtr.
+	 check on s->origPtr.
       */
       if (s->origPtr < 0 || s->origPtr >= nblock)
-         RETURN(BZ_DATA_ERROR);
+	 RETURN(BZ_DATA_ERROR);
 
       s->state_out_len = 0;
       s->state_out_ch  = 0;
@@ -539,62 +539,61 @@ Int32 BZ2_decompress ( DState* s )
 
       if (s->smallDecompress) {
 
-         /*-- Make a copy of cftab, used in generation of T --*/
-         for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
-
-         /*-- compute the T vector --*/
-         for (i = 0; i < nblock; i++) {
-            uc = (UChar)(s->ll16[i]);
-            SET_LL(i, s->cftabCopy[uc]);
-            s->cftabCopy[uc]++;
-         }
-
-         /*-- Compute T^(-1) by pointer reversal on T --*/
-         i = s->origPtr;
-         j = GET_LL(i);
-         do {
-            Int32 tmp = GET_LL(j);
-            SET_LL(j, i);
-            i = j;
-            j = tmp;
-         }
-            while (i != s->origPtr);
-
-         s->tPos = s->origPtr;
-         s->nblock_used = 0;
-         if (s->blockRandomised) {
-            BZ_RAND_INIT_MASK;
-            BZ_GET_SMALL(s->k0); s->nblock_used++;
-            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
-         } else {
-            BZ_GET_SMALL(s->k0); s->nblock_used++;
-         }
+	 /*-- Make a copy of cftab, used in generation of T --*/
+	 for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
+
+	 /*-- compute the T vector --*/
+	 for (i = 0; i < nblock; i++) {
+	    uc = (UChar)(s->ll16[i]);
+	    SET_LL(i, s->cftabCopy[uc]);
+	    s->cftabCopy[uc]++;
+	 }
+
+	 /*-- Compute T^(-1) by pointer reversal on T --*/
+	 i = s->origPtr;
+	 j = GET_LL(i);
+	 do {
+	    Int32 tmp = GET_LL(j);
+	    SET_LL(j, i);
+	    i = j;
+	    j = tmp;
+	 }
+	    while (i != s->origPtr);
+
+	 s->tPos = s->origPtr;
+	 s->nblock_used = 0;
+	 if (s->blockRandomised) {
+	    BZ_RAND_INIT_MASK;
+	    BZ_GET_SMALL(s->k0); s->nblock_used++;
+	    BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
+	 } else {
+	    BZ_GET_SMALL(s->k0); s->nblock_used++;
+	 }
 
       } else {
 
-         /*-- compute the T^(-1) vector --*/
-         for (i = 0; i < nblock; i++) {
-            uc = (UChar)(s->tt[i] & 0xff);
-            s->tt[s->cftab[uc]] |= (i << 8);
-            s->cftab[uc]++;
-         }
-
-         s->tPos = s->tt[s->origPtr] >> 8;
-         s->nblock_used = 0;
-         if (s->blockRandomised) {
-            BZ_RAND_INIT_MASK;
-            BZ_GET_FAST(s->k0); s->nblock_used++;
-            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
-         } else {
-            BZ_GET_FAST(s->k0); s->nblock_used++;
-         }
+	 /*-- compute the T^(-1) vector --*/
+	 for (i = 0; i < nblock; i++) {
+	    uc = (UChar)(s->tt[i] & 0xff);
+	    s->tt[s->cftab[uc]] |= (i << 8);
+	    s->cftab[uc]++;
+	 }
+
+	 s->tPos = s->tt[s->origPtr] >> 8;
+	 s->nblock_used = 0;
+	 if (s->blockRandomised) {
+	    BZ_RAND_INIT_MASK;
+	    BZ_GET_FAST(s->k0); s->nblock_used++;
+	    BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
+	 } else {
+	    BZ_GET_FAST(s->k0); s->nblock_used++;
+	 }
 
       }
 
       RETURN(BZ_OK);
 
 
-
     endhdr_2:
 
       GET_UCHAR(BZ_X_ENDHDR_2, uc);
diff --git a/lib_generic/bzlib_huffman.c b/lib_generic/bzlib_huffman.c
index 6cf336e3607..effae98a733 100644
--- a/lib_generic/bzlib_huffman.c
+++ b/lib_generic/bzlib_huffman.c
@@ -91,8 +91,8 @@
       yy = zz << 1;                                   \
       if (yy > nHeap) break;                          \
       if (yy < nHeap &&                               \
-          weight[heap[yy+1]] < weight[heap[yy]])      \
-         yy++;                                        \
+	  weight[heap[yy+1]] < weight[heap[yy]])      \
+	 yy++;                                        \
       if (weight[tmp] < weight[heap[yy]]) break;      \
       heap[zz] = heap[yy];                            \
       zz = yy;                                        \
@@ -103,9 +103,9 @@
 
 /*---------------------------------------------------*/
 void BZ2_hbMakeCodeLengths ( UChar *len,
-                             Int32 *freq,
-                             Int32 alphaSize,
-                             Int32 maxLen )
+			     Int32 *freq,
+			     Int32 alphaSize,
+			     Int32 maxLen )
 {
    /*--
       Nodes and heap entries run from 1.  Entry 0
@@ -131,43 +131,43 @@ void BZ2_hbMakeCodeLengths ( UChar *len,
       parent[0] = -2;
 
       for (i = 1; i <= alphaSize; i++) {
-         parent[i] = -1;
-         nHeap++;
-         heap[nHeap] = i;
-         UPHEAP(nHeap);
+	 parent[i] = -1;
+	 nHeap++;
+	 heap[nHeap] = i;
+	 UPHEAP(nHeap);
       }
 
       AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
 
       while (nHeap > 1) {
-         n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
-         n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
-         nNodes++;
-         parent[n1] = parent[n2] = nNodes;
-         weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
-         parent[nNodes] = -1;
-         nHeap++;
-         heap[nHeap] = nNodes;
-         UPHEAP(nHeap);
+	 n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
+	 n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
+	 nNodes++;
+	 parent[n1] = parent[n2] = nNodes;
+	 weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
+	 parent[nNodes] = -1;
+	 nHeap++;
+	 heap[nHeap] = nNodes;
+	 UPHEAP(nHeap);
       }
 
       AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
 
       tooLong = False;
       for (i = 1; i <= alphaSize; i++) {
-         j = 0;
-         k = i;
-         while (parent[k] >= 0) { k = parent[k]; j++; }
-         len[i-1] = j;
-         if (j > maxLen) tooLong = True;
+	 j = 0;
+	 k = i;
+	 while (parent[k] >= 0) { k = parent[k]; j++; }
+	 len[i-1] = j;
+	 if (j > maxLen) tooLong = True;
       }
 
       if (! tooLong) break;
 
       for (i = 1; i < alphaSize; i++) {
-         j = weight[i] >> 8;
-         j = 1 + (j / 2);
-         weight[i] = j << 8;
+	 j = weight[i] >> 8;
+	 j = 1 + (j / 2);
+	 weight[i] = j << 8;
       }
    }
 }
@@ -175,17 +175,17 @@ void BZ2_hbMakeCodeLengths ( UChar *len,
 
 /*---------------------------------------------------*/
 void BZ2_hbAssignCodes ( Int32 *code,
-                         UChar *length,
-                         Int32 minLen,
-                         Int32 maxLen,
-                         Int32 alphaSize )
+			 UChar *length,
+			 Int32 minLen,
+			 Int32 maxLen,
+			 Int32 alphaSize )
 {
    Int32 n, vec, i;
 
    vec = 0;
    for (n = minLen; n <= maxLen; n++) {
       for (i = 0; i < alphaSize; i++)
-         if (length[i] == n) { code[i] = vec; vec++; };
+	 if (length[i] == n) { code[i] = vec; vec++; };
       vec <<= 1;
    }
 }
@@ -193,19 +193,19 @@ void BZ2_hbAssignCodes ( Int32 *code,
 
 /*---------------------------------------------------*/
 void BZ2_hbCreateDecodeTables ( Int32 *limit,
-                                Int32 *base,
-                                Int32 *perm,
-                                UChar *length,
-                                Int32 minLen,
-                                Int32 maxLen,
-                                Int32 alphaSize )
+				Int32 *base,
+				Int32 *perm,
+				UChar *length,
+				Int32 minLen,
+				Int32 maxLen,
+				Int32 alphaSize )
 {
    Int32 pp, i, j, vec;
 
    pp = 0;
    for (i = minLen; i <= maxLen; i++)
       for (j = 0; j < alphaSize; j++)
-         if (length[j] == i) { perm[pp] = j; pp++; };
+	 if (length[j] == i) { perm[pp] = j; pp++; };
 
    for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
    for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
diff --git a/lib_generic/bzlib_private.h b/lib_generic/bzlib_private.h
index 9c26774ae59..87d8f945258 100644
--- a/lib_generic/bzlib_private.h
+++ b/lib_generic/bzlib_private.h
@@ -77,7 +77,6 @@
 #endif
 
 
-
 /*-- General stuff. --*/
 
 #define BZ_VERSION  "1.0.2, 30-Dec-2001"
@@ -105,7 +104,7 @@ extern void BZ2_bz__AssertH__fail ( int errcode );
 #define AssertD(cond,msg) \
    { if (!(cond)) {       \
       fprintf ( stderr,   \
-        "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
+	"\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
       exit(1); \
    }}
 #else
@@ -163,7 +162,6 @@ extern void bz_internal_error ( int errcode );
 #define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
 
 
-
 /*-- Stuff for randomising repetitive blocks. --*/
 
 extern Int32 BZ2_rNums[512];
@@ -187,7 +185,6 @@ extern Int32 BZ2_rNums[512];
    s->rNToGo--;
 
 
-
 /*-- Stuff for doing CRCs. --*/
 
 extern UInt32 BZ2_crc32Table[256];
@@ -205,12 +202,11 @@ extern UInt32 BZ2_crc32Table[256];
 #define BZ_UPDATE_CRC(crcVar,cha)              \
 {                                              \
    crcVar = (crcVar << 8) ^                    \
-            BZ2_crc32Table[(crcVar >> 24) ^    \
-                           ((UChar)cha)];      \
+	    BZ2_crc32Table[(crcVar >> 24) ^    \
+			   ((UChar)cha)];      \
 }
 
 
-
 /*-- States and modes for compression. --*/
 
 #define BZ_M_IDLE      1
@@ -227,8 +223,6 @@ extern UInt32 BZ2_crc32Table[256];
 #define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
 
 
-
-
 /*-- Structure holding all the compression-side stuff. --*/
 
 typedef
@@ -304,7 +298,6 @@ typedef
    EState;
 
 
-
 /*-- externs for compression. --*/
 
 extern void
@@ -323,7 +316,6 @@ extern void
 BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
 
 
-
 /*-- states for decompression. --*/
 
 #define BZ_X_IDLE        1
@@ -372,14 +364,12 @@ BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
 #define BZ_X_CCRC_4      50
 
 
-
 /*-- Constants for the fast MTF decoder. --*/
 
 #define MTFA_SIZE 4096
 #define MTFL_SIZE 16
 
 
-
 /*-- Structure holding all the decompression-side stuff. --*/
 
 typedef
@@ -476,7 +466,6 @@ typedef
    DState;
 
 
-
 /*-- Macros for decompression. --*/
 
 #define BZ_GET_FAST(cccc)                     \
@@ -491,8 +480,8 @@ typedef
 
 #define SET_LL4(i,n)                                          \
    { if (((i) & 0x1) == 0)                                    \
-        s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else    \
-        s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4);  \
+	s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else    \
+	s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4);  \
    }
 
 #define GET_LL4(i)                             \
@@ -521,7 +510,7 @@ BZ2_decompress ( DState* );
 
 extern void
 BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
-                           Int32,  Int32, Int32 );
+			   Int32,  Int32, Int32 );
 
 
 #endif