Adding upstream version 1.0~rc3.upstream/1.0_rc3

Signed-off-by: Daniel Baumann <mail@daniel-baumann.ch>

13 files changed, 264 insertions, 263 deletions

diff --git a/ChangeLog b/ChangeLog
index cbbcdbd..a1bb0fd 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2010-03-13  Antonio Diaz Diaz  <ant_diaz@teleline.es>
+
+	* Version 1.0-rc3 released.
+	* decoder.h: Input_buffer integrated in Range_decoder.
+
 2010-02-21  Antonio Diaz Diaz  <ant_diaz@teleline.es>
 
 	* Version 1.0-rc2 released.
@@ -8,7 +13,7 @@
 
 	* Version 1.0-rc1 released.
 	* Initial release.
-	* Translated to C from the C++ source for lzip 1.10-rc1
+	* Translated to C from the C++ source for lzip 1.10-rc1.
 
 
 Copyright (C) 2010 Antonio Diaz Diaz.
diff --git a/NEWS b/NEWS
index fd8c0ee..1ce6a12 100644
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,4 @@ Changes in version 1.0:
 
 Initial release.
 
-Translated to C from the C++ source for lzip 1.10-rc1
-
-Compiler warnings produced by over-optimization (-O3) have been fixed.
+Translated to C from the C++ source for lzip 1.10-rc3.
diff --git a/clzip.h b/clzip.h
index c523660..4629000 100644
--- a/clzip.h
+++ b/clzip.h
@@ -137,7 +137,7 @@ static inline void CRC32_init()
     {
     unsigned int c = n;
     for( int k = 0; k < 8; ++k )
-      { if( c & 1 ) c = 0xEDB88320 ^ ( c >> 1 ); else c >>= 1; }
+      { if( c & 1 ) c = 0xEDB88320U ^ ( c >> 1 ); else c >>= 1; }
     crc32[n] = c;
     }
   }
