seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_lzdecomp.cpp

@@ -0,0 +1,1586 @@
+// File: lzham_lzdecomp.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+//
+// See "Coroutines in C":
+// http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
+// Also see "Protothreads - Lightweight, Stackless Threads in C":
+// http://www.sics.se/~adam/pt/
+#include "lzham_core.h"
+#include "lzham_decomp.h"
+#include "lzham_symbol_codec.h"
+#include "lzham_checksum.h"
+#include "lzham_lzdecompbase.h"
+
+using namespace lzham;
+
+// We currently only really need ~35K, adding a few K as a fudge factor.
+#define LZHAM_DECOMP_MEMORY_ARENA_SIZE (38*1024)
+
+namespace lzham
+{
+   static const uint8 s_literal_next_state[24] =
+   {
+      0, 0, 0, 0, 1, 2, 3, // 0-6: literal states
+      4, 5, 6, 4, 5,       // 7-11: match states
+      7, 7, 7, 7, 7, 7, 7, 10, 10, 10, 10, 10   // 12-23: unused
+   };
+   
+   static const uint s_huge_match_base_len[4] = { CLZDecompBase::cMaxMatchLen + 1, CLZDecompBase::cMaxMatchLen + 1 + 256, CLZDecompBase::cMaxMatchLen + 1 + 256 + 1024, CLZDecompBase::cMaxMatchLen + 1 + 256 + 1024 + 4096 };
+   static const uint8 s_huge_match_code_len[4] = { 8, 10, 12, 16 };
+
+   struct lzham_decompressor
+   {
+      lzham_decompressor(lzham_malloc_context malloc_context) : 
+         m_malloc_context(malloc_context),
+         m_codec(malloc_context),
+         m_lit_table(malloc_context),
+         m_delta_lit_table(malloc_context),
+         m_main_table(malloc_context),
+         m_dist_lsb_table(malloc_context)
+      {
+         for (uint i = 0; i < 2; i++)
+         {
+            m_rep_len_table[i].set_malloc_context(malloc_context);
+            m_large_len_table[i].set_malloc_context(malloc_context);
+         }
+      }
+
+      void init();
+      
+      template<bool unbuffered> lzham_decompress_status_t decompress();
+      
+      void reset_huff_tables();
+      void reset_arith_tables();
+      void reset_all_tables();
+      void reset_huffman_table_update_rates();
+
+      lzham_malloc_context m_malloc_context;
+
+      int m_state;
+
+      CLZDecompBase m_lzBase;
+      symbol_codec m_codec;
+
+      uint32 m_raw_decomp_buf_size;
+      uint8 *m_pRaw_decomp_buf;
+      uint8 *m_pDecomp_buf;
+      uint32 m_decomp_adler32;
+
+      const uint8 *m_pIn_buf;
+      size_t *m_pIn_buf_size;
+      uint8 *m_pOut_buf;
+      size_t *m_pOut_buf_size;
+      bool m_no_more_input_bytes_flag;
+
+      uint8 *m_pOrig_out_buf;
+      size_t m_orig_out_buf_size;
+
+      lzham_decompress_params m_params;
+
+      lzham_decompress_status_t m_status;
+                              
+      quasi_adaptive_huffman_data_model m_lit_table;
+      quasi_adaptive_huffman_data_model m_delta_lit_table;
+      quasi_adaptive_huffman_data_model m_main_table;
+      quasi_adaptive_huffman_data_model m_rep_len_table[2];
+      quasi_adaptive_huffman_data_model m_large_len_table[2];
+      quasi_adaptive_huffman_data_model m_dist_lsb_table;
+
+      adaptive_bit_model m_is_match_model[CLZDecompBase::cNumStates];
+      adaptive_bit_model m_is_rep_model[CLZDecompBase::cNumStates];
+      adaptive_bit_model m_is_rep0_model[CLZDecompBase::cNumStates];
+      adaptive_bit_model m_is_rep0_single_byte_model[CLZDecompBase::cNumStates];
+      adaptive_bit_model m_is_rep1_model[CLZDecompBase::cNumStates];
+      adaptive_bit_model m_is_rep2_model[CLZDecompBase::cNumStates];
+      
+      uint m_dst_ofs;
+      uint m_dst_highwater_ofs;
+
+      uint m_step;
+      uint m_block_step;
+      uint m_initial_step;
+
+      uint m_block_index;
+
+      int m_match_hist0;
+      int m_match_hist1;
+      int m_match_hist2;
+      int m_match_hist3;
+      uint m_cur_state;
+
+      uint m_start_block_dst_ofs;
+            
+      uint m_block_type;
+
+      const uint8 *m_pFlush_src;
+      size_t m_flush_num_bytes_remaining;
+      size_t m_flush_n;
+
+      uint m_seed_bytes_to_ignore_when_flushing;
+
+      uint m_file_src_file_adler32;
+
+      uint m_rep_lit0;
+      uint m_match_len;
+      uint m_match_slot;
+      uint m_extra_bits;
+      uint m_num_extra_bits;
+
+      uint m_src_ofs;
+      const uint8* m_pCopy_src;
+      uint m_num_raw_bytes_remaining;
+
+      uint m_debug_is_match;
+      uint m_debug_match_len;
+      uint m_debug_match_dist;
+      uint m_debug_lit;
+
+      lzham_decompress_status_t m_z_last_status;
+      uint m_z_first_call;
+      uint m_z_has_flushed;
+      uint m_z_cmf;
+      uint m_z_flg;
+      uint m_z_dict_adler32;
+
+      uint m_tmp;
+   };
+
+   // Ordinarily I dislike macros like this, but in this case I think using them makes the decompression function easier to follow.
+
+   // Coroutine helpers.
+   #define LZHAM_CR_INITIAL_STATE 0
+   #define LZHAM_CR_BEGIN(state) switch( state ) { case LZHAM_CR_INITIAL_STATE:
+   #define LZHAM_CR_RETURN(state, result) do { state = __LINE__; return (result); case __LINE__:; } while (0)
+   #define LZHAM_CR_FINISH }
+
+   // Helpers to save/restore local variables (hopefully CPU registers) to memory.
+   #define LZHAM_RESTORE_STATE LZHAM_RESTORE_LOCAL_STATE \
+      match_hist0 = m_match_hist0; match_hist1 = m_match_hist1; match_hist2 = m_match_hist2; match_hist3 = m_match_hist3; \
+      cur_state = m_cur_state; dst_ofs = m_dst_ofs;
+      
+   #define LZHAM_SAVE_STATE LZHAM_SAVE_LOCAL_STATE \
+      m_match_hist0 = match_hist0; m_match_hist1 = match_hist1; m_match_hist2 = match_hist2; m_match_hist3 = match_hist3; \
+      m_cur_state = cur_state; m_dst_ofs = dst_ofs;
+      
+   // Helper that coroutine returns to the caller with a request for more input bytes.
+   #define LZHAM_DECODE_NEEDS_BYTES \
+      LZHAM_SAVE_STATE \
+      for ( ; ; ) \
+      { \
+         *m_pIn_buf_size = static_cast<size_t>(m_codec.decode_get_bytes_consumed()); \
+         *m_pOut_buf_size = 0; \
+         LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT); \
+         m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); \
+         if ((m_codec.m_decode_buf_eof) || (m_codec.m_decode_buf_size)) break; \
+      } \
+      LZHAM_RESTORE_STATE
+
+   #if LZHAM_PLATFORM_X360
+      #define LZHAM_BULK_MEMCPY XMemCpy
+      #define LZHAM_MEMCPY memcpy
+   #else
+      #define LZHAM_BULK_MEMCPY memcpy
+      #define LZHAM_MEMCPY memcpy
+   #endif
+
+   // Flush the output buffer/dictionary by doing a coroutine return to the caller.
+   // Buffered mode only.
+   #define LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dict_ofs) \
+      LZHAM_SAVE_STATE \
+      m_pFlush_src = m_pDecomp_buf + m_seed_bytes_to_ignore_when_flushing + m_dst_highwater_ofs; \
+      m_flush_num_bytes_remaining = dict_ofs - m_seed_bytes_to_ignore_when_flushing - m_dst_highwater_ofs; \
+      m_seed_bytes_to_ignore_when_flushing = 0; \
+      m_dst_highwater_ofs = dict_ofs & dict_size_mask; \
+      while (m_flush_num_bytes_remaining) \
+      { \
+         m_flush_n = LZHAM_MIN(m_flush_num_bytes_remaining, *m_pOut_buf_size); \
+         if (0 == (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_COMPUTE_ADLER32)) \
+         { \
+            LZHAM_BULK_MEMCPY(m_pOut_buf, m_pFlush_src, m_flush_n); \
+         } \
+         else \
+         { \
+            size_t copy_ofs = 0; \
+            while (copy_ofs < m_flush_n) \
+            { \
+               const uint cBytesToMemCpyPerIteration = 8192U; \
+               size_t bytes_to_copy = LZHAM_MIN((size_t)(m_flush_n - copy_ofs), cBytesToMemCpyPerIteration); \
+               LZHAM_MEMCPY(m_pOut_buf + copy_ofs, m_pFlush_src + copy_ofs, bytes_to_copy); \
+               m_decomp_adler32 = adler32(m_pFlush_src + copy_ofs, bytes_to_copy, m_decomp_adler32); \
+               copy_ofs += bytes_to_copy; \
+            } \
+         } \
+         *m_pIn_buf_size = static_cast<size_t>(m_codec.decode_get_bytes_consumed()); \
+         *m_pOut_buf_size = m_flush_n; \
+         LZHAM_CR_RETURN(m_state, m_flush_n ? LZHAM_DECOMP_STATUS_NOT_FINISHED : LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT); \
+         m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag); \
+         m_pFlush_src += m_flush_n; \
+         m_flush_num_bytes_remaining -= m_flush_n; \
+      } \
+      LZHAM_RESTORE_STATE
+
+   #define LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, result, model) LZHAM_SYMBOL_CODEC_DECODE_ADAPTIVE_HUFFMAN(codec, result, model)
+   
+   //------------------------------------------------------------------------------------------------------------------
+   void lzham_decompressor::init()
+   {
+      m_lzBase.init_position_slots(m_params.m_dict_size_log2);
+
+#ifdef LZHAM_LZDEBUG
+      if (m_pDecomp_buf)
+         memset(m_pDecomp_buf, 0xCE, 1U << m_params.m_dict_size_log2);
+#endif
+
+      m_state = LZHAM_CR_INITIAL_STATE;
+      m_step = 0;
+      m_block_step = 0;
+      m_block_index = 0;
+      m_initial_step = 0;
+            
+      m_dst_ofs = 0;
+      m_dst_highwater_ofs = 0;
+
+      m_pIn_buf = NULL;
+      m_pIn_buf_size = NULL;
+      m_pOut_buf = NULL;
+      m_pOut_buf_size = NULL;
+      m_no_more_input_bytes_flag = false;
+      m_status = LZHAM_DECOMP_STATUS_NOT_FINISHED;
+      m_pOrig_out_buf = NULL;
+      m_orig_out_buf_size = 0;
+      m_decomp_adler32 = cInitAdler32;
+      m_seed_bytes_to_ignore_when_flushing = 0;
+      
+      m_z_last_status = LZHAM_DECOMP_STATUS_NOT_FINISHED;
+      m_z_first_call = 1;
+      m_z_has_flushed = 0;
+      m_z_cmf = 0;
+      m_z_flg = 0;
+      m_z_dict_adler32 = 0;
+
+      m_tmp = 0;
+
+      m_match_hist0 = 0;
+      m_match_hist1 = 0;
+      m_match_hist2 = 0;
+      m_match_hist3 = 0;
+      m_cur_state = 0;
+      
+      m_start_block_dst_ofs = 0;
+      m_block_type = 0;
+      m_flush_num_bytes_remaining = 0;
+      m_flush_n = 0;
+      m_file_src_file_adler32 = 0;
+      m_rep_lit0 = 0;
+      m_match_len = 0;
+      m_match_slot = 0;
+      m_extra_bits = 0;
+      m_num_extra_bits = 0;
+      m_src_ofs = 0;
+      m_pCopy_src = NULL;
+      m_num_raw_bytes_remaining = 0;
+      
+      m_codec.clear();
+   }
+
+   void lzham_decompressor::reset_huff_tables()
+   {
+      m_lit_table.reset();
+     m_delta_lit_table.reset();
+      
+      m_main_table.reset();
+
+      for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_rep_len_table); i++)
+         m_rep_len_table[i].reset();
+
+      for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_large_len_table); i++)
+         m_large_len_table[i].reset();
+
+      m_dist_lsb_table.reset();
+   }
+
+   void lzham_decompressor::reset_arith_tables()
+   {
+      for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_is_match_model); i++)
+         m_is_match_model[i].clear();
+
+      for (uint i = 0; i < CLZDecompBase::cNumStates; i++)
+      {
+         m_is_rep_model[i].clear();
+         m_is_rep0_model[i].clear();
+         m_is_rep0_single_byte_model[i].clear();
+         m_is_rep1_model[i].clear();
+         m_is_rep2_model[i].clear();
+      }
+   }
+
+   void lzham_decompressor::reset_all_tables()
+   {
+      reset_huff_tables();
+
+      reset_arith_tables();
+   }
+
+   void lzham_decompressor::reset_huffman_table_update_rates()
+   {
+      m_lit_table.reset_update_rate();
+      m_delta_lit_table.reset_update_rate();
+
+      m_main_table.reset_update_rate();
+
+      for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_rep_len_table); i++)
+         m_rep_len_table[i].reset_update_rate();
+
+      for (uint i = 0; i < LZHAM_ARRAY_SIZE(m_large_len_table); i++)
+         m_large_len_table[i].reset_update_rate();
+
+      m_dist_lsb_table.reset_update_rate();
+   }
+      
+   //------------------------------------------------------------------------------------------------------------------
+   // Decompression method. Implemented as a coroutine so it can be paused and resumed to support streaming.
+   //------------------------------------------------------------------------------------------------------------------
+   template<bool unbuffered>
+   lzham_decompress_status_t lzham_decompressor::decompress()
+   {
+      // Important: This function is a coroutine. ANY locals variables that need to be preserved across coroutine
+      // returns must be either be a member variable, or a local which is saved/restored to a member variable at
+      // the right times. (This makes this function difficult to follow and freaking ugly due to the macros of doom - but hey it works.)
+      // The most often used variables are in locals so the compiler hopefully puts them into CPU registers.
+      symbol_codec &codec = m_codec;
+      const uint dict_size = 1U << m_params.m_dict_size_log2;
+      const uint dict_size_mask = unbuffered ? UINT_MAX : (dict_size - 1);
+
+      int match_hist0 = 0, match_hist1 = 0, match_hist2 = 0, match_hist3 = 0;
+      uint cur_state = 0, dst_ofs = 0;
+      
+      const size_t out_buf_size = *m_pOut_buf_size;
+      
+      uint8* pDst = unbuffered ? reinterpret_cast<uint8*>(m_pOut_buf) : reinterpret_cast<uint8*>(m_pDecomp_buf);
+      uint8* pDst_end = unbuffered ?  (reinterpret_cast<uint8*>(m_pOut_buf) + out_buf_size) : (reinterpret_cast<uint8*>(m_pDecomp_buf) + dict_size);      
+      
+      LZHAM_SYMBOL_CODEC_DECODE_DECLARE(codec);
+
+#define LZHAM_SAVE_LOCAL_STATE
+#define LZHAM_RESTORE_LOCAL_STATE
+
+      // Important: Do not use any switch() statements below here.
+      LZHAM_CR_BEGIN(m_state)
+
+      if ((!unbuffered) && (m_params.m_num_seed_bytes))
+      {
+         LZHAM_BULK_MEMCPY(pDst, m_params.m_pSeed_bytes, m_params.m_num_seed_bytes);
+         dst_ofs += m_params.m_num_seed_bytes;
+         if (dst_ofs >= dict_size)
+            dst_ofs = 0;
+         else
+            m_seed_bytes_to_ignore_when_flushing = dst_ofs;
+      }
+      
+      if (!m_codec.start_decoding(m_pIn_buf, *m_pIn_buf_size, m_no_more_input_bytes_flag, NULL, NULL))
+      {
+         LZHAM_LOG_ERROR(1020);
+         return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING;
+      }
+
+      LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+
+      {
+         if (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM)
+         {
+            uint check;
+            LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_z_cmf, 8);
+            LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_z_flg, 8);
+            check = ((m_z_cmf << 8) + m_z_flg) % 31;
+            if ((check != 0) || ((m_z_cmf & 15) != LZHAM_Z_LZHAM))
+            {
+               LZHAM_LOG_ERROR(1021);
+               return LZHAM_DECOMP_STATUS_FAILED_BAD_ZLIB_HEADER;
+            }
+            if (m_z_flg & 32)
+            {
+               if ((!m_params.m_pSeed_bytes) || (unbuffered))
+               {
+                  LZHAM_LOG_ERROR(1022);
+                  return LZHAM_DECOMP_STATUS_FAILED_NEED_SEED_BYTES;
+               }
+               m_z_dict_adler32 = 0;
+               for (m_tmp = 0; m_tmp < 4; ++m_tmp)
+               {
+                  uint n; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 8);
+                  m_z_dict_adler32 = (m_z_dict_adler32 << 8) | n;
+               }
+               if (adler32(m_params.m_pSeed_bytes, m_params.m_num_seed_bytes) != m_z_dict_adler32)
+               {
+                  LZHAM_LOG_ERROR(1023);
+                  return LZHAM_DECOMP_STATUS_FAILED_BAD_SEED_BYTES;
+               }
+            }
+         }
+
+         {
+            // Was written by lzcompressor::send_configuration().
+            //uint tmp;
+            //LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, tmp, 2);
+         }
+
+         uint max_update_interval = m_params.m_table_max_update_interval, update_interval_slow_rate =  m_params.m_table_update_interval_slow_rate;
+         if (!max_update_interval && !update_interval_slow_rate)
+         {
+            uint rate = m_params.m_table_update_rate;
+            if (!rate)
+               rate = LZHAM_DEFAULT_TABLE_UPDATE_RATE;
+            rate = math::clamp<uint>(rate, 1, LZHAM_FASTEST_TABLE_UPDATE_RATE) - 1;
+            max_update_interval = g_table_update_settings[rate].m_max_update_interval;
+            update_interval_slow_rate = g_table_update_settings[rate].m_slow_rate;
+         }
+
+         bool succeeded = m_lit_table.init2(m_malloc_context, false, 256, max_update_interval, update_interval_slow_rate, NULL);
+         succeeded = succeeded && m_delta_lit_table.assign(m_lit_table);
+         
+         succeeded = succeeded && m_main_table.init2(m_malloc_context, false, CLZDecompBase::cLZXNumSpecialLengths + (m_lzBase.m_num_lzx_slots - CLZDecompBase::cLZXLowestUsableMatchSlot) * 8, max_update_interval, update_interval_slow_rate, NULL);
+
+         succeeded = succeeded && m_rep_len_table[0].init2(m_malloc_context, false, CLZDecompBase::cNumHugeMatchCodes + (CLZDecompBase::cMaxMatchLen - CLZDecompBase::cMinMatchLen + 1), max_update_interval, update_interval_slow_rate, NULL);
+         succeeded = succeeded && m_rep_len_table[1].assign(m_rep_len_table[0]);
+
+         succeeded = succeeded && m_large_len_table[0].init2(m_malloc_context, false, CLZDecompBase::cNumHugeMatchCodes + CLZDecompBase::cLZXNumSecondaryLengths, max_update_interval, update_interval_slow_rate, NULL);
+         succeeded = succeeded && m_large_len_table[1].assign(m_large_len_table[0]);
+
+         succeeded = succeeded && m_dist_lsb_table.init2(m_malloc_context, false, 16, max_update_interval, update_interval_slow_rate, NULL);
+         if (!succeeded)
+         {
+            LZHAM_LOG_ERROR(1024);
+            return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING;
+         }
+      }
+      
+      // Output block loop.
+      do
+      {
+#ifdef LZHAM_LZDEBUG
+         uint outer_sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, 12);
+         LZHAM_VERIFY(outer_sync_marker == 166);
+#endif
+         
+         // Decode block type.
+         LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_block_type, CLZDecompBase::cBlockHeaderBits);
+
+         if (m_block_type == CLZDecompBase::cSyncBlock)
+         {
+            // Sync block
+            // Reset either the symbol table update rates, or all statistics, then force a coroutine return to give the caller a chance to handle the output right now.
+            LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_tmp, CLZDecompBase::cBlockFlushTypeBits);
+
+            // See lzcompressor::send_sync_block() (TODO: make these an enum)
+            if (m_tmp == 1)
+               reset_huffman_table_update_rates();
+            else if (m_tmp == 2)
+               reset_all_tables();
+
+            LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec);
+
+            uint n; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 16);
+            if (n != 0)
+            {
+               LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+               *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+               *m_pOut_buf_size = 0;
+               for ( ; ; ) { LZHAM_LOG_ERROR(1025); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_SYNC_BLOCK); }
+            }
+
+            LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, n, 16);
+            if (n != 0xFFFF)
+            {
+               LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+               *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+               *m_pOut_buf_size = 0;
+               for ( ; ; ) { LZHAM_LOG_ERROR(1026); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_SYNC_BLOCK); }
+            }
+            
+            // See lzcompressor::send_sync_block() (TODO: make these an enum)            
+            if ((m_tmp == 2) || (m_tmp == 3))
+            {
+               // It's a sync or full flush, so immediately give caller whatever output we have. Also gives the caller a chance to reposition the input stream ptr somewhere else before continuing.
+               LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+
+               if ((!unbuffered) && (dst_ofs))
+               {
+                  LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dst_ofs);
+               }
+               else
+               {
+                  if (unbuffered)
+                  {
+                     LZHAM_ASSERT(dst_ofs >= m_dst_highwater_ofs);
+                  }
+                  else
+                  {
+                     LZHAM_ASSERT(!m_dst_highwater_ofs);
+                  }
+                  
+                  // unbuffered, or dst_ofs==0
+                  *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+                  *m_pOut_buf_size = dst_ofs - m_dst_highwater_ofs;
+                  
+                  // Partial/sync flushes in unbuffered mode details:
+                  // We assume the caller doesn't move the output buffer between calls AND the pointer to the output buffer input parameter won't change between calls (i.e.
+                  // it *always* points to the beginning of the decompressed stream). The caller will need to track the current output buffer offset.
+                  m_dst_highwater_ofs = dst_ofs;
+                  
+                  LZHAM_SAVE_STATE
+                  LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NOT_FINISHED);
+                  LZHAM_RESTORE_STATE
+                  
+                  m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag);
+               }
+               
+               LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+            }
+         }
+         else if (m_block_type == CLZDecompBase::cRawBlock)
+         {
+            // Raw block handling is complex because we ultimately want to (safely) handle as many bytes as possible using a small number of memcpy()'s.
+            uint num_raw_bytes_remaining;
+            num_raw_bytes_remaining = 0;
+            
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_num_raw_bytes_remaining = num_raw_bytes_remaining;
+#define LZHAM_RESTORE_LOCAL_STATE num_raw_bytes_remaining = m_num_raw_bytes_remaining;
+
+            // Determine how large this raw block is.
+            LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, num_raw_bytes_remaining, 24);
+            
+            // Get and verify raw block length check bits.
+            uint num_raw_bytes_check_bits; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, num_raw_bytes_check_bits, 8);
+            uint raw_bytes_remaining0, raw_bytes_remaining1, raw_bytes_remaining2;
+            raw_bytes_remaining0 = num_raw_bytes_remaining & 0xFF;
+            raw_bytes_remaining1 = (num_raw_bytes_remaining >> 8) & 0xFF;
+            raw_bytes_remaining2 = (num_raw_bytes_remaining >> 16) & 0xFF;
+            if (num_raw_bytes_check_bits != ((raw_bytes_remaining0 ^ raw_bytes_remaining1) ^ raw_bytes_remaining2))
+            {
+               LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+               *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+               *m_pOut_buf_size = 0;
+               for ( ; ; ) { LZHAM_LOG_ERROR(1027); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_RAW_BLOCK); }
+            }
+            
+            num_raw_bytes_remaining++;
+            
+            // Discard any partial bytes from the bit buffer (align up to the next byte).
+            LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec);
+            
+            // Flush any full bytes from the bit buffer.
+            do
+            {
+               int b;
+               LZHAM_SYMBOL_CODEC_DECODE_REMOVE_BYTE_FROM_BIT_BUF(codec, b);
+               if (b < 0)
+                  break;
+
+               if ((unbuffered) && (dst_ofs >= out_buf_size))
+               {
+                  LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                  *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+                  *m_pOut_buf_size = 0;
+                  for ( ; ; ) { LZHAM_LOG_ERROR(1028); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); }
+               }
+
+               pDst[dst_ofs++] = static_cast<uint8>(b);
+
+               if ((!unbuffered) && (dst_ofs > dict_size_mask))
+               {
+                  LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                  LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dict_size);
+                  LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+                  dst_ofs = 0;
+               }
+
+               num_raw_bytes_remaining--;
+            } while (num_raw_bytes_remaining);
+
+            LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+
+            // Now handle the bulk of the raw data with memcpy().
+            while (num_raw_bytes_remaining)
+            {
+               uint64 in_buf_ofs, in_buf_remaining;
+               in_buf_ofs = codec.decode_get_bytes_consumed();
+               in_buf_remaining = *m_pIn_buf_size - in_buf_ofs;
+
+               while (!in_buf_remaining)
+               {
+                  // We need more bytes from the caller.
+                  *m_pIn_buf_size = static_cast<size_t>(in_buf_ofs);
+                  *m_pOut_buf_size = 0;
+
+                  if (m_no_more_input_bytes_flag)
+                  {
+                     for ( ; ; ) { LZHAM_LOG_ERROR(1029); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_EXPECTED_MORE_RAW_BYTES); }
+                  }
+
+                  LZHAM_SAVE_STATE
+                  LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT);
+                  LZHAM_RESTORE_STATE
+
+                  m_codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf, m_no_more_input_bytes_flag);
+
+                  in_buf_ofs = 0;
+                  in_buf_remaining = *m_pIn_buf_size;
+               }
+
+               // Determine how many bytes we can safely memcpy() in a single call.
+               uint num_bytes_to_copy;
+               num_bytes_to_copy = static_cast<uint>(LZHAM_MIN(num_raw_bytes_remaining, in_buf_remaining));
+               if (!unbuffered)
+                  num_bytes_to_copy = LZHAM_MIN(num_bytes_to_copy, dict_size - dst_ofs);
+
+               if ((unbuffered) && ((dst_ofs + num_bytes_to_copy) > out_buf_size))
+               {
+                  // Output buffer is not large enough.
+                  *m_pIn_buf_size = static_cast<size_t>(in_buf_ofs);
+                  *m_pOut_buf_size = 0;
+                  for ( ; ; ) { LZHAM_LOG_ERROR(1030); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); }
+               }
+
+               // Copy the raw bytes.
+               LZHAM_BULK_MEMCPY(pDst + dst_ofs, m_pIn_buf + in_buf_ofs, num_bytes_to_copy);
+
+               in_buf_ofs += num_bytes_to_copy;
+               num_raw_bytes_remaining -= num_bytes_to_copy;
+
+               codec.decode_set_input_buffer(m_pIn_buf, *m_pIn_buf_size, m_pIn_buf + in_buf_ofs, m_no_more_input_bytes_flag);
+
+               dst_ofs += num_bytes_to_copy;
+
+               if ((!unbuffered) && (dst_ofs > dict_size_mask))
+               {
+                  LZHAM_ASSERT(dst_ofs == dict_size);
+
+                  LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dict_size);
+
+                  dst_ofs = 0;
+               }
+            }
+
+            LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE
+#define LZHAM_RESTORE_LOCAL_STATE
+         }
+         else if (m_block_type == CLZDecompBase::cCompBlock)
+         {
+            LZHAM_SYMBOL_CODEC_DECODE_ARITH_START(codec)
+
+            match_hist0 = 1;
+            match_hist1 = 1;
+            match_hist2 = 1;
+            match_hist3 = 1;
+            cur_state = 0;
+                        
+            m_start_block_dst_ofs = dst_ofs;
+
+            {
+               uint block_flush_type; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, block_flush_type, CLZDecompBase::cBlockFlushTypeBits);
+               if (block_flush_type == 1)
+                  reset_huffman_table_update_rates();
+               else if (block_flush_type == 2)
+                  reset_all_tables();
+            }
+
+#ifdef LZHAM_LZDEBUG
+            m_initial_step = m_step;
+            m_block_step = 0;
+            for ( ; ; m_step++, m_block_step++)
+#else
+            for ( ; ; )
+#endif
+            {
+#ifdef LZHAM_LZDEBUG
+               uint sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, x, CLZDecompBase::cLZHAMDebugSyncMarkerBits);
+               LZHAM_VERIFY(sync_marker == CLZDecompBase::cLZHAMDebugSyncMarkerValue);
+
+               LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_is_match, 1);
+               LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_match_len, 17);
+
+               uint debug_cur_state; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, debug_cur_state, 4);
+               LZHAM_VERIFY(cur_state == debug_cur_state);
+#endif
+
+               // Read "is match" bit.
+               uint match_model_index;
+               match_model_index = LZHAM_IS_MATCH_MODEL_INDEX(cur_state);
+               LZHAM_ASSERT(match_model_index < LZHAM_ARRAY_SIZE(m_is_match_model));
+
+               uint is_match_bit; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_match_bit, m_is_match_model[match_model_index]);
+
+#ifdef LZHAM_LZDEBUG
+               LZHAM_VERIFY(is_match_bit == m_debug_is_match);
+#endif
+
+               if (LZHAM_BUILTIN_EXPECT(!is_match_bit, 0))
+               {
+                  // Handle literal.
+
+#ifdef LZHAM_LZDEBUG
+                  LZHAM_VERIFY(m_debug_match_len == 1);
+#endif
+
+#ifdef LZHAM_LZDEBUG
+                  LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_lit, 8);
+#endif
+                  
+                  if ((unbuffered) && (LZHAM_BUILTIN_EXPECT(dst_ofs >= out_buf_size, 0)))
+                  {
+                     LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                     *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+                     *m_pOut_buf_size = 0;
+                     for ( ; ; ) { LZHAM_LOG_ERROR(1031); LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_DEST_BUF_TOO_SMALL); }
+                  }
+
+                  if (LZHAM_BUILTIN_EXPECT(cur_state < CLZDecompBase::cNumLitStates, 1))
+                  {
+                     // Regular literal
+                     uint r; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, r, m_lit_table);
+                     pDst[dst_ofs] = static_cast<uint8>(r);
+
+#ifdef LZHAM_LZDEBUG
+                     LZHAM_VERIFY(pDst[dst_ofs] == m_debug_lit);
+#endif
+                  }
+                  else
+                  {
+                     // Delta literal
+                     uint match_hist0_ofs, rep_lit0;
+
+                     // Determine delta literal's partial context.
+                     match_hist0_ofs = dst_ofs - match_hist0;
+                     rep_lit0 = pDst[match_hist0_ofs & dict_size_mask];
+                                          
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_rep_lit0 = rep_lit0;
+#define LZHAM_RESTORE_LOCAL_STATE rep_lit0 = m_rep_lit0;
+
+#ifdef LZHAM_LZDEBUG
+                     uint debug_rep_lit0; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, debug_rep_lit0, 8);
+                     LZHAM_VERIFY(debug_rep_lit0 == rep_lit0);
+#endif
+
+                     uint r; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, r, m_delta_lit_table);
+                     r ^= rep_lit0;
+                     pDst[dst_ofs] = static_cast<uint8>(r);
+
+#ifdef LZHAM_LZDEBUG
+                     LZHAM_VERIFY(pDst[dst_ofs] == m_debug_lit);
+#endif
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE
+#define LZHAM_RESTORE_LOCAL_STATE
+                  }
+
+                  cur_state = s_literal_next_state[cur_state];
+
+                  dst_ofs++;
+                  if ((!unbuffered) && (LZHAM_BUILTIN_EXPECT(dst_ofs > dict_size_mask, 0)))
+                  {
+                     LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                     LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dict_size);
+                     LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+                     dst_ofs = 0;
+                  }
+               }
+               else
+               {
+                  // Handle match.
+                  uint match_len;
+                  match_len = 1;
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len;
+
+                  // Determine if match is a rep_match, and if so what type.
+                  uint is_rep; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep, m_is_rep_model[cur_state]);
+                  if (LZHAM_BUILTIN_EXPECT(is_rep, 1))
+                  {
+                     uint is_rep0; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep0, m_is_rep0_model[cur_state]);
+                     if (LZHAM_BUILTIN_EXPECT(is_rep0, 1))
+                     {
+                        uint is_rep0_len1; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep0_len1, m_is_rep0_single_byte_model[cur_state]);
+                        if (LZHAM_BUILTIN_EXPECT(is_rep0_len1, 1))
+                        {
+                           cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 9 : 11;
+                        }
+                        else
+                        {
+                           LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, match_len, m_rep_len_table[cur_state >= CLZDecompBase::cNumLitStates]);
+                           match_len += CLZDecompBase::cMinMatchLen;
+                           
+                           if (match_len == (CLZDecompBase::cMaxMatchLen + 1))
+                           {
+                              // Decode "huge" match length.
+                              match_len = 0;
+                              do 
+                              {
+                                 uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); 
+                                 if (!b)
+                                    break;
+                                 match_len++;
+                              } while (match_len < 3);
+                              uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]);
+                              match_len = s_huge_match_base_len[match_len] + k;
+                           }
+
+                           cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 8 : 11;
+                        }
+                     }
+                     else
+                     {
+                        LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, match_len, m_rep_len_table[cur_state >= CLZDecompBase::cNumLitStates]);
+                        match_len += CLZDecompBase::cMinMatchLen;
+                        
+                        if (match_len == (CLZDecompBase::cMaxMatchLen + 1))
+                        {
+                           // Decode "huge" match length.
+                           match_len = 0;
+                           do 
+                           {
+                              uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); 
+                              if (!b)
+                                 break;
+                              match_len++;
+                           } while (match_len < 3);
+                           uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]);
+                           match_len = s_huge_match_base_len[match_len] + k;
+                        }
+
+                        uint is_rep1; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep1, m_is_rep1_model[cur_state]);
+                        if (LZHAM_BUILTIN_EXPECT(is_rep1, 1))
+                        {
+                           uint temp = match_hist1;
+                           match_hist1 = match_hist0;
+                           match_hist0 = temp;
+                        }
+                        else
+                        {
+                           uint is_rep2; LZHAM_SYMBOL_CODEC_DECODE_ARITH_BIT(codec, is_rep2, m_is_rep2_model[cur_state]);
+
+                           if (LZHAM_BUILTIN_EXPECT(is_rep2, 1))
+                           {
+                              // rep2
+                              uint temp = match_hist2;
+                              match_hist2 = match_hist1;
+                              match_hist1 = match_hist0;
+                              match_hist0 = temp;
+                           }
+                           else
+                           {
+                              // rep3
+                              uint temp = match_hist3;
+                              match_hist3 = match_hist2;
+                              match_hist2 = match_hist1;
+                              match_hist1 = match_hist0;
+                              match_hist0 = temp;
+                           }
+                        }
+
+                        cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? 8 : 11;
+                     }
+                  }
+                  else
+                  {
+                     // Handle normal/full match.
+                     uint sym; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, sym, m_main_table);
+                     sym -= CLZDecompBase::cLZXNumSpecialLengths;
+
+                     if (LZHAM_BUILTIN_EXPECT(static_cast<int>(sym) < 0, 0))
+                     {
+                        // Handle special symbols.
+                        if (static_cast<int>(sym) == (CLZDecompBase::cLZXSpecialCodeEndOfBlockCode - CLZDecompBase::cLZXNumSpecialLengths))
+                           break;
+                        else
+                        {
+                           // Must be cLZXSpecialCodePartialStateReset.
+                           match_hist0 = 1;
+                           match_hist1 = 1;
+                           match_hist2 = 1;
+                           match_hist3 = 1;
+                           cur_state = 0;
+                           continue;
+                        }
+                     }
+
+                     // Low 3 bits of symbol = match length category, higher bits = distance category.
+                     match_len = (sym & 7) + 2;
+
+                     uint match_slot;
+                     match_slot = (sym >> 3) + CLZDecompBase::cLZXLowestUsableMatchSlot;
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot;
+
+                     if (LZHAM_BUILTIN_EXPECT(match_len == 9, 0))
+                     {
+                        // Match is >= 9 bytes, decode the actual length.
+                        uint e; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, e, m_large_len_table[cur_state >= CLZDecompBase::cNumLitStates]);
+                        match_len += e;
+                        
+                        if (match_len == (CLZDecompBase::cMaxMatchLen + 1))
+                        {
+                           // Decode "huge" match length.
+                           match_len = 0;
+                           do 
+                           {
+                              uint b; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, b, 1); 
+                              if (!b)
+                                 break;
+                              match_len++;
+                           } while (match_len < 3);
+                           uint k; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, k, s_huge_match_code_len[match_len]);
+                           match_len = s_huge_match_base_len[match_len] + k;
+                        }
+                     }
+
+                     uint num_extra_bits;
+                     num_extra_bits = m_lzBase.m_lzx_position_extra_bits[match_slot];
+
+                     uint extra_bits;
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot; m_num_extra_bits = num_extra_bits;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot; num_extra_bits = m_num_extra_bits;
+
+                     if (LZHAM_BUILTIN_EXPECT(num_extra_bits < 3, 0))
+                     {
+                        LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, extra_bits, num_extra_bits);
+                     }
+                     else
+                     {
+                        extra_bits = 0;
+                        if (LZHAM_BUILTIN_EXPECT(num_extra_bits > 4, 1))
+                        {
+                           LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, extra_bits, num_extra_bits - 4);
+                           extra_bits <<= 4;
+                        }
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_match_slot = match_slot; m_extra_bits = extra_bits;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; match_slot = m_match_slot; extra_bits = m_extra_bits;
+
+                        uint j; LZHAM_DECOMPRESS_DECODE_ADAPTIVE_SYMBOL(codec, j, m_dist_lsb_table);
+                        extra_bits += j;
+                     }
+
+                     match_hist3 = match_hist2;
+                     match_hist2 = match_hist1;
+                     match_hist1 = match_hist0;
+                     match_hist0 = m_lzBase.m_lzx_position_base[match_slot] + extra_bits;
+
+                     cur_state = (cur_state < CLZDecompBase::cNumLitStates) ? CLZDecompBase::cNumLitStates : CLZDecompBase::cNumLitStates + 3;
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len;
+                  }
+
+                  // We have the match's length and distance, now do the copy.
+
+#ifdef LZHAM_LZDEBUG
+                  LZHAM_VERIFY(match_len == m_debug_match_len);
+                  LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_debug_match_dist, 25);
+                  uint d; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, d, 4);
+                  m_debug_match_dist = (m_debug_match_dist << 4) | d;
+                  LZHAM_VERIFY((uint)match_hist0 == m_debug_match_dist);
+#endif
+                  if ( (unbuffered) && LZHAM_BUILTIN_EXPECT((((size_t)match_hist0 > dst_ofs) || ((dst_ofs + match_len) > out_buf_size)), 0) )
+                  {
+                     LZHAM_LOG_ERROR(1032);
+                     LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                     *m_pIn_buf_size = static_cast<size_t>(codec.decode_get_bytes_consumed());
+                     *m_pOut_buf_size = 0;
+                     for ( ; ; ) { LZHAM_CR_RETURN(m_state, LZHAM_DECOMP_STATUS_FAILED_BAD_CODE); }
+                  }
+
+                  uint src_ofs;
+                  const uint8* pCopy_src;
+                  src_ofs = (dst_ofs - match_hist0) & dict_size_mask;
+                  pCopy_src = pDst + src_ofs;
+                                    
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE m_match_len = match_len; m_src_ofs = src_ofs; m_pCopy_src = pCopy_src;
+#define LZHAM_RESTORE_LOCAL_STATE match_len = m_match_len; src_ofs = m_src_ofs; pCopy_src = m_pCopy_src;
+
+                  if ( (!unbuffered) && LZHAM_BUILTIN_EXPECT( ((LZHAM_MAX(src_ofs, dst_ofs) + match_len) > dict_size_mask), 0) )
+                  {
+                     // Match source or destination wraps around the end of the dictionary to the beginning, so handle the copy one byte at a time.
+                     do
+                     {
+                        pDst[dst_ofs++] = *pCopy_src++;
+
+                        if (LZHAM_BUILTIN_EXPECT(pCopy_src == pDst_end, 0))
+                           pCopy_src = pDst;
+
+                        if (LZHAM_BUILTIN_EXPECT(dst_ofs > dict_size_mask, 0))
+                        {
+                           LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+                           LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dict_size);
+                           LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+                           dst_ofs = 0;
+                        }
+
+                        match_len--;
+                     } while (LZHAM_BUILTIN_EXPECT(match_len > 0, 1));
+                  }
+                  else
+                  {
+                     uint8* pCopy_dst = pDst + dst_ofs;
+                     if (LZHAM_BUILTIN_EXPECT(match_hist0 == 1, 0))
+                     {
+                        // Handle byte runs.
+                        uint8 c = *pCopy_src;
+                        if (LZHAM_BUILTIN_EXPECT(match_len < 8, 1))
+                        {
+                           for (int i = match_len; i > 0; i--)
+                              *pCopy_dst++ = c;
+                        }
+                        else
+                        {
+                           memset(pCopy_dst, c, match_len);
+                        }
+                     }
+                     else
+                     {
+                        // Handle matches of length 2 or higher.
+                        if (LZHAM_BUILTIN_EXPECT(((match_len < 8) || ((int)match_len > match_hist0)), 1))
+                        {
+                           for (int i = match_len; i > 0; i--)
+                              *pCopy_dst++ = *pCopy_src++;
+                        }
+                        else
+                        {
+                           LZHAM_MEMCPY(pCopy_dst, pCopy_src, match_len);
+                        }
+                     }
+                     dst_ofs += match_len;
+                  }
+               } // lit or match
+
+#undef LZHAM_SAVE_LOCAL_STATE
+#undef LZHAM_RESTORE_LOCAL_STATE
+#define LZHAM_SAVE_LOCAL_STATE
+#define LZHAM_RESTORE_LOCAL_STATE
+            } // for ( ; ; )
+
+#ifdef LZHAM_LZDEBUG
+            uint end_sync_marker; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, end_sync_marker, 12);
+            LZHAM_VERIFY(end_sync_marker == 366);
+#endif
+            LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec);
+         }
+         else if (m_block_type == CLZDecompBase::cEOFBlock)
+         {
+            // Received EOF.
+            m_status = LZHAM_DECOMP_STATUS_SUCCESS;
+         }
+         else
+         {
+            LZHAM_LOG_ERROR(1033);
+            // This block type is currently undefined.
+            m_status = LZHAM_DECOMP_STATUS_FAILED_BAD_CODE;
+         }
+
+         m_block_index++;
+
+      } while (m_status == LZHAM_DECOMP_STATUS_NOT_FINISHED);
+
+      if ((!unbuffered) && (dst_ofs))
+      {
+         LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+         LZHAM_FLUSH_DICT_TO_OUTPUT_BUFFER(dst_ofs);
+         LZHAM_SYMBOL_CODEC_DECODE_BEGIN(codec);
+      }
+
+      if (m_status == LZHAM_DECOMP_STATUS_SUCCESS)
+      {
+         LZHAM_SYMBOL_CODEC_DECODE_ALIGN_TO_BYTE(codec);
+
+         LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, m_file_src_file_adler32, 16);
+         uint l; LZHAM_SYMBOL_CODEC_DECODE_GET_BITS(codec, l, 16);
+         m_file_src_file_adler32 = (m_file_src_file_adler32 << 16) | l;
+
+         if (m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_COMPUTE_ADLER32)
+         {
+            if (unbuffered)
+            {
+               m_decomp_adler32 = adler32(pDst, dst_ofs, cInitAdler32);
+            }
+
+            if (m_file_src_file_adler32 != m_decomp_adler32)
+            {
+               LZHAM_LOG_ERROR(1034);
+               m_status = LZHAM_DECOMP_STATUS_FAILED_ADLER32;
+            }
+         }
+         else
+         {
+            m_decomp_adler32 = m_file_src_file_adler32;
+         }
+      }
+
+      LZHAM_SYMBOL_CODEC_DECODE_END(codec);
+
+      *m_pIn_buf_size = static_cast<size_t>(codec.stop_decoding());
+      *m_pOut_buf_size = unbuffered ? (dst_ofs - m_dst_highwater_ofs) : 0;
+      m_dst_highwater_ofs = dst_ofs;
+
+      LZHAM_CR_RETURN(m_state, m_status);
+
+      for ( ; ; )
+      {
+         *m_pIn_buf_size = 0;
+         *m_pOut_buf_size = 0;
+         LZHAM_CR_RETURN(m_state, m_status);
+      }
+
+      LZHAM_CR_FINISH
+
+      return m_status;
+   }
+
+   static bool check_params(const lzham_decompress_params *pParams)
+   {
+      if ((!pParams) || (pParams->m_struct_size != sizeof(lzham_decompress_params)))
+      {
+         LZHAM_LOG_ERROR(1000);
+         return false;
+      }
+
+      if ((pParams->m_dict_size_log2 < CLZDecompBase::cMinDictSizeLog2) || (pParams->m_dict_size_log2 > CLZDecompBase::cMaxDictSizeLog2))
+      {
+         LZHAM_LOG_ERROR(1001);
+         return false;
+      }
+
+      if (pParams->m_num_seed_bytes)
+      {
+         if (((pParams->m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED) != 0) || (!pParams->m_pSeed_bytes))
+         {
+            LZHAM_LOG_ERROR(1002);
+            return false;
+         }
+         if (pParams->m_num_seed_bytes > (1U << pParams->m_dict_size_log2))
+         {
+            LZHAM_LOG_ERROR(1003);
+            return false;
+         }
+      }
+      return true;
+   }
+   
+   lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_init(const lzham_decompress_params *pParams)
+   {
+      LZHAM_ASSUME(CLZDecompBase::cMinDictSizeLog2 == LZHAM_MIN_DICT_SIZE_LOG2);
+      LZHAM_ASSUME(CLZDecompBase::cMaxDictSizeLog2 == LZHAM_MAX_DICT_SIZE_LOG2_X64);
+
+      if (!check_params(pParams))
+         return NULL;
+
+      lzham_malloc_context malloc_context = lzham_create_malloc_context(LZHAM_DECOMP_MEMORY_ARENA_SIZE);
+      
+      lzham_decompressor *pState = lzham_new<lzham_decompressor>(malloc_context, malloc_context);
+      if (!pState)
+      {
+         lzham_destroy_malloc_context(malloc_context);
+         return NULL;
+      }
+      
+      pState->m_params = *pParams;
+
+      if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED)
+      {
+         pState->m_pRaw_decomp_buf = NULL;
+         pState->m_raw_decomp_buf_size = 0;
+         pState->m_pDecomp_buf = NULL;
+      }
+      else
+      {
+         uint32 decomp_buf_size = 1U << pState->m_params.m_dict_size_log2;
+         pState->m_pRaw_decomp_buf = static_cast<uint8*>(lzham_malloc(malloc_context, decomp_buf_size + 15));
+         if (!pState->m_pRaw_decomp_buf)
+         {
+            lzham_delete(malloc_context, pState);
+            lzham_destroy_malloc_context(malloc_context);
+            return NULL;
+         }
+         pState->m_raw_decomp_buf_size = decomp_buf_size;
+         pState->m_pDecomp_buf = math::align_up_pointer(pState->m_pRaw_decomp_buf, 16);
+      }
+
+      pState->init();
+      
+      return pState;
+   }
+
+   lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_reinit(lzham_decompress_state_ptr p, const lzham_decompress_params *pParams)
+   {
+      if (!p)
+         return lzham_lib_decompress_init(pParams);
+      
+      lzham_decompressor *pState = static_cast<lzham_decompressor *>(p);
+
+      if (!check_params(pParams))
+         return NULL;
+      
+      if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED)
+      {
+         lzham_free(pState->m_malloc_context, pState->m_pRaw_decomp_buf);
+         pState->m_pRaw_decomp_buf = NULL;
+         pState->m_raw_decomp_buf_size = 0;
+         pState->m_pDecomp_buf = NULL;
+      }
+      else
+      {
+         uint32 new_dict_size = 1U << pState->m_params.m_dict_size_log2;
+         if ((!pState->m_pRaw_decomp_buf) || (pState->m_raw_decomp_buf_size < new_dict_size))
+         {
+            uint8 *pNew_dict = static_cast<uint8*>(lzham_realloc(pState->m_malloc_context, pState->m_pRaw_decomp_buf, new_dict_size + 15));
+            if (!pNew_dict)
+               return NULL;
+            pState->m_pRaw_decomp_buf = pNew_dict;
+            pState->m_raw_decomp_buf_size = new_dict_size;
+            pState->m_pDecomp_buf = math::align_up_pointer(pState->m_pRaw_decomp_buf, 16);
+         }
+      }
+      
+      pState->m_params = *pParams;
+
+      pState->init();
+
+      pState->reset_arith_tables();
+      return pState;
+   }
+
+   uint32 LZHAM_CDECL lzham_lib_decompress_deinit(lzham_decompress_state_ptr p)
+   {
+      lzham_decompressor *pState = static_cast<lzham_decompressor *>(p);
+      if (!pState)
+         return 0;
+
+      uint32 adler32 = pState->m_decomp_adler32;
+
+      lzham_malloc_context malloc_context = pState->m_malloc_context;
+
+      lzham_free(malloc_context, pState->m_pRaw_decomp_buf);
+      lzham_delete(malloc_context, pState);
+      lzham_destroy_malloc_context(malloc_context);
+
+      return adler32;
+   }
+
+   lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress(
+      lzham_decompress_state_ptr p,
+      const lzham_uint8 *pIn_buf, size_t *pIn_buf_size,
+      lzham_uint8 *pOut_buf, size_t *pOut_buf_size,
+      lzham_bool no_more_input_bytes_flag)
+   {
+      lzham_decompressor *pState = static_cast<lzham_decompressor *>(p);
+
+      if ((!pState) || (!pState->m_params.m_dict_size_log2) || (!pIn_buf_size) || (!pOut_buf_size))
+      {
+         return LZHAM_DECOMP_STATUS_INVALID_PARAMETER;
+      }
+
+      if ((*pIn_buf_size) && (!pIn_buf))
+      {
+         return LZHAM_DECOMP_STATUS_INVALID_PARAMETER;
+      }
+
+      if ((*pOut_buf_size) && (!pOut_buf))
+      {
+         return LZHAM_DECOMP_STATUS_INVALID_PARAMETER;
+      }
+
+      pState->m_pIn_buf = pIn_buf;
+      pState->m_pIn_buf_size = pIn_buf_size;
+      pState->m_pOut_buf = pOut_buf;
+      pState->m_pOut_buf_size = pOut_buf_size;
+      pState->m_no_more_input_bytes_flag = (no_more_input_bytes_flag != 0);
+
+      if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED)
+      {
+         if (!pState->m_pOrig_out_buf)
+         {
+            pState->m_pOrig_out_buf = pOut_buf;
+            pState->m_orig_out_buf_size = *pOut_buf_size;
+         }
+         else
+         {
+            // In unbuffered mode, the caller is not allowed to move the output buffer and the output pointer MUST always point to the beginning of the output buffer.
+            // Also, the output buffer size must indicate the full size of the output buffer. The decompressor will track the current output offset, and during partial/sync
+            // flushes it'll report how many bytes it has written since the call. 
+            if ((pState->m_pOrig_out_buf != pOut_buf) || (pState->m_orig_out_buf_size != *pOut_buf_size))
+            {
+               return LZHAM_DECOMP_STATUS_INVALID_PARAMETER;
+            }
+         }
+      }
+
+      lzham_decompress_status_t status;
+
+      if (pState->m_params.m_decompress_flags & LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED)
+         status = pState->decompress<true>();
+      else
+         status = pState->decompress<false>();
+      
+      return status;
+   }
+
+   lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress_memory(const lzham_decompress_params *pParams, lzham_uint8* pDst_buf, size_t *pDst_len, const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32)
+   {
+      if (!pParams)
+         return LZHAM_DECOMP_STATUS_INVALID_PARAMETER;
+
+      lzham_decompress_params params(*pParams);
+      params.m_decompress_flags |= LZHAM_DECOMP_FLAG_OUTPUT_UNBUFFERED;
+
+      lzham_decompress_state_ptr pState = lzham_lib_decompress_init(&params);
+      if (!pState)
+         return LZHAM_DECOMP_STATUS_FAILED_INITIALIZING;
+
+      lzham_decompress_status_t status = lzham_lib_decompress(pState, pSrc_buf, &src_len, pDst_buf, pDst_len, true);
+
+      uint32 adler32 = lzham_lib_decompress_deinit(pState);
+      if (pAdler32)
+         *pAdler32 = adler32;
+
+      return status;
+   }
+
+   // ----------------- zlib-style API's
+
+   int LZHAM_CDECL lzham_lib_z_inflateInit(lzham_z_streamp pStream)
+   {
+      return lzham_lib_z_inflateInit2(pStream, LZHAM_Z_DEFAULT_WINDOW_BITS);
+   }
+
+   int LZHAM_CDECL lzham_lib_z_inflateInit2(lzham_z_streamp pStream, int window_bits)
+   {
+      if (!pStream) 
+         return LZHAM_Z_STREAM_ERROR;
+      
+#ifdef LZHAM_Z_API_FORCE_WINDOW_BITS
+      window_bits = LZHAM_Z_API_FORCE_WINDOW_BITS;
+#endif      
+
+      int max_window_bits = LZHAM_64BIT_POINTERS ? LZHAM_MAX_DICT_SIZE_LOG2_X64 : LZHAM_MAX_DICT_SIZE_LOG2_X86;
+      if (labs(window_bits) > max_window_bits)
+         return LZHAM_Z_PARAM_ERROR;
+
+      if (labs(window_bits) < LZHAM_MIN_DICT_SIZE_LOG2)
+         window_bits = (window_bits < 0) ? -LZHAM_MIN_DICT_SIZE_LOG2 : LZHAM_MIN_DICT_SIZE_LOG2;
+      
+      lzham_decompress_params params;
+      utils::zero_object(params);
+      params.m_struct_size = sizeof(lzham_decompress_params);
+      params.m_dict_size_log2 = static_cast<lzham_uint32>(labs(window_bits));
+      
+      params.m_decompress_flags = LZHAM_DECOMP_FLAG_COMPUTE_ADLER32;
+      if (window_bits > 0)
+         params.m_decompress_flags |= LZHAM_DECOMP_FLAG_READ_ZLIB_STREAM;
+      
+      lzham_decompress_state_ptr pState = lzham_lib_decompress_init(&params);
+      if (!pState)
+         return LZHAM_Z_MEM_ERROR;
+      pStream->state = static_cast<lzham_z_internal_state *>(pState);
+
+      pStream->data_type = 0;
+      pStream->adler = LZHAM_Z_ADLER32_INIT;
+      pStream->msg = NULL;
+      pStream->total_in = 0;
+      pStream->total_out = 0;
+      pStream->reserved = 0;
+            
+      return LZHAM_Z_OK;
+   }
+   
+   int LZHAM_CDECL lzham_lib_z_inflateReset(lzham_z_streamp pStream)
+   {
+      if ((!pStream) || (!pStream->state)) 
+         return LZHAM_Z_STREAM_ERROR;
+
+      lzham_decompress_state_ptr pState = static_cast<lzham_decompress_state_ptr>(pStream->state);
+      lzham_decompressor *pDecomp = static_cast<lzham_decompressor *>(pState);
+      
+      lzham_decompress_params params(pDecomp->m_params);
+
+      if (!lzham_lib_decompress_reinit(pState, &params))
+         return LZHAM_Z_STREAM_ERROR;
+
+      return LZHAM_Z_OK;
+   }
+
+   int LZHAM_CDECL lzham_lib_z_inflate(lzham_z_streamp pStream, int flush)
+   {
+      if ((!pStream) || (!pStream->state)) 
+         return LZHAM_Z_STREAM_ERROR;
+            
+      if ((flush == LZHAM_Z_PARTIAL_FLUSH) || (flush == LZHAM_Z_FULL_FLUSH))
+         flush = LZHAM_Z_SYNC_FLUSH;
+      if (flush)
+      {
+         if ((flush != LZHAM_Z_SYNC_FLUSH) && (flush != LZHAM_Z_FINISH)) 
+            return LZHAM_Z_STREAM_ERROR;
+      }
+
+      size_t orig_avail_in = pStream->avail_in;
+
+      lzham_decompress_state_ptr pState = static_cast<lzham_decompress_state_ptr>(pStream->state);
+      lzham_decompressor *pDecomp = static_cast<lzham_decompressor *>(pState);
+      if (pDecomp->m_z_last_status >= LZHAM_DECOMP_STATUS_FIRST_SUCCESS_OR_FAILURE_CODE)
+         return LZHAM_Z_DATA_ERROR;
+
+      if (pDecomp->m_z_has_flushed && (flush != LZHAM_Z_FINISH)) 
+         return LZHAM_Z_STREAM_ERROR;
+      pDecomp->m_z_has_flushed |= (flush == LZHAM_Z_FINISH);
+
+      lzham_decompress_status_t status;
+      for ( ; ; )
+      {
+         size_t in_bytes = pStream->avail_in;
+         size_t out_bytes = pStream->avail_out;
+         lzham_bool no_more_input_bytes_flag = (flush == LZHAM_Z_FINISH);
+         status = lzham_lib_decompress(pState, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, no_more_input_bytes_flag);
+         
+         pDecomp->m_z_last_status = status;
+
+         pStream->next_in += (uint)in_bytes; 
+         pStream->avail_in -= (uint)in_bytes;
+         pStream->total_in += (uint)in_bytes; 
+         pStream->adler = pDecomp->m_decomp_adler32;
+
+         pStream->next_out += (uint)out_bytes;
+         pStream->avail_out -= (uint)out_bytes;
+         pStream->total_out += (uint)out_bytes;
+                  
+         if (status >= LZHAM_DECOMP_STATUS_FIRST_FAILURE_CODE)
+         {
+            if (status == LZHAM_DECOMP_STATUS_FAILED_NEED_SEED_BYTES)
+               return LZHAM_Z_NEED_DICT;
+            else 
+               return LZHAM_Z_DATA_ERROR; // Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well).
+         }
+         
+         if ((status == LZHAM_DECOMP_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
+            return LZHAM_Z_BUF_ERROR; // Signal caller that we can't make forward progress without supplying more input, or by setting flush to LZHAM_Z_FINISH.
+         else if (flush == LZHAM_Z_FINISH)
+         {
+            // Caller has indicated that all remaining input was at next_in, and all remaining output will fit entirely in next_out.
+            // (The output buffer at next_out MUST be large to hold the remaining uncompressed data when flush==LZHAM_Z_FINISH).
+            if (status == LZHAM_DECOMP_STATUS_SUCCESS)
+               return LZHAM_Z_STREAM_END;
+            // If status is LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT, there must be at least 1 more byte on the way but the caller to lzham_decompress() supplied an empty output buffer.
+            // Something is wrong because the caller's output buffer should be large enough to hold the entire decompressed stream when flush==LZHAM_Z_FINISH.
+            else if (status == LZHAM_DECOMP_STATUS_HAS_MORE_OUTPUT)
+               return LZHAM_Z_BUF_ERROR;
+         }
+         else if ((status == LZHAM_DECOMP_STATUS_SUCCESS) || (!pStream->avail_in) || (!pStream->avail_out))
+            break;
+      }
+
+      return (status == LZHAM_DECOMP_STATUS_SUCCESS) ? LZHAM_Z_STREAM_END : LZHAM_Z_OK;
+   }
+
+   int LZHAM_CDECL lzham_lib_z_inflateEnd(lzham_z_streamp pStream)
+   {
+      if (!pStream)
+         return LZHAM_Z_STREAM_ERROR;
+
+      lzham_decompress_state_ptr pState = static_cast<lzham_decompress_state_ptr>(pStream->state);
+      if (pState)
+      {
+         pStream->adler = lzham_lib_decompress_deinit(pState);
+         pStream->state = NULL;
+      }
+
+      return LZHAM_Z_OK;
+   }
+
+   int LZHAM_CDECL lzham_lib_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len)
+   {
+      lzham_z_stream stream;
+      int status;
+      memset(&stream, 0, sizeof(stream));
+
+      // In case lzham_z_ulong is 64-bits (argh I hate longs).
+      if ((source_len | *pDest_len) > 0xFFFFFFFFU) 
+         return LZHAM_Z_PARAM_ERROR;
+
+      stream.next_in = pSource;
+      stream.avail_in = (uint)source_len;
+      stream.next_out = pDest;
+      stream.avail_out = (uint)*pDest_len;
+
+      status = lzham_lib_z_inflateInit(&stream);
+      if (status != LZHAM_Z_OK)
+         return status;
+
+      status = lzham_lib_z_inflate(&stream, LZHAM_Z_FINISH);
+      if (status != LZHAM_Z_STREAM_END)
+      {
+         lzham_lib_z_inflateEnd(&stream);
+         return ((status == LZHAM_Z_BUF_ERROR) && (!stream.avail_in)) ? LZHAM_Z_DATA_ERROR : status;
+      }
+      *pDest_len = stream.total_out;
+
+      return lzham_lib_z_inflateEnd(&stream);
+   }
+
+   const char * LZHAM_CDECL lzham_lib_z_error(int err)
+   {
+      static struct 
+      { 
+         int m_err; 
+         const char *m_pDesc; 
+      } 
+      s_error_descs[] =
+      {
+         { LZHAM_Z_OK, "" }, 
+         { LZHAM_Z_STREAM_END, "stream end" }, 
+         { LZHAM_Z_NEED_DICT, "need dictionary" }, 
+         { LZHAM_Z_ERRNO, "file error" }, 
+         { LZHAM_Z_STREAM_ERROR, "stream error" },
+         { LZHAM_Z_DATA_ERROR, "data error" }, 
+         { LZHAM_Z_MEM_ERROR, "out of memory" }, 
+         { LZHAM_Z_BUF_ERROR, "buf error" }, 
+         { LZHAM_Z_VERSION_ERROR, "version error" }, 
+         { LZHAM_Z_PARAM_ERROR, "parameter error" }
+      };
+      for (uint i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) 
+         if (s_error_descs[i].m_err == err) 
+            return s_error_descs[i].m_pDesc;
+      return NULL;
+   }
+
+   lzham_z_ulong lzham_lib_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len)
+   {
+      return adler32(ptr, buf_len, static_cast<uint>(adler));
+   }
+
+   lzham_z_ulong LZHAM_CDECL lzham_lib_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len)
+   {
+      return crc32(static_cast<uint>(crc), ptr, buf_len);
+   }
+
+} // namespace lzham