@@ -155,6 +155,7 @@ static inline void CRC32_update_buf( uint32_t * crc, const uint8_t * const buffe
 typedef uint8_t File_header[6];		// 0-3 magic bytes
 					//   4 version
 					//   5 coded_dict_size;
+enum { Fh_size = 6 };
 
 static inline void Fh_set_magic( File_header header )
   {
@@ -185,23 +186,23 @@ static inline int Fh_real_bits( const int value )
 
 static inline int Fh_get_dictionary_size( const File_header header )
   {
-  int size = ( 1 << ( header[5] & 0x1F ) );
-  if( size > min_dictionary_size && size <= max_dictionary_size )
-    size -= ( size / 16 ) * ( ( header[5] >> 5 ) & 0x07 );
-  return size;
+  int sz = ( 1 << ( header[5] & 0x1F ) );
+  if( sz > min_dictionary_size && sz <= max_dictionary_size )
+    sz -= ( sz / 16 ) * ( ( header[5] >> 5 ) & 0x07 );
+  return sz;
   }
 
-static inline bool Fh_set_dictionary_size( File_header header, const int size )
+static inline bool Fh_set_dictionary_size( File_header header, const int sz )
   {
-  if( size >= min_dictionary_size && size <= max_dictionary_size )
+  if( sz >= min_dictionary_size && sz <= max_dictionary_size )
     {
-    header[5] = Fh_real_bits( size - 1 );
-    if( size > min_dictionary_size )
+    header[5] = Fh_real_bits( sz - 1 );
+    if( sz > min_dictionary_size )
       {
       const int base_size = 1 << header[5];
       const int wedge = base_size / 16;
       for( int i = 7; i >= 1; --i )
-        if( base_size - ( i * wedge ) >= size )
+        if( base_size - ( i * wedge ) >= sz )
           { header[5] |= ( i << 5 ); break; }
       }
     return true;
@@ -215,8 +216,10 @@ typedef uint8_t File_trailer[20];
 			//  4-11 size of the uncompressed data
 			// 12-19 member size including header and trailer
 
-static inline int Ft_size( const int version )
-  { return sizeof (File_trailer) - ( ( version >= 1 ) ? 0 : 8 ); }
+enum { Ft_size = 20 };
+
+static inline int Ft_versioned_size( const int version )
+  { return ( ( version >= 1 ) ? 20 : 12 ); }
 
 static inline uint32_t Ft_get_data_crc( const File_trailer trailer )
   {
@@ -235,9 +238,9 @@ static inline long long Ft_get_data_size( const File_trailer trailer )
   return tmp;
   }
 
-static inline void Ft_set_data_size( File_trailer trailer, long long size )
+static inline void Ft_set_data_size( File_trailer trailer, long long sz )
   {
-  for( int i = 4; i <= 11; ++i ) { trailer[i] = (uint8_t)size; size >>= 8; }
+  for( int i = 4; i <= 11; ++i ) { trailer[i] = (uint8_t)sz; sz >>= 8; }
   }
 
 static inline long long Ft_get_member_size( const File_trailer trailer )
@@ -247,9 +250,9 @@ static inline long long Ft_get_member_size( const File_trailer trailer )
   return tmp;
   }
 
-static inline void Ft_set_member_size( File_trailer trailer, long long size )
+static inline void Ft_set_member_size( File_trailer trailer, long long sz )
   {
-  for( int i = 12; i <= 19; ++i ) { trailer[i] = (uint8_t)size; size >>= 8; }
+  for( int i = 12; i <= 19; ++i ) { trailer[i] = (uint8_t)sz; sz >>= 8; }
   }
 
 
diff --git a/configure b/configure
index 5ebfe51..4a77e1c 100755
--- a/configure
+++ b/configure
@@ -5,12 +5,12 @@
 # This configure script is free software: you have unlimited permission
 # to copy, distribute and modify it.
 #
-# Date of this version: 2010-02-21
+# Date of this version: 2010-03-13
 
 args=
 no_create=
 pkgname=clzip
-pkgversion=1.0-rc2
+pkgversion=1.0-rc3
 progname=clzip
 srctrigger=clzip.h
 
diff --git a/decoder.c b/decoder.c
index 20799a3..0d00219 100644
--- a/decoder.c
+++ b/decoder.c
@@ -28,15 +28,18 @@
 #include "decoder.h"
 
 
-bool Ib_read_block( struct Input_buffer * const ibuf )
+bool Rd_read_block( struct Range_decoder * const rdec )
   {
-  if( ibuf->at_stream_end ) return false;
-  ibuf->stream_pos = readblock( ibuf->infd_, ibuf->buffer, Ib_buffer_size );
-  if( ibuf->stream_pos != Ib_buffer_size && errno )
-    { show_error( "read error", errno, false ); cleanup_and_fail( 1 ); }
-  ibuf->pos = 0;
-  ibuf->at_stream_end = ( ibuf->stream_pos < Ib_buffer_size );
-  return !Ib_finished( ibuf );
+  if( !rdec->at_stream_end )
+    {
+    rdec->stream_pos = readblock( rdec->infd_, rdec->buffer, Rd_buffer_size );
+    if( rdec->stream_pos != Rd_buffer_size && errno )
+      { show_error( "read error", errno, false ); cleanup_and_fail( 1 ); }
+    rdec->at_stream_end = ( rdec->stream_pos < Rd_buffer_size );
+    rdec->partial_member_pos += rdec->pos;
+    rdec->pos = 0;
+    }
+  return !Rd_finished( rdec );
   }
 
 
@@ -59,13 +62,15 @@ void LZd_flush_data( struct LZ_decoder * const decoder )
 bool LZd_verify_trailer( struct LZ_decoder * const decoder,
                          struct Pretty_print * const pp )
   {
-  bool error = false;
   File_trailer trailer;
-  const int trailer_size = Ft_size( decoder->format_version );
+  const int trailer_size = Ft_versioned_size( decoder->format_version );
+  const long long member_size = LZd_member_position( decoder ) + trailer_size;
+  bool error = false;
+
   for( int i = 0; i < trailer_size && !error; ++i )
     {
-    if( !Rd_finished( &decoder->range_decoder ) )
-      trailer[i] = Rd_get_byte( &decoder->range_decoder );
+    if( !Rd_finished( decoder->range_decoder ) )
+      trailer[i] = Rd_get_byte( decoder->range_decoder );
     else
       {
       error = true;
@@ -73,13 +78,13 @@ bool LZd_verify_trailer( struct LZ_decoder * const decoder,
         {
         Pp_show_msg( pp, 0 );
         fprintf( stderr, "trailer truncated at trailer position %d;"
-                 " some checks may fail.\n", i );
+                         " some checks may fail.\n", i );
         }
+      for( ; i < trailer_size; ++i ) trailer[i] = 0;
       }
     }
-  if( decoder->format_version == 0 )
-    Ft_set_member_size( trailer, LZd_member_position( decoder ) );
-  if( !Rd_code_is_zero( &decoder->range_decoder ) )
+  if( decoder->format_version == 0 ) Ft_set_member_size( trailer, member_size );
+  if( !Rd_code_is_zero( decoder->range_decoder ) )
     {
     error = true;
     if( verbosity >= 0 )
@@ -105,18 +110,18 @@ bool LZd_verify_trailer( struct LZ_decoder * const decoder,
     if( verbosity >= 0 )
       {
       Pp_show_msg( pp, 0 );
-      fprintf( stderr, "data size mismatch; trailer says %lld, data size is %lld.\n",
-               Ft_get_data_size( trailer ), LZd_data_position( decoder ) );
+      fprintf( stderr, "data size mismatch; trailer says %lld, data size is %lld (0x%llX).\n",
+               Ft_get_data_size( trailer ), LZd_data_position( decoder ), LZd_data_position( decoder ) );
       }
     }
-  if( Ft_get_member_size( trailer ) != LZd_member_position( decoder ) )
+  if( Ft_get_member_size( trailer ) != member_size )
     {
     error = true;
     if( verbosity >= 0 )
       {
       Pp_show_msg( pp, 0 );
-      fprintf( stderr, "member size mismatch; trailer says %lld, member size is %lld.\n",
-               Ft_get_member_size( trailer ), LZd_member_position( decoder ) );
+      fprintf( stderr, "member size mismatch; trailer says %lld, member size is %lld (0x%llX).\n",
+               Ft_get_member_size( trailer ), member_size, member_size );
       }
     }
   if( !error && verbosity >= 3 )
@@ -137,41 +142,42 @@ int LZd_decode_member( struct LZ_decoder * const decoder,
   unsigned int rep2 = 0;	// repeated distances
   unsigned int rep3 = 0;
   State state = 0;
+  Rd_load( decoder->range_decoder );
 
   while( true )
     {
-    if( Rd_finished( &decoder->range_decoder ) )
+    if( Rd_finished( decoder->range_decoder ) )
       { LZd_flush_data( decoder ); return 2; }
     const int pos_state = LZd_data_position( decoder ) & pos_state_mask;
-    if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_match[state][pos_state] ) == 0 )
+    if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_match[state][pos_state] ) == 0 )
       {
       const uint8_t prev_byte = LZd_get_byte( decoder, 0 );
       if( St_is_char( state ) )
-        LZd_put_byte( decoder, Lid_decode( &decoder->literal_decoder, &decoder->range_decoder, prev_byte ) );
+        LZd_put_byte( decoder, Lid_decode( &decoder->literal_decoder, decoder->range_decoder, prev_byte ) );
       else
-        LZd_put_byte( decoder, Lid_decode_matched( &decoder->literal_decoder, &decoder->range_decoder, prev_byte,
+        LZd_put_byte( decoder, Lid_decode_matched( &decoder->literal_decoder, decoder->range_decoder, prev_byte,
                              LZd_get_byte( decoder, rep0 ) ) );
       St_set_char( &state );
       }
     else
       {
       int len;
-      if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_rep[state] ) == 1 )
+      if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_rep[state] ) == 1 )
         {
         len = 0;
-        if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_rep0[state] ) == 0 )
+        if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_rep0[state] ) == 0 )
           {
-          if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_len[state][pos_state] ) == 0 )
+          if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_len[state][pos_state] ) == 0 )
             { len = 1; St_set_short_rep( &state ); }
           }
         else
           {
           unsigned int distance;
-          if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_rep1[state] ) == 0 )
+          if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_rep1[state] ) == 0 )
             distance = rep1;
           else
             {
-            if( Rd_decode_bit( &decoder->range_decoder, &decoder->bm_rep2[state] ) == 0 )
+            if( Rd_decode_bit( decoder->range_decoder, &decoder->bm_rep2[state] ) == 0 )
               distance = rep2;
             else { distance = rep3; rep3 = rep2; }
             rep2 = rep1;
@@ -181,30 +187,30 @@ int LZd_decode_member( struct LZ_decoder * const decoder,
           }
         if( len == 0 )
           {
-          len = min_match_len + Led_decode( &decoder->rep_match_len_decoder, &decoder->range_decoder, pos_state );
+          len = min_match_len + Led_decode( &decoder->rep_match_len_decoder, decoder->range_decoder, pos_state );
           St_set_rep( &state );
           }
         }
       else
         {
         unsigned int rep0_saved = rep0;
-        len = min_match_len + Led_decode( &decoder->len_decoder, &decoder->range_decoder, pos_state );
-        const int dis_slot = Rd_decode_tree( &decoder->range_decoder, decoder->bm_dis_slot[get_dis_state(len)], dis_slot_bits );
+        len = min_match_len + Led_decode( &decoder->len_decoder, decoder->range_decoder, pos_state );
+        const int dis_slot = Rd_decode_tree( decoder->range_decoder, decoder->bm_dis_slot[get_dis_state(len)], dis_slot_bits );
         if( dis_slot < start_dis_model ) rep0 = dis_slot;
         else
           {
           const int direct_bits = ( dis_slot >> 1 ) - 1;
           rep0 = ( 2 | ( dis_slot & 1 ) ) << direct_bits;
           if( dis_slot < end_dis_model )
-            rep0 += Rd_decode_tree_reversed( &decoder->range_decoder, decoder->bm_dis + rep0 - dis_slot, direct_bits );
+            rep0 += Rd_decode_tree_reversed( decoder->range_decoder, decoder->bm_dis + rep0 - dis_slot, direct_bits );
           else
             {
-            rep0 += Rd_decode( &decoder->range_decoder, direct_bits - dis_align_bits ) << dis_align_bits;
-            rep0 += Rd_decode_tree_reversed( &decoder->range_decoder, decoder->bm_align, dis_align_bits );
-            if( rep0 == 0xFFFFFFFF )		// Marker found
+            rep0 += Rd_decode( decoder->range_decoder, direct_bits - dis_align_bits ) << dis_align_bits;
+            rep0 += Rd_decode_tree_reversed( decoder->range_decoder, decoder->bm_align, dis_align_bits );
+            if( rep0 == 0xFFFFFFFFU )		// Marker found
               {
               rep0 = rep0_saved;
-              Rd_normalize( &decoder->range_decoder );
+              Rd_normalize( decoder->range_decoder );
               LZd_flush_data( decoder );
               if( len == min_match_len )	// End Of Stream marker
                 {
@@ -212,7 +218,7 @@ int LZd_decode_member( struct LZ_decoder * const decoder,
                 }
               if( len == min_match_len + 1 )	// Sync Flush marker
                 {
-                Rd_reload( &decoder->range_decoder ); continue;
+                Rd_load( decoder->range_decoder ); continue;
                 }
               if( verbosity >= 0 )
                 {
diff --git a/decoder.h b/decoder.h
index 7df68b9..1bb773c 100644
--- a/decoder.h
+++ b/decoder.h
@@ -15,182 +15,159 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-enum { Ib_buffer_size = 65536 };
+enum { Rd_buffer_size = 16384 };
 
-struct Input_buffer
+struct Range_decoder
   {
-  uint8_t * buffer;
+  long long partial_member_pos;
+  uint8_t * buffer;		// input buffer
   int pos;
   int stream_pos;		// when reached, a new block must be read
+  uint32_t code;
+  uint32_t range;
   int infd_;			// input file descriptor
   bool at_stream_end;
   };
 
-bool Ib_read_block( struct Input_buffer * const ibuf );
+bool Rd_read_block( struct Range_decoder * const rdec );
 
-static inline void Ib_init( struct Input_buffer * const ibuf, const int infd )
+static inline void Rd_init( struct Range_decoder * const rdec, const int infd )
   {
-  ibuf->buffer = (uint8_t *)malloc( Ib_buffer_size );
-  if( !ibuf->buffer )
+  rdec->partial_member_pos = 0;
+  rdec->buffer = (uint8_t *)malloc( Rd_buffer_size );
+  if( !rdec->buffer )
     {
     show_error( "not enough memory. Find a machine with more memory", 0, false );
     cleanup_and_fail( 1 );
     }
-  ibuf->pos = 0;
-  ibuf->stream_pos = 0;
-  ibuf->infd_ = infd;
-  ibuf->at_stream_end = false;
+  rdec->pos = 0;
+  rdec->stream_pos = 0;
+  rdec->code = 0;
+  rdec->range = 0xFFFFFFFF;
+  rdec->infd_ = infd;
+  rdec->at_stream_end = false;
   }
 
-static inline void Ib_free( struct Input_buffer * const ibuf )
-  { free( ibuf->buffer ); ibuf->buffer = 0; }
+static inline void Rd_free( struct Range_decoder * const rdec )
+  { free( rdec->buffer ); rdec->buffer = 0; }
 
-static inline bool Ib_finished( struct Input_buffer * const ibuf )
-  { return ibuf->at_stream_end && ibuf->pos >= ibuf->stream_pos; }
+static inline bool Rd_code_is_zero( struct Range_decoder * const rdec )
+  { return ( rdec->code == 0 ); }
 
-static inline uint8_t Ib_get_byte( struct Input_buffer * const ibuf )
-  {
-  if( ibuf->pos >= ibuf->stream_pos && !Ib_read_block( ibuf ) )
-    return 0;
-  return ibuf->buffer[ibuf->pos++];
-  }
+static inline bool Rd_finished( struct Range_decoder * const rdec )
+  { return rdec->at_stream_end && rdec->pos >= rdec->stream_pos; }
 
+static inline long long Rd_member_position( struct Range_decoder * const rdec )
+  { return rdec->partial_member_pos + rdec->pos; }
 
-struct Range_decoder
-  {
-  long long member_pos;
-  uint32_t code;
-  uint32_t range;
-  struct Input_buffer * ibuf;
-  };
+static inline void Rd_reset_member_position( struct Range_decoder * const rdec )
+  { rdec->partial_member_pos = -rdec->pos; }
 
-static inline uint8_t Rd_get_byte( struct Range_decoder * const range_decoder )
+static inline uint8_t Rd_get_byte( struct Range_decoder * const rdec )
   {
-  ++range_decoder->member_pos;
-  return Ib_get_byte( range_decoder->ibuf );
+  if( rdec->pos >= rdec->stream_pos && !Rd_read_block( rdec ) ) return 0;
+  return rdec->buffer[rdec->pos++];
   }
 
-static inline void Rd_init( struct Range_decoder * const range_decoder,
-                            struct Input_buffer * const buf )
+static inline void Rd_load( struct Range_decoder * const rdec )
   {
-  range_decoder->member_pos = sizeof (File_header);
-  range_decoder->code = 0;
-  range_decoder->range = 0xFFFFFFFF;
-  range_decoder->ibuf = buf;
+  rdec->code = 0;
+  rdec->range = 0xFFFFFFFFU;
   for( int i = 0; i < 5; ++i )
-    range_decoder->code = (range_decoder->code << 8) |
-                          Rd_get_byte( range_decoder );
+    rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
   }
 
-static inline bool Rd_code_is_zero( struct Range_decoder * const range_decoder )
-  { return ( range_decoder->code == 0 ); }
-static inline bool Rd_finished( struct Range_decoder * const range_decoder )
-  { return Ib_finished( range_decoder->ibuf ); }
-static inline long long Rd_member_position( struct Range_decoder * const range_decoder )
-  { return range_decoder->member_pos; }
-
-static inline void Rd_reload( struct Range_decoder * const range_decoder )
+static inline void Rd_normalize( struct Range_decoder * const rdec )
   {
-  range_decoder->code = 0;
-  range_decoder->range = 0xFFFFFFFF;
-  for( int i = 0; i < 5; ++i )
-    range_decoder->code = (range_decoder->code << 8) |
-                          Rd_get_byte( range_decoder );
-  }
-
-static inline void Rd_normalize( struct Range_decoder * const range_decoder )
-  {
-  if( range_decoder->range <= 0x00FFFFFF )
+  if( rdec->range <= 0x00FFFFFFU )
     {
-    range_decoder->range <<= 8;
-    range_decoder->code = (range_decoder->code << 8) |
-                          Rd_get_byte( range_decoder );
+    rdec->range <<= 8;
+    rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
     }
   }
 
-static inline int Rd_decode( struct Range_decoder * const range_decoder,
+static inline int Rd_decode( struct Range_decoder * const rdec,
                              const int num_bits )
   {
   int symbol = 0;
   for( int i = num_bits; i > 0; --i )
     {
     symbol <<= 1;
-    if( range_decoder->range <= 0x00FFFFFF )
+    if( rdec->range <= 0x00FFFFFFU )
       {
-      range_decoder->range <<= 7;
-      range_decoder->code = (range_decoder->code << 8) |
-                            Rd_get_byte( range_decoder );
-      if( range_decoder->code >= range_decoder->range )
-        { range_decoder->code -= range_decoder->range; symbol |= 1; }
+      rdec->range <<= 7;
+      rdec->code = (rdec->code << 8) | Rd_get_byte( rdec );
+      if( rdec->code >= rdec->range )
+        { rdec->code -= rdec->range; symbol |= 1; }
       }
     else
       {
-      range_decoder->range >>= 1;
-      if( range_decoder->code >= range_decoder->range )
-        { range_decoder->code -= range_decoder->range; symbol |= 1; }
+      rdec->range >>= 1;
+      if( rdec->code >= rdec->range )
+        { rdec->code -= rdec->range; symbol |= 1; }
       }
     }
   return symbol;
   }
 
-static inline int Rd_decode_bit( struct Range_decoder * const range_decoder,
+static inline int Rd_decode_bit( struct Range_decoder * const rdec,
                                  Bit_model * const probability )
   {
-  Rd_normalize( range_decoder );
-  const uint32_t bound = ( range_decoder->range >> bit_model_total_bits ) *
+  Rd_normalize( rdec );
+  const uint32_t bound = ( rdec->range >> bit_model_total_bits ) *
                          *probability;
-  if( range_decoder->code < bound )
+  if( rdec->code < bound )
     {
-    range_decoder->range = bound;
+    rdec->range = bound;
     *probability += (bit_model_total - *probability) >> bit_model_move_bits;
     return 0;
     }
   else
     {
-    range_decoder->range -= bound;
-    range_decoder->code -= bound;
+    rdec->range -= bound;
+    rdec->code -= bound;
     *probability -= *probability >> bit_model_move_bits;
     return 1;
     }
   }
 
-static inline int Rd_decode_tree( struct Range_decoder * const range_decoder,
+static inline int Rd_decode_tree( struct Range_decoder * const rdec,
                                   Bit_model bm[], const int num_bits )
   {
   int model = 1;
   for( int i = num_bits; i > 0; --i )
-    model = ( model << 1 ) | Rd_decode_bit( range_decoder, &bm[model] );
+    model = ( model << 1 ) | Rd_decode_bit( rdec, &bm[model] );
   return model - (1 << num_bits);
   }
 
-static inline int Rd_decode_tree_reversed( struct Range_decoder * const range_decoder,
+static inline int Rd_decode_tree_reversed( struct Range_decoder * const rdec,
                                            Bit_model bm[], const int num_bits )
   {
   int model = 1;
   int symbol = 0;
   for( int i = 0; i < num_bits; ++i )
     {
-    const int bit = Rd_decode_bit( range_decoder, &bm[model] );
+    const int bit = Rd_decode_bit( rdec, &bm[model] );
     model <<= 1;
     if( bit ) { model |= 1; symbol |= (1 << i); }
     }
   return symbol;
   }
 
-static inline int Rd_decode_matched( struct Range_decoder * const range_decoder,
+static inline int Rd_decode_matched( struct Range_decoder * const rdec,
                                      Bit_model bm[], const int match_byte )
   {
-  Bit_model *bm1 = bm + 0x100;
+  Bit_model * const bm1 = bm + 0x100;
   int symbol = 1;
-  for( int i = 1; i <= 8; ++i )
+  for( int i = 7; i >= 0; --i )
     {
-    const int match_bit = ( match_byte << i ) & 0x100;
-    const int bit = Rd_decode_bit( range_decoder, &bm1[match_bit+symbol] );
+    const int match_bit = ( match_byte >> i ) & 1;
+    const int bit = Rd_decode_bit( rdec, &bm1[(match_bit<<8)+symbol] );
     symbol = ( symbol << 1 ) | bit;
-    if( ( match_bit && !bit ) || ( !match_bit && bit ) )
+    if( match_bit != bit )
       {
-      while( ++i <= 8 )
-        symbol = ( symbol << 1 ) | Rd_decode_bit( range_decoder, &bm[symbol] );
+      while( --i >= 0 )
+        symbol = ( symbol << 1 ) | Rd_decode_bit( rdec, &bm[symbol] );
       break;
       }
     }
@@ -222,18 +199,16 @@ static inline void Led_init( struct Len_decoder * const len_decoder )
   }
 
 static inline int Led_decode( struct Len_decoder * const len_decoder,
-                              struct Range_decoder * const range_decoder,
+                              struct Range_decoder * const rdec,
                               const int pos_state )
   {
-  if( Rd_decode_bit( range_decoder, &len_decoder->choice1 ) == 0 )
-    return Rd_decode_tree( range_decoder, len_decoder->bm_low[pos_state],
-                        len_low_bits );
-  if( Rd_decode_bit( range_decoder, &len_decoder->choice2 ) == 0 )
+  if( Rd_decode_bit( rdec, &len_decoder->choice1 ) == 0 )
+    return Rd_decode_tree( rdec, len_decoder->bm_low[pos_state], len_low_bits );
+  if( Rd_decode_bit( rdec, &len_decoder->choice2 ) == 0 )
     return len_low_symbols +
-           Rd_decode_tree( range_decoder, len_decoder->bm_mid[pos_state],
-                        len_mid_bits );
+           Rd_decode_tree( rdec, len_decoder->bm_mid[pos_state], len_mid_bits );
   return len_low_symbols + len_mid_symbols +
-         Rd_decode_tree( range_decoder, len_decoder->bm_high, len_high_bits );
+         Rd_decode_tree( rdec, len_decoder->bm_high, len_high_bits );
   }
 
 
@@ -253,15 +228,15 @@ static inline int Lid_state( const int prev_byte )
   { return ( prev_byte >> ( 8 - literal_context_bits ) ); }
 
 static inline uint8_t Lid_decode( struct Literal_decoder * const literal_decoder,
-                                  struct Range_decoder * const range_decoder,
+                                  struct Range_decoder * const rdec,
                                   const uint8_t prev_byte )
-  { return Rd_decode_tree( range_decoder, literal_decoder->bm_literal[Lid_state(prev_byte)], 8 ); }
+  { return Rd_decode_tree( rdec, literal_decoder->bm_literal[Lid_state(prev_byte)], 8 ); }
 
 static inline uint8_t Lid_decode_matched( struct Literal_decoder * const literal_decoder,
-                                          struct Range_decoder * const range_decoder,
+                                          struct Range_decoder * const rdec,
                                           const uint8_t prev_byte,
                                           const uint8_t match_byte )
-  { return Rd_decode_matched( range_decoder, literal_decoder->bm_literal[Lid_state(prev_byte)], match_byte ); }
+  { return Rd_decode_matched( rdec, literal_decoder->bm_literal[Lid_state(prev_byte)], match_byte ); }
 
 
 struct LZ_decoder
@@ -286,7 +261,7 @@ struct LZ_decoder
   Bit_model bm_dis[modeled_distances-end_dis_model];
   Bit_model bm_align[dis_align_size];
 
-  struct Range_decoder range_decoder;
+  struct Range_decoder * range_decoder;
   struct Len_decoder len_decoder;
   struct Len_decoder rep_match_len_decoder;
   struct Literal_decoder literal_decoder;
@@ -335,7 +310,7 @@ bool LZd_verify_trailer( struct LZ_decoder * const decoder,
 
 static inline void LZd_init( struct LZ_decoder * const decoder,
                              const File_header header,
-                             struct Input_buffer * const ibuf, const int outfd )
+                             struct Range_decoder * const rdec, const int outfd )
   {
   decoder->partial_data_pos = 0;
   decoder->format_version = Fh_version( header );
@@ -349,7 +324,7 @@ static inline void LZd_init( struct LZ_decoder * const decoder,
     }
   decoder->pos = 0;
   decoder->stream_pos = 0;
-  decoder->crc_ = 0xFFFFFFFF;
+  decoder->crc_ = 0xFFFFFFFFU;
   decoder->outfd_ = outfd;
 
   for( int i = 0; i < St_states; ++i )
@@ -372,7 +347,7 @@ static inline void LZd_init( struct LZ_decoder * const decoder,
   for( int i = 0; i < dis_align_size; ++i )
     Bm_init( &decoder->bm_align[i] );
 
-  Rd_init( &decoder->range_decoder, ibuf );
+  decoder->range_decoder = rdec;
   Led_init( &decoder->len_decoder );
   Led_init( &decoder->rep_match_len_decoder );
   Lid_init( &decoder->literal_decoder );
@@ -383,11 +358,13 @@ static inline void LZd_free( struct LZ_decoder * const decoder )
   { free( decoder->buffer ); decoder->buffer = 0; }
 
 static inline uint32_t LZd_crc( struct LZ_decoder * const decoder )
-  { return decoder->crc_ ^ 0xFFFFFFFF; }
+  { return decoder->crc_ ^ 0xFFFFFFFFU; }
+
 int LZd_decode_member( struct LZ_decoder * const decoder,
                        struct Pretty_print * const pp );
 
 static inline long long LZd_member_position( struct LZ_decoder * const decoder )
-  { return Rd_member_position( &decoder->range_decoder ); }
+  { return Rd_member_position( decoder->range_decoder ); }
+
 static inline long long LZd_data_position( struct LZ_decoder * const decoder )
   { return decoder->partial_data_pos + decoder->pos; }
diff --git a/doc/clzip.1 b/doc/clzip.1
index 71884aa..f259dfa 100644
--- a/doc/clzip.1
+++ b/doc/clzip.1
@@ -1,5 +1,5 @@
 .\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.36.
-.TH CLZIP "1" "February 2010" "Clzip 1.0-rc2" "User Commands"
+.TH CLZIP "1" "March 2010" "Clzip 1.0-rc3" "User Commands"
 .SH NAME
 Clzip \- data compressor based on the LZMA algorithm
 .SH SYNOPSIS
diff --git a/doc/clzip.info b/doc/clzip.info
index d4a51b3..a98e8e5 100644
--- a/doc/clzip.info
+++ b/doc/clzip.info
@@ -12,7 +12,7 @@ File: clzip.info,  Node: Top,  Next: Introduction,  Up: (dir)
 Clzip Manual
 ************
 
-This manual is for Clzip (version 1.0-rc2, 21 February 2010).
+This manual is for Clzip (version 1.0-rc3, 13 March 2010).
 
 * Menu:
 
@@ -68,11 +68,11 @@ multivolume compressed tar archives.
    The amount of memory required for compression is about 5 MiB plus 1
 or 2 times the dictionary size limit (1 if input file size is less than
 dictionary size limit, else 2) plus 8 times the dictionary size really
-used. For decompression is a little more than the dictionary size really
-used. Clzip will automatically use the smallest possible dictionary size
-without exceeding the given limit. It is important to appreciate that
-the decompression memory requirement is affected at compression time by
-the choice of dictionary size limit.
+used. For decompression it is a little more than the dictionary size
+really used. Clzip will automatically use the smallest possible
+dictionary size without exceeding the given limit. It is important to
+appreciate that the decompression memory requirement is affected at
+compression time by the choice of dictionary size limit.
 
    When decompressing, clzip attempts to guess the name for the
 decompressed file from that of the compressed file as follows:
@@ -432,7 +432,7 @@ Concept Index
 
 Tag Table:
 Node: Top226
-Node: Introduction838
+Node: Introduction835
 Node: Algorithm4160
 Node: Invoking Clzip6391
 Node: File Format10747
diff --git a/doc/clzip.texinfo b/doc/clzip.texinfo
index e9e6339..2a2e586 100644
--- a/doc/clzip.texinfo
+++ b/doc/clzip.texinfo
@@ -5,8 +5,8 @@
 @finalout
 @c %**end of header
 
-@set UPDATED 21 February 2010
-@set VERSION 1.0-rc2
+@set UPDATED 13 March 2010
+@set VERSION 1.0-rc3
 
 @dircategory Data Compression
 @direntry
@@ -84,11 +84,11 @@ compressed tar archives.
 The amount of memory required for compression is about 5 MiB plus 1 or 2
 times the dictionary size limit (1 if input file size is less than
 dictionary size limit, else 2) plus 8 times the dictionary size really
-used. For decompression is a little more than the dictionary size really
-used. Clzip will automatically use the smallest possible dictionary size
-without exceeding the given limit. It is important to appreciate that
-the decompression memory requirement is affected at compression time by
-the choice of dictionary size limit.
+used. For decompression it is a little more than the dictionary size
+really used. Clzip will automatically use the smallest possible
+dictionary size without exceeding the given limit. It is important to
+appreciate that the decompression memory requirement is affected at
+compression time by the choice of dictionary size limit.
 
 When decompressing, clzip attempts to guess the name for the decompressed
 file from that of the compressed file as follows:
diff --git a/encoder.c b/encoder.c
index a46893a..bcbdf6a 100644
--- a/encoder.c
+++ b/encoder.c
@@ -50,7 +50,8 @@ void Mf_init( struct Matchfinder * const matchfinder,
   matchfinder->stream_pos = 0;
   matchfinder->infd_ = infd;
   matchfinder->match_len_limit_ = len_limit;
-  matchfinder->prev_positions = (int32_t *)malloc( mf_num_prev_positions * sizeof (int32_t) );
+  matchfinder->prev_positions =
+    (int32_t *)malloc( mf_num_prev_positions * sizeof (int32_t) );
   if( !matchfinder->prev_positions )
     {
     show_error( "not enough memory. Try a smaller dictionary size", 0, false );
@@ -71,7 +72,8 @@ void Mf_init( struct Matchfinder * const matchfinder,
   if( !matchfinder->at_stream_end && matchfinder->buffer_size < buffer_size_limit )
     {
     matchfinder->buffer_size = buffer_size_limit;
-    matchfinder->buffer = (uint8_t *)realloc( matchfinder->buffer, matchfinder->buffer_size * sizeof (uint8_t) );
+    matchfinder->buffer =
+      (uint8_t *)realloc( matchfinder->buffer, matchfinder->buffer_size );
     if( !matchfinder->buffer )
       {
       show_error( "not enough memory. Try a smaller dictionary size", 0, false );
@@ -85,7 +87,8 @@ void Mf_init( struct Matchfinder * const matchfinder,
   else matchfinder->dictionary_size_ = dict_size;
   matchfinder->pos_limit = matchfinder->buffer_size;
   if( !matchfinder->at_stream_end ) matchfinder->pos_limit -= mf_after_size;
-  matchfinder->prev_pos_tree = (int32_t *)malloc( 2 * matchfinder->dictionary_size_ * sizeof (int32_t) );
+  matchfinder->prev_pos_tree =
+    (int32_t *)malloc( 2 * matchfinder->dictionary_size_ * sizeof (int32_t) );
   if( !matchfinder->prev_pos_tree )
     {
     show_error( "not enough memory. Try a smaller dictionary size", 0, false );
@@ -153,10 +156,11 @@ int Mf_longest_match_len( struct Matchfinder * const matchfinder,
   const uint8_t * const data = matchfinder->buffer + matchfinder->pos;
   const int key2 = mf_num_prev_positions4 + mf_num_prev_positions3 +
                    ( ( (int)data[0] << 8 ) | data[1] );
-  const int tmp = crc32[data[0]] ^ data[1] ^ ( (int)data[2] << 8 );
-  const int key3 = mf_num_prev_positions4 + ( tmp & ( mf_num_prev_positions3 - 1 ) );
-  const int key4 = ( tmp ^ ( crc32[data[3]] << 5 ) ) &
-                   ( mf_num_prev_positions4 - 1 );
+  const uint32_t tmp = crc32[data[0]] ^ data[1] ^ ( (uint32_t)data[2] << 8 );
+  const int key3 = mf_num_prev_positions4 +
+                   (int)( tmp & ( mf_num_prev_positions3 - 1 ) );
+  const int key4 = (int)( ( tmp ^ ( crc32[data[3]] << 5 ) ) &
+                          ( mf_num_prev_positions4 - 1 ) );
 
   if( distances )
     {
@@ -292,9 +296,11 @@ void LZe_fill_distance_prices( struct LZ_encoder * const encoder )
   }
 
 
-// Return value: ( dis == -1 ) && ( len == 1 ) means literal
-int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[num_rep_distances],
-                            const State state )
+// Return value == number of bytes advanced (ahead).
+// trials[0]..trials[retval-1] contain the steps to encode.
+// ( trials[0].dis == -1 && trials[0].price == 1 ) means literal.
+int LZe_sequence_optimizer( struct LZ_encoder * const encoder,
+                            const int reps[num_rep_distances], const State state )
   {
   int main_len;
   if( encoder->longest_match_found > 0 )		// from previous call
@@ -328,15 +334,14 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
     return main_len;
     }
 
-  encoder->trials[0].state = state;
-  for( int i = 0; i < num_rep_distances; ++i ) encoder->trials[0].reps[i] = reps[i];
-
+  {
+  const int pos_state = Mf_data_position( encoder->matchfinder ) & pos_state_mask;
   const uint8_t prev_byte = Mf_peek( encoder->matchfinder, -1 );
   const uint8_t cur_byte = Mf_peek( encoder->matchfinder, 0 );
   const uint8_t match_byte = Mf_peek( encoder->matchfinder, -reps[0]-1 );
-  unsigned int position = Mf_data_position( encoder->matchfinder );
-  const int pos_state = position & pos_state_mask;
 
+  encoder->trials[0].state = state;
+  for( int i = 0; i < num_rep_distances; ++i ) encoder->trials[0].reps[i] = reps[i];
   encoder->trials[1].dis = -1;
   encoder->trials[1].prev_index = 0;
   encoder->trials[1].price = price0( encoder->bm_match[state][pos_state] );
@@ -385,6 +390,7 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
       Tr_update( &encoder->trials[len], rep, 0, price +
                  Lee_price( &encoder->rep_match_len_encoder, len, pos_state ) );
     }
+  }
 
   int cur = 0;
   int num_trials = main_len;
@@ -392,7 +398,7 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
 
   while( true )
     {
-    if( ++cur >= num_trials )
+    if( ++cur >= num_trials )		// no more initialized trials
       {
       LZe_backward( encoder, cur );
       return cur;
@@ -424,10 +430,11 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
       LZe_mtf_reps( cur_trial->dis, cur_trial->reps );
       }
 
+    const int pos_state = Mf_data_position( encoder->matchfinder ) & pos_state_mask;
     const uint8_t prev_byte = Mf_peek( encoder->matchfinder, -1 );
     const uint8_t cur_byte = Mf_peek( encoder->matchfinder, 0 );
     const uint8_t match_byte = Mf_peek( encoder->matchfinder, -cur_trial->reps[0]-1 );
-    const int pos_state = ++position & pos_state_mask;
+
     int next_price = cur_trial->price + price0( encoder->bm_match[cur_trial->state][pos_state] );
     if( St_is_char( cur_trial->state ) )
       next_price += Lie_price_symbol( &encoder->literal_encoder, prev_byte, cur_byte );
@@ -472,7 +479,7 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
     if( newlen <= len_limit &&
         ( newlen > min_match_len ||
           ( newlen == min_match_len &&
-            encoder->match_distances[newlen] < modeled_distances ) ) )
+            encoder->match_distances[min_match_len] < modeled_distances ) ) )
       {
       const int normal_match_price = match_price +
                                      price0( encoder->bm_rep[cur_trial->state] );
@@ -488,19 +495,19 @@ int LZe_best_pair_sequence( struct LZ_encoder * const encoder, const int reps[nu
   }
 
 
-     // End Of Stream mark => (dis == 0xFFFFFFFF, len == min_match_len)
+     // End Of Stream mark => (dis == 0xFFFFFFFFU, len == min_match_len)
 void LZe_full_flush( struct LZ_encoder * const encoder, const State state )
   {
-  const int pos_state = ( Mf_data_position( encoder->matchfinder ) ) & pos_state_mask;
+  const int pos_state = Mf_data_position( encoder->matchfinder ) & pos_state_mask;
   Re_encode_bit( &encoder->range_encoder, &encoder->bm_match[state][pos_state], 1 );
   Re_encode_bit( &encoder->range_encoder, &encoder->bm_rep[state], 0 );
-  LZe_encode_pair( encoder, 0xFFFFFFFF, min_match_len, pos_state );
+  LZe_encode_pair( encoder, 0xFFFFFFFFU, min_match_len, pos_state );
   Re_flush( &encoder->range_encoder );
   File_trailer trailer;
   Ft_set_data_crc( trailer, LZe_crc( encoder ) );
   Ft_set_data_size( trailer, Mf_data_position( encoder->matchfinder ) );
-  Ft_set_member_size( trailer, LZe_member_position( encoder ) + sizeof (File_trailer) );
-  for( unsigned int i = 0; i < sizeof (File_trailer); ++i )
+  Ft_set_member_size( trailer, LZe_member_position( encoder ) + Ft_size );
+  for( int i = 0; i < Ft_size; ++i )
     Re_put_byte( &encoder->range_encoder, trailer[i] );
   Re_flush_data( &encoder->range_encoder );
   }
@@ -510,7 +517,7 @@ void LZe_init( struct LZ_encoder * const encoder, struct Matchfinder * const mf,
                const File_header header, const int outfd )
   {
   encoder->longest_match_found = 0;
-  encoder->crc_ = 0xFFFFFFFF;
+  encoder->crc_ = 0xFFFFFFFFU;
 
   for( int i = 0; i < St_states; ++i )
     {
@@ -541,17 +548,17 @@ void LZe_init( struct LZ_encoder * const encoder, struct Matchfinder * const mf,
 
   LZe_fill_align_prices( encoder );
 
-  for( unsigned int i = 0; i < sizeof (File_header); ++i )
+  for( int i = 0; i < Fh_size; ++i )
     Re_put_byte( &encoder->range_encoder, header[i] );
   }
 
 
 bool LZe_encode_member( struct LZ_encoder * const encoder, const long long member_size )
   {
-  if( LZe_member_position( encoder ) != sizeof (File_header) )
+  if( LZe_member_position( encoder ) != Fh_size )
     return false;		// can be called only once
   const long long member_size_limit =
-    member_size - sizeof (File_trailer) - lze_max_marker_size;
+    member_size - Ft_size - lze_max_marker_size;
   int fill_counter = 0;
   int rep_distances[num_rep_distances];
   State state = 0;
@@ -576,22 +583,23 @@ bool LZe_encode_member( struct LZ_encoder * const encoder, const long long membe
     if( fill_counter <= 0 )
       { LZe_fill_distance_prices( encoder ); fill_counter = 512; }
 
-    int ahead = LZe_best_pair_sequence( encoder, rep_distances, state );
+    int ahead = LZe_sequence_optimizer( encoder, rep_distances, state );
     if( ahead <= 0 ) return false;
     fill_counter -= ahead;
 
     for( int i = 0; ; )
       {
       const int pos_state = ( Mf_data_position( encoder->matchfinder ) - ahead ) & pos_state_mask;
-      int dis = encoder->trials[i].dis;
+      const int dis = encoder->trials[i].dis;
       const int len = encoder->trials[i].price;
 
       bool bit = ( dis < 0 && len == 1 );
       Re_encode_bit( &encoder->range_encoder, &encoder->bm_match[state][pos_state], !bit );
-      if( bit )
+      if( bit )				// literal byte
         {
         const uint8_t prev_byte = Mf_peek( encoder->matchfinder, -ahead-1 );
         const uint8_t cur_byte = Mf_peek( encoder->matchfinder, -ahead );
+        CRC32_update_byte( &encoder->crc_, cur_byte );
         if( St_is_char( state ) )
           Lie_encode( &encoder->literal_encoder, &encoder->range_encoder, prev_byte, cur_byte );
         else
@@ -601,8 +609,9 @@ bool LZe_encode_member( struct LZ_encoder * const encoder, const long long membe
           }
         St_set_char( &state );
         }
-      else
+      else				// match or repeated match
         {
+        CRC32_update_buf( &encoder->crc_, Mf_ptr_to_current_pos( encoder->matchfinder ) - ahead, len );
         LZe_mtf_reps( dis, rep_distances );
         bit = ( dis < num_rep_distances );
         Re_encode_bit( &encoder->range_encoder, &encoder->bm_rep[state], bit );
@@ -631,8 +640,6 @@ bool LZe_encode_member( struct LZ_encoder * const encoder, const long long membe
           St_set_match( &state );
           }
         }
-      for( int j = 0; j < len; ++j )
-        CRC32_update_byte( &encoder->crc_, Mf_peek( encoder->matchfinder, j-ahead ) );
       ahead -= len; i += len;
       if( LZe_member_position( encoder ) >= member_size_limit )
         {
diff --git a/encoder.h b/encoder.h
index fe74f7c..975fe01 100644
--- a/encoder.h
+++ b/encoder.h
@@ -112,14 +112,14 @@ static inline int price_matched( const Bit_model bm[], const int symbol,
   for( int i = 7; i >= 0; --i )
     {
     const int match_bit = ( match_byte >> i ) & 1;
-    const int bit = ( symbol >> i ) & 1;
+    int bit = ( symbol >> i ) & 1;
     price += price_bit( bm[(match_bit<<8)+model+0x100], bit );
     model = ( model << 1 ) | bit;
     if( match_bit != bit )
       {
       while( --i >= 0 )
         {
-        const int bit = ( symbol >> i ) & 1;
+        bit = ( symbol >> i ) & 1;
         price += price_bit( bm[model], bit );
         model = ( model << 1 ) | bit;
         }
@@ -251,7 +251,7 @@ static inline void Re_put_byte( struct Range_encoder * const range_encoder,
 static inline void Re_shift_low( struct Range_encoder * const range_encoder )
   {
   const uint32_t carry = range_encoder->low >> 32;
-  if( range_encoder->low < 0xFF000000LL || carry == 1 )
+  if( range_encoder->low < 0xFF000000U || carry == 1 )
     {
     Re_put_byte( range_encoder, range_encoder->cache + carry );
     for( ; range_encoder->ff_count > 0; --range_encoder->ff_count )
@@ -259,7 +259,7 @@ static inline void Re_shift_low( struct Range_encoder * const range_encoder )
     range_encoder->cache = range_encoder->low >> 24;
     }
   else ++range_encoder->ff_count;
-  range_encoder->low = ( range_encoder->low & 0x00FFFFFFLL ) << 8;
+  range_encoder->low = ( range_encoder->low & 0x00FFFFFFU ) << 8;
   }
 
 static inline void Re_init( struct Range_encoder * const range_encoder,
@@ -274,7 +274,7 @@ static inline void Re_init( struct Range_encoder * const range_encoder,
     cleanup_and_fail( 1 );
     }
   range_encoder->pos = 0;
-  range_encoder->range = 0xFFFFFFFF;
+  range_encoder->range = 0xFFFFFFFFU;
   range_encoder->ff_count = 0;
   range_encoder->outfd_ = outfd;
   range_encoder->cache = 0;
@@ -296,7 +296,7 @@ static inline void Re_encode( struct Range_encoder * const range_encoder,
     {
     range_encoder->range >>= 1;
     if( (symbol >> i) & 1 ) range_encoder->low += range_encoder->range;
-    if( range_encoder->range <= 0x00FFFFFF )
+    if( range_encoder->range <= 0x00FFFFFFU )
       { range_encoder->range <<= 8; Re_shift_low( range_encoder ); }
     }
   }
@@ -316,7 +316,7 @@ static inline void Re_encode_bit( struct Range_encoder * const range_encoder,
     range_encoder->range -= bound;
     *probability -= *probability >> bit_model_move_bits;
     }
-  if( range_encoder->range <= 0x00FFFFFF )
+  if( range_encoder->range <= 0x00FFFFFFU )
     { range_encoder->range <<= 8; Re_shift_low( range_encoder ); }
   }
 
@@ -353,15 +353,15 @@ static inline void Re_encode_matched( struct Range_encoder * const range_encoder
   int model = 1;
   for( int i = 7; i >= 0; --i )
     {
-    const int bit = ( symbol >> i ) & 1;
     const int match_bit = ( match_byte >> i ) & 1;
+    int bit = ( symbol >> i ) & 1;
     Re_encode_bit( range_encoder, &bm[(match_bit<<8)+model+0x100], bit );
     model = ( model << 1 ) | bit;
     if( match_bit != bit )
       {
       while( --i >= 0 )
         {
-        const int bit = ( symbol >> i ) & 1;
+        bit = ( symbol >> i ) & 1;
         Re_encode_bit( range_encoder, &bm[model], bit );
         model = ( model << 1 ) | bit;
         }
@@ -387,17 +387,17 @@ static inline void Lee_update_prices( struct Len_encoder * const len_encoder,
                                       const int pos_state )
   {
   int * const pps = len_encoder->prices[pos_state];
-  int price = price0( len_encoder->choice1 );
+  int tmp = price0( len_encoder->choice1 );
   int len = 0;
   for( ; len < len_low_symbols && len < len_encoder->len_symbols; ++len )
-    pps[len] = price +
+    pps[len] = tmp +
                price_symbol( len_encoder->bm_low[pos_state], len, len_low_bits );
-  price = price1( len_encoder->choice1 );
+  tmp = price1( len_encoder->choice1 );
   for( ; len < len_low_symbols + len_mid_symbols && len < len_encoder->len_symbols; ++len )
-    pps[len] = price + price0( len_encoder->choice2 ) +
+    pps[len] = tmp + price0( len_encoder->choice2 ) +
                price_symbol( len_encoder->bm_mid[pos_state], len - len_low_symbols, len_mid_bits );
   for( ; len < len_encoder->len_symbols; ++len )
-    pps[len] = price + price1( len_encoder->choice2 ) +
+    pps[len] = tmp + price1( len_encoder->choice2 ) +
                price_symbol( len_encoder->bm_high, len - len_low_symbols - len_mid_symbols, len_high_bits );
   len_encoder->counters[pos_state] = len_encoder->len_symbols;
   }
@@ -519,8 +519,9 @@ void LZe_fill_align_prices( struct LZ_encoder * const encoder );
 void LZe_fill_distance_prices( struct LZ_encoder * const encoder );
 
 static inline uint32_t LZe_crc( struct LZ_encoder * const encoder )
-  { return encoder->crc_ ^ 0xFFFFFFFF; }
+  { return encoder->crc_ ^ 0xFFFFFFFFU; }
 
+       // move-to-front dis in/into reps
 static inline void LZe_mtf_reps( const int dis, int reps[num_rep_distances] )
   {
   if( dis >= num_rep_distances )
@@ -631,7 +632,7 @@ static inline void LZe_backward( struct LZ_encoder * const encoder, int cur )
     }
   }
 
-int LZe_best_pair_sequence( struct LZ_encoder * const encoder,
+int LZe_sequence_optimizer( struct LZ_encoder * const encoder,
                             const int reps[num_rep_distances], const State state );
 
 void LZe_full_flush( struct LZ_encoder * const encoder, const State state );
diff --git a/main.c b/main.c
index 3eb7c87..77cb1f6 100644
--- a/main.c
+++ b/main.c
@@ -399,8 +399,9 @@ static bool next_filename()
 
 
 static int compress( const long long member_size, const long long volume_size,
-                     const struct Lzma_options * const encoder_options, const int infd,
-                     struct Pretty_print * const pp, const struct stat * const in_statsp )
+                     const struct Lzma_options * const encoder_options,
+                     const int infd, struct Pretty_print * const pp,
+                     const struct stat * const in_statsp )
   {
   if( verbosity >= 1 ) Pp_show_msg( pp, 0 );
   File_header header;
@@ -412,7 +413,7 @@ static int compress( const long long member_size, const long long volume_size,
 
   struct Matchfinder matchfinder;
   Mf_init( &matchfinder, Fh_get_dictionary_size( header ),
-                    encoder_options->match_len_limit, infd );
+           encoder_options->match_len_limit, infd );
   Fh_set_dictionary_size( header, Mf_dictionary_size( &matchfinder ) );
 
   long long in_size = 0, out_size = 0, partial_volume_size = 0;
@@ -424,8 +425,7 @@ static int compress( const long long member_size, const long long volume_size,
     const long long size =
       min( member_size, volume_size - partial_volume_size );
     if( !LZe_encode_member( &encoder, size ) )
-      { Pp_show_msg( pp, 0 ); show_error( "encoder error", 0, false );
-        retval = 1; break; }
+      { Pp_show_msg( pp, "encoder error" ); retval = 1; break; }
     in_size += Mf_data_position( &matchfinder );
     out_size += LZe_member_position( &encoder );
     partial_volume_size += LZe_member_position( &encoder );
@@ -438,15 +438,14 @@ static int compress( const long long member_size, const long long volume_size,
         {
         close_and_set_permissions( in_statsp );
         if( !next_filename() )
-          { Pp_show_msg( pp, 0 );
-            show_error( "too many volume files", 0, false );
-            retval = 1; break; }
+          { Pp_show_msg( pp, "too many volume files" ); retval = 1; break; }
         if( !open_outstream( true ) ) { retval = 1; break; }
         delete_output_on_interrupt = true;
         }
       }
     if( !Mf_reset( &matchfinder ) )
-      { Pp_show_msg( pp, 0 ); show_error( "can't reset matchfinder", 0, false );
+      { Pp_show_msg( pp, 0 );
+        show_error( "can't reset matchfinder", errno, false );
         retval = 1; break; }
     }
 
@@ -470,20 +469,22 @@ static int compress( const long long member_size, const long long volume_size,
 static int decompress( const int infd, struct Pretty_print * const pp,
                        const bool testing )
   {
-  struct Input_buffer ibuf;
-  Ib_init( &ibuf, infd );
+  struct Range_decoder rdec;
+  Rd_init( &rdec, infd );
   long long partial_file_pos = 0;
   int retval = 0;
 
   for( bool first_member = true; ; first_member = false, Pp_reset( pp ) )
     {
     File_header header;
-    for( unsigned int i = 0; i < sizeof (File_header); ++i )
-      header[i] = Ib_get_byte( &ibuf );
-    if( Ib_finished( &ibuf ) )		// End Of File
+    Rd_reset_member_position( &rdec );
+    for( int i = 0; i < Fh_size; ++i )
+      header[i] = Rd_get_byte( &rdec );
+    if( Rd_finished( &rdec ) )		// End Of File
       {
-      if( !first_member ) break;
-      Pp_show_msg( pp, "error reading member header" ); retval = 1; break;
+      if( first_member )
+        { Pp_show_msg( pp, "error reading member header" ); retval = 1; }
+      break;
       }
     if( !Fh_verify_magic( header ) )
       {
@@ -513,10 +514,10 @@ static int decompress( const int infd, struct Pretty_print * const pp,
                  format_num( Fh_get_dictionary_size( header ), 9999, 0 ) );
       }
     struct LZ_decoder decoder;
-    LZd_init( &decoder, header, &ibuf, outfd );
+    LZd_init( &decoder, header, &rdec, outfd );
 
     const int result = LZd_decode_member( &decoder, pp );
-    partial_file_pos += LZd_member_position( &decoder );
+    partial_file_pos += Rd_member_position( &rdec );
     LZd_free( &decoder );
     if( result != 0 )
       {
@@ -535,7 +536,7 @@ static int decompress( const int infd, struct Pretty_print * const pp,
       { if( testing ) fprintf( stderr, "ok\n" );
         else fprintf( stderr, "done\n" ); }
     }
-  Ib_free( &ibuf );
+  Rd_free( &rdec );
   return retval;
   }
 
@@ -683,6 +684,7 @@ int main( const int argc, const char * const argv[] )
   // to the corresponding LZMA compression modes.
   const struct Lzma_options option_mapping[] =
     {
+    { 1 << 16,   5 },		// -0
     { 1 << 20,  10 },		// -1
     { 3 << 19,  12 },		// -2
     { 1 << 21,  17 },		// -3
@@ -692,7 +694,7 @@ int main( const int argc, const char * const argv[] )
     { 1 << 24, 108 },		// -7
     { 3 << 23, 163 },		// -8
     { 1 << 25, 273 } };		// -9
-  struct Lzma_options encoder_options = option_mapping[5];	// default = "-6"
+  struct Lzma_options encoder_options = option_mapping[6];	// default = "-6"
   long long member_size = LLONG_MAX;
   long long volume_size = LLONG_MAX;
   int infd = -1;
@@ -709,6 +711,7 @@ int main( const int argc, const char * const argv[] )
 
   const struct ap_Option options[] =
     {
+    { '0',  0,                ap_no  },
     { '1', "fast",            ap_no  },
     { '2',  0,                ap_no  },
     { '3',  0,                ap_no  },
@@ -721,6 +724,7 @@ int main( const int argc, const char * const argv[] )
     { 'b', "member-size",     ap_yes },
     { 'c', "stdout",          ap_no  },
     { 'd', "decompress",      ap_no  },
+    { 'e', "extreme",         ap_no  },
     { 'f', "force",           ap_no  },
     { 'h', "help",            ap_no  },
     { 'k', "keep",            ap_no  },
@@ -736,9 +740,9 @@ int main( const int argc, const char * const argv[] )
 
   struct Arg_parser parser;
   if( !ap_init( &parser, argc, argv, options, 0 ) )
-    { show_error( "Memory exhausted", 0, 0 ); return 1; }
+    { show_error( "memory exhausted", 0, false ); return 1; }
   if( ap_error( &parser ) )				// bad option
-    { show_error( ap_error( &parser ), 0, 1 ); return 1; }
+    { show_error( ap_error( &parser ), 0, true ); return 1; }
 
   int argind = 0;
   for( ; argind < ap_arguments( &parser ); ++argind )
@@ -748,13 +752,13 @@ int main( const int argc, const char * const argv[] )
     if( !code ) break;					// no more options
     switch( code )
       {
-      case '1': case '2': case '3':
-      case '4': case '5': case '6':
-      case '7': case '8': case '9':
-                encoder_options = option_mapping[code-'1']; break;
+      case '0': case '1': case '2': case '3': case '4':
+      case '5': case '6': case '7': case '8': case '9':
+                encoder_options = option_mapping[code-'0']; break;
       case 'b': member_size = getnum( arg, 0, 100000, LLONG_MAX / 2 ); break;
       case 'c': to_stdout = true; break;
       case 'd': program_mode = m_decompress; break;
+      case 'e': break;				// ignored by now
       case 'f': force = true; break;
       case 'h': show_help(); return 0;
       case 'k': keep_input_files = true; break;
diff --git a/testsuite/check.sh b/testsuite/check.sh
index a57224d..17146bc 100755
--- a/testsuite/check.sh
+++ b/testsuite/check.sh
@@ -28,7 +28,7 @@ fail=0
 "${LZIP}" -cd "${testdir}"/test1.lz > copy || fail=1
 cmp in copy || fail=1
 
-for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
+for i in s4Ki 0 1 2 3 4 5 6 7 8 9 ; do
 	"${LZIP}" -k -$i in || fail=1
 	mv -f in.lz copy.lz || fail=1
 	printf "garbage" >> copy.lz || fail=1
@@ -37,7 +37,7 @@ for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
 	printf .
 done
 
-for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
+for i in s4Ki 0 1 2 3 4 5 6 7 8 9 ; do
 	"${LZIP}" -c -$i in > out || fail=1
 	printf "g" >> out || fail=1
 	"${LZIP}" -cd out > copy || fail=1
@@ -45,15 +45,15 @@ for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
 	printf .
 done
 
-for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
+for i in s4Ki 0 1 2 3 4 5 6 7 8 9 ; do
 	"${LZIP}" -$i < in > out || fail=1
 	"${LZIP}" -d < out > copy || fail=1
 	cmp in copy || fail=1
 	printf .
 done
 
-for i in s4Ki 1 2 3 4 5 6 7 8 9 ; do
-	"${LZIP}" -f -$i -o out < in || fail=1
+for i in s4Ki 0 1 2 3 4 5 6 7 8 9 ; do
+	"${LZIP}" -fe -$i -o out < in || fail=1
 	"${LZIP}" -df -o copy < out.lz || fail=1
 	cmp in copy || fail=1
 	printf .