#include "../game/q_shared.h"
#include "../qcommon/qcommon.h"

#include "zip.h"
#include "inflate.h"

#ifdef _TIMING
int		totalInflateTime;
int		totalInflateCount;
#endif

// If you use the zlib library in a product, an acknowledgment is welcome
// in the documentation of your product. If for some reason you cannot
// include such an acknowledgment, I would appreciate that you keep this
// copyright string in the executable of your product.
const char inflate_copyright[] = "Inflate 1.1.3 Copyright 1995-1998 Mark Adler ";

static const char *inflate_error = "OK";

//	int inflate(z_stream *strm);
//
//    inflate decompresses as much data as possible, and stops when the input
//  buffer becomes empty or the output buffer becomes full. It may some
//  introduce some output latency (reading input without producing any output)
//  except when forced to flush.
//
//  The detailed semantics are as follows. inflate performs one or both of the
//  following actions:
//
//  - Decompress more input starting at next_in and update next_in and avail_in
//    accordingly. If not all input can be processed (because there is not
//    enough room in the output buffer), next_in is updated and processing
//    will resume at this point for the next call of inflate().
//
//  - Provide more output starting at next_out and update next_out and avail_out
//    accordingly.  inflate() provides as much output as possible, until there
//    is no more input data or no more space in the output buffer (see below
//    about the flush parameter).
//
//  Before the call of inflate(), the application should ensure that at least
//  one of the actions is possible, by providing more input and/or consuming
//  more output, and updating the next_* and avail_* values accordingly.
//  The application can consume the uncompressed output when it wants, for
//  example when the output buffer is full (avail_out == 0), or after each
//  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
//  must be called again after making room in the output buffer because there
//  might be more output pending.
//
//    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
//  output as possible to the output buffer. The flushing behavior of inflate is
//  not specified for values of the flush parameter other than Z_SYNC_FLUSH
//  and Z_FINISH, but the current implementation actually flushes as much output
//  as possible anyway.
//
//    inflate() should normally be called until it returns Z_STREAM_END or an
//  error. However if all decompression is to be performed in a single step
//  (a single call of inflate), the parameter flush should be set to
//  Z_FINISH. In this case all pending input is processed and all pending
//  output is flushed; avail_out must be large enough to hold all the
//  uncompressed data. (The size of the uncompressed data may have been saved
//  by the compressor for this purpose.) The next operation on this stream must
//  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
//  is never required, but can be used to inform inflate that a faster routine
//  may be used for the single inflate() call.
//
//    It sets strm->adler to the adler32 checksum of all output produced
//  so and returns Z_OK, Z_STREAM_END or
//  an error code as described below. At the end of the stream, inflate()
//  checks that its computed adler32 checksum is equal to that saved by the
//  compressor and returns Z_STREAM_END only if the checksum is correct.
//
//    inflate() returns Z_OK if some progress has been made (more input processed
//  or more output produced), Z_STREAM_END if the end of the compressed data has
//  been reached and all uncompressed output has been produced, 
//  Z_DATA_ERROR if the input data was
//  corrupted (input stream not conforming to the zlib format or incorrect
//  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
//  (for example if next_in or next_out was NULL),
//  Z_BUF_ERROR if no progress is possible or if there was not
//  enough room in the output buffer when Z_FINISH is used.

//	int inflateEnd (z_stream *strm);
//
//     All dynamically allocated data structures for this stream are freed.
//   This function discards any unprocessed input and does not flush any
//   pending output.
//
//     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
//   was inconsistent. In the error case, msg may be set but then points to a
//   static string (which must not be deallocated).

//	EStatus inflateInit(z_stream *strm, EFlush flush, int noWrap = 0);
//
//      inflateInit returns Z_OK if success,
//   Z_STREAM_ERROR if a parameter is invalid.
//   msg is set to "OK" if there is no error message. inflateInit
//   does not perform any decompression apart from reading the zlib header if
//   present: this will be done by inflate(). (So next_in and avail_in may be
//   modified, but next_out and avail_out are unchanged.)

//   Notes beyond the 1.93a appnote.txt:
//
//   1. Distance pointers never point before the beginning of the output
//      stream.
//   2. Distance pointers can point back across blocks, up to 32k away.
//   3. There is an implied maximum of 7 bits for the bit length table and
//      15 bits for the actual data.
//   4. If only one code exists, then it is encoded using one bit.  (Zero
//      would be more efficient, but perhaps a little confusing.)  If two
//      codes exist, they are coded using one bit each (0 and 1).
//   5. There is no way of sending zero distance codes--a dummy must be
//      sent if there are none.  (History: a pre 2.0 version of PKZIP would
//      store blocks with no distance codes, but this was discovered to be
//      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
//      zero distance codes, which is sent as one code of zero bits in
//      length.
//   6. There are up to 286 literal/length codes.  Code 256 represents the
//      end-of-block.  Note however that the static length tree defines
//      288 codes just to fill out the Huffman codes.  Codes 286 and 287
//      cannot be used though, since there is no length base or extra bits
//      defined for them.  Similarily, there are up to 30 distance codes.
//      However, static trees define 32 codes (all 5 bits) to fill out the
//      Huffman codes, but the last two had better not show up in the data.
//   7. Unzip can check dynamic Huffman blocks for complete code sets.
//      The exception is that a single code would not be complete (see #4).
//   8. The five bits following the block type is really the number of
//      literal codes sent minus 257.
//   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
//      (1+6+6).  Therefore, to output three times the length, you output
//      three codes (1+1+1), whereas to output four times the same length,
//      you only need two codes (1+3).  Hmm.
//  10. In the tree reconstruction algorithm, Code = Code + Increment
//      only if BitLength(i) is not zero.  (Pretty obvious.)
//  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
//  12. Note: length code 284 can represent 227-258, but length code 285
//      really is 258.  The last length deserves its own, short code
//      since it gets used a lot in very redundant files.  The length
//      258 is special since 258 - 3 (the min match length) is 255.
//  13. The literal/length and distance code bit lengths are read as a
//      single stream of lengths.  It is possible (and advantageous) for
//      a repeat code (16, 17, or 18) to go across the boundary between
//      the two sets of lengths.

// And'ing with mask[n] masks the lower n bits
static const uint32_t inflate_mask[17] = 
{
    0x0000,
    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};

// Order of the bit length code lengths
static const uint32_t border[] = 
{ 
	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
};

// Copy lengths for literal codes 257..285 (see note #13 above about 258)
static const uint32_t cplens[31] = 
{ 
	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
};

// Extra bits for literal codes 257..285 (112 == invalid)
static const uint32_t cplext[31] = 
{ 
	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112
}; 

// Copy offsets for distance codes 0..29
static const uint32_t cpdist[30] = 
{ 
	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
	8193, 12289, 16385, 24577
};

static uint32_t fixed_bl = 9;
static uint32_t fixed_bd = 5;

static inflate_huft_t fixed_tl[] = 
{
    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 192 },
    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 160 },
    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 224 },
    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 144 },
    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 208 },
    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 176 },
    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 240 },
    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 200 },
    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 168 },
    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 232 },
    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 152 },
    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 216 },
    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 184 },
    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 248 },
    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 196 },
    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 164 },
    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 228 },
    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 148 },
    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 212 },
    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 180 },
    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 244 },
    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 204 },
    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 172 },
    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 236 },
    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 156 },
    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 220 },
    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 188 },
    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 252 },
    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 194 },
    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 162 },
    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 226 },
    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 146 },
    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 210 },
    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 178 },
    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 242 },
    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 202 },
    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 170 },
    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 234 },
    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 154 },
    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 218 },
    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 186 },
    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 250 },
    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 198 },
    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 166 },
    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 230 },
    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 150 },
    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 214 },
    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 182 },
    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 246 },
    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 206 },
    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 174 },
    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 238 },
    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 158 },
    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 222 },
    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 190 },
    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 254 },
    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 193 },
    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 161 },
    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 225 },
    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 145 },
    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 209 },
    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 177 },
    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 241 },
    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 201 },
    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 169 },
    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 233 },
    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 153 },
    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 217 },
    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 185 },
    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 249 },
    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 197 },
    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 165 },
    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 229 },
    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 149 },
    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 213 },
    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 181 },
    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 245 },
    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 205 },
    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 173 },
    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 237 },
    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 157 },
    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 221 },
    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 189 },
    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 253 },
    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 195 },
    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 163 },
    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 227 },
    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 147 },
    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 211 },
    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 179 },
    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 243 },
    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 203 },
    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 171 },
    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 235 },
    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 155 },
    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 219 },
    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 187 },
    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 251 },
    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 199 },
    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 167 },
    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 231 },
    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 151 },
    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 215 },
    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 183 },
    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 247 },
    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 207 },
    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 175 },
    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 239 },
    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 159 },
    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 223 },
    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 191 },
    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 255 }
};

static inflate_huft_t fixed_td[] = 
{
    { 80, 5, 1  }, { 87, 5, 257  }, { 83, 5, 17  }, { 91,  5, 4097  },
    { 81, 5, 5  }, { 89, 5, 1025 }, { 85, 5, 65  }, { 93,  5, 16385 },
    { 80, 5, 3  }, { 88, 5, 513  }, { 84, 5, 33  }, { 92,  5, 8193  },
    { 82, 5, 9  }, { 90, 5, 2049 }, { 86, 5, 129 }, { 192, 5, 24577 },
    { 80, 5, 2  }, { 87, 5, 385  }, { 83, 5, 25  }, { 91,  5, 6145  },
    { 81, 5, 7  }, { 89, 5, 1537 }, { 85, 5, 97  }, { 93,  5, 24577 },
    { 80, 5, 4  }, { 88, 5, 769  }, { 84, 5, 49  }, { 92,  5, 12289 },
    { 82, 5, 13 }, { 90, 5, 3073 }, { 86, 5, 193 }, { 192, 5, 24577 }
};

// ===============================================================================
// ===============================================================================

static void inflate_blocks_reset(z_stream *z, inflate_blocks_state_t *s)
{
	if((s->mode == BTREE) || (s->mode == DTREE))
	{
		Z_Free(s->trees.blens);
	}
	if(s->mode == CODES)
	{
		Z_Free(s->decode.codes);
	}
	s->mode = TYPE;
	s->bitk = 0;
	s->bitb = 0;
	s->write = s->window;
	s->read = s->window;
	z->istate->adler = 1;
}

// ===============================================================================
// ===============================================================================

static int inflate_blocks_free(z_stream *z, inflate_blocks_state_t *s)
{
	inflate_blocks_reset(z, s);
	Z_Free(s->hufts);
	s->hufts = NULL;
	Z_Free(s);
	return(Z_OK);
}

// ===============================================================================
// ===============================================================================

static inflate_blocks_state_t *inflate_blocks_new(z_stream *z, check_func check)
{
	inflate_blocks_state_t *s;

	s = (inflate_blocks_state_t *)Z_Malloc(sizeof(inflate_blocks_state_t), TAG_INFLATE, qtrue);
	s->hufts = (inflate_huft_t *)Z_Malloc(sizeof(inflate_huft_t) * MANY, TAG_INFLATE, qtrue);
	s->end = s->window + WINDOW_SIZE;
	s->mode = TYPE;
	inflate_blocks_reset(z, s);

	return(s);
}

// ===============================================================================
// copy as much as possible from the sliding window to the output area
// ===============================================================================

static void inflate_flush_copy(z_stream *z, inflate_blocks_state_t *s, uint32_t count)
{
	if(count > z->avail_out)
	{
		count = z->avail_out;
	}
	if(count && (z->error == Z_BUF_ERROR))
	{
		z->error = Z_OK;
	}

	// Calculate the checksum if required
	if(!z->istate->nowrap)
	{
		z->istate->adler = adler32(z->istate->adler, s->read, count);
	}

	// copy as as end of window
	memcpy(z->next_out, s->read, count);

	// update counters
	z->avail_out -= count;
	z->total_out += count;
	z->next_out += count;
	s->read += count;
}

// ===============================================================================
// ===============================================================================

static void inflate_flush(z_stream *z, inflate_blocks_state_t *s)
{
	uint32_t	count;

	// compute number of bytes to copy as as end of window
	count = (s->read <= s->write ? s->write : s->end) - s->read;

	inflate_flush_copy(z, s, count);

	// see if more to copy at beginning of window
	if(s->read == s->end)
	{
		// wrap pointers
		s->read = s->window;
		if(s->write == s->end)
		{
			s->write = s->window;
		}
		// compute bytes to copy
		count = s->write - s->read;
		inflate_flush_copy(z, s, count);
	}
}

// ===============================================================================
// get bytes and bits
// ===============================================================================

static bool getbits(z_stream *z, inflate_blocks_state_t *s, uint32_t bits)								 
{			
	while(s->bitk < bits) 							
	{											
		if(z->avail_in)
		{
			z->error = Z_OK;
		}
		else
		{										
			inflate_flush(z, s);
			return(false);
		}		  
		z->avail_in--;
		z->total_in++;
		s->bitb |= *z->next_in++ << s->bitk;			
		s->bitk += 8; 	 
	}		
	return(true);
}

// ===============================================================================
// output bytes
// ===============================================================================

static uint32_t needout(z_stream *z, inflate_blocks_state_t *s, uint32_t bytesToEnd) 
{ 
	if(!bytesToEnd)
	{ 
		if((s->write == s->end) && (s->read != s->window)) 
		{ 
			s->write = s->window;
			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
		}
		if(!bytesToEnd)
		{
			inflate_flush(z, s);
			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
			if((s->write == s->end) && (s->read != s->window))
			{
				s->write = s->window;
				bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
			}
			if(!bytesToEnd)
			{
				inflate_flush(z, s);
				return(bytesToEnd);
			}
		}
	}
	z->error = Z_OK;
	return(bytesToEnd);
}

// ===============================================================================
// Called with number of bytes left to write in window at least 258
//	 (the maximum string length) and number of input bytes available
//	 at least ten.	The ten bytes are six bytes for the longest length/
//	 distance pair plus four bytes for overloading the bit buffer.
// ===============================================================================

inline byte *qcopy(byte *dst, byte *src, int count)
{
	byte 	*retval;
#ifdef _MSC_VER
	_asm
	{
		push ecx  
		push esi
		push edi

		mov edi, [dst]
		mov esi, [src]
		mov ecx, [count]
		rep movsb

		mov [retval], edi
		pop edi
		pop esi
		pop ecx
	}
#else
	asm("repe movsb;"
	    : "=D"(retval)
	    : "D"(dst), "S"(src), "c"(count)
	);
#endif
	return(retval);
}

inline uint32_t get_remaining(inflate_blocks_state_t *s)
{
	if(s->write < s->read)
	{
		return(s->read - s->write - 1);
	}
	return(s->end - s->write); 
}

static EStatus inflate_fast(uint32_t lengthMask, uint32_t distMask, inflate_huft_t *lengthTree, inflate_huft_t *distTree, inflate_blocks_state_t *s, z_stream *z)
{
	inflate_huft_t	*huft;			// temporary pointer
	byte			*data;			
	byte			*src; 			// copy source pointer
	byte			*dst;			
	uint32_t			extraBits;		// extra bits or operation
	uint32_t			bytesToEnd;		// bytes to end of window or read pointer
	uint32_t			count;			// bytes to copy
	uint32_t			dist;			// distance back to copy from
	uint32_t			bitb;
	uint32_t			bitk;
	uint32_t			availin;
	uint32_t			morebits;
	uint32_t			copymore;

	// load input, output, bit values
	data = z->next_in;
	dst = s->write;
	availin = z->avail_in;
	bitb = s->bitb;
	bitk = s->bitk;

	bytesToEnd = get_remaining(s);

	// do until not enough input or output space for fast loop
	// assume called with bytesToEnd >= 258 && availIn >= 10
	while((bytesToEnd >= 258) && (availin >= 10))
	{						   
		// get literal/length code
		while(bitk < 20)
		{
			bitb |= *data++ << bitk;
			bitk += 8;
			availin--;
		}

		huft = lengthTree + (bitb & lengthMask);
		if(!huft->Exop)
		{
			bitb >>= huft->Bits;
			bitk -= huft->Bits;
			*dst++ = (byte)huft->base;
			bytesToEnd--;
		}
		else
		{
			extraBits = huft->Exop;
			morebits = 1;
			do
			{
				bitb >>= huft->Bits; 
				bitk -= huft->Bits;
				if(extraBits & 16)
				{
					// get extra bits for length
					extraBits &= 15;
					count = huft->base + (bitb & inflate_mask[extraBits]);
					bitb >>= extraBits;
					bitk -= extraBits;
					// decode distance base of block to copy
					while(bitk < 15)
					{
						bitb |= *data++ << bitk;
						bitk += 8;
						availin--;
					}
					huft = distTree + (bitb & distMask);
					extraBits = huft->Exop;
	   				copymore = 1;
					do
					{
						bitb >>= huft->Bits;
						bitk -= huft->Bits;
						if(extraBits & 16)
						{
							// get extra bits to add to distance base
							extraBits &= 15;
							while(bitk < extraBits)
							{
								bitb |= *data++ << bitk;
								bitk += 8;
								availin--;
							}
							dist = huft->base + (bitb & inflate_mask[extraBits]);
							bitb >>= extraBits;
							bitk -= extraBits;

							// do the copy
							bytesToEnd -= count;
							// offset before dest
							if((dst - s->window) >= dist)	 
							{								   
								// just copy
								src = dst - dist;
							}
							// else offset after destination
							else						
							{
								// bytes from offset to end
								extraBits = dist - (dst - s->window);
								// pointer to offset
								src = s->end - extraBits; 		  
								// if source crosses,					  
								if(count > extraBits)				  
								{
									// copy to end of window
									dst = qcopy(dst, src, extraBits);
									// copy rest from start of window
									count -= extraBits; 				
									src = s->window;			
								}
							}
							// copy all or what's left
							dst = qcopy(dst, src, count);
							copymore = 0;
						}
						else
						{
							if(!(extraBits & 64))
							{
								huft += huft->base + (bitb & inflate_mask[extraBits]);
								extraBits = huft->Exop;
							}
							else
							{
								inflate_error = "Inflate data: Invalid distance code";
								return(Z_DATA_ERROR);
							}
						}
					} while(copymore);

					morebits = 0;
				}
				else
				{
					if(!(extraBits & 64))
					{
						huft += huft->base + (bitb & inflate_mask[extraBits]);
						extraBits = huft->Exop;
						if(!extraBits)								   
						{
							bitb >>= huft->Bits;
							bitk -= huft->Bits;
							*dst++ = (byte)huft->base;
							bytesToEnd--;
							morebits = 0;
						}
					}
					else if(extraBits & 32)									 
					{
						count = data - z->next_in;

						z->avail_in = availin;
						z->total_in += count;
						z->next_in = data;

						s->write = dst;

						count = (bitk >> 3) < count ? bitk >> 3 : count;

						s->bitb = bitb;
						s->bitk = bitk - (count << 3);
						z->avail_in += count;
						z->total_in -= count;
						z->next_in -= count ;
						return(Z_STREAM_END);
					}
					else
					{
						inflate_error = "Inflate data: Invalid literal/length code";
						return(Z_DATA_ERROR);
					}
				}
			} while(morebits);
		}
	}

	// not enough input or output--restore pointers and return
	count = data - z->next_in;

	z->avail_in = availin;
	z->total_in += count;
	z->next_in = data;

	s->write = dst;

	count = (bitk >> 3) < count ? bitk >> 3 : count;
	s->bitb = bitb;
	s->bitk = bitk - (count << 3);
	z->avail_in += count;
	z->total_in -= count;
	z->next_in -= count;

	return(Z_OK);
}

// ===============================================================================
// ===============================================================================

static void inflate_codes(z_stream *z, inflate_blocks_state_t *s)
{
	inflate_huft_t			*huft; 		// temporary pointer
	uint32_t					extraBits;	// extra bits or operation
	uint32_t					bytesToEnd;	// bytes to end of window or read pointer
	byte					*src; 		// pointer to copy strings from
	inflate_codes_state_t	*infCodes;	// codes state

	infCodes = s->decode.codes;

	// copy input/output information to locals
	bytesToEnd = get_remaining(s);

	// process input and output based on current state
	while(true)
	{
		// waiting for "i:"=input, "o:"=output, "x:"=nothing
		switch (infCodes->mode)
		{			  
		// x: set up for LEN
		case START:
			if((bytesToEnd >= 258) && (z->avail_in >= 10))
			{
				z->error = inflate_fast(inflate_mask[infCodes->lbits], inflate_mask[infCodes->dbits], infCodes->ltree, infCodes->dtree, s, z);
				bytesToEnd = get_remaining(s);
				if(z->error != Z_OK)
				{
					infCodes->mode = (z->error == Z_STREAM_END) ? WASH : BADCODE;
					break;
				}
			}
			infCodes->code.need = infCodes->lbits;
			infCodes->code.tree = infCodes->ltree;
			infCodes->mode = LEN;
		// i: get length/literal/eob next
		case LEN:			
			if(!getbits(z, s, infCodes->code.need))
			{
				// We could get here because we have run out of input data *or* the stream has ended
				if(z->status == Z_BUF_ERROR)
				{
					z->error = Z_STREAM_END;
				}
				return;
			}
			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
			s->bitb >>= huft->Bits;
			s->bitk -= huft->Bits; 
			extraBits = huft->Exop;
			// literal
			if(!extraBits)				 
			{
				infCodes->lit = huft->base;
				infCodes->mode = LIT;
				break;
			}
			// length
			if(extraBits & 16) 			  
			{
				infCodes->copy.get = extraBits & 15;
				infCodes->len = huft->base;
				infCodes->mode = LENEXT;
				break;
			}
			// next table
			if(!(extraBits & 64))
			{
				infCodes->code.need = extraBits;
				infCodes->code.tree = huft + huft->base;
				break;
			}
			// end of block
			if(extraBits & 32) 			  
			{
				infCodes->mode = WASH;
				break;
			}
			// invalid code
			infCodes->mode = BADCODE;		  
			inflate_error = "Inflate data: Invalid literal/length code";
			z->error = Z_DATA_ERROR;
			inflate_flush(z, s);
			return;
		// i: getting length extra (have base)
		case LENEXT:		
			if(!getbits(z, s, infCodes->copy.get))
			{
				return;
			}
			infCodes->len += s->bitb & inflate_mask[infCodes->copy.get];
			s->bitb >>= infCodes->copy.get;
			s->bitk -= infCodes->copy.get;
			infCodes->code.need = infCodes->dbits;
			infCodes->code.tree = infCodes->dtree;
			infCodes->mode = DIST;
		// i: get distance next
		case DIST:			
			if(!getbits(z, s, infCodes->code.need))
			{
				return;
			}
			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
			s->bitb >>= huft->Bits;
			s->bitk -= huft->Bits;
			extraBits = huft->Exop;
			// distance
			if(extraBits & 16) 			  
			{
				infCodes->copy.get = extraBits & 15;
				infCodes->copy.dist = huft->base;
				infCodes->mode = DISTEXT;
				break;
			}
			// next table
			if(!(extraBits & 64))
			{
				infCodes->code.need = extraBits;
				infCodes->code.tree = huft + huft->base;
				break;
			}
			// invalid code
			infCodes->mode = BADCODE;		  
			inflate_error = "Inflate data: Invalid distance code";
			z->error = Z_DATA_ERROR;
			inflate_flush(z, s);
			return;
		// i: getting distance extra
		case DISTEXT:		
			if(!getbits(z, s, infCodes->copy.get))
			{
				return;
			}
			infCodes->copy.dist += s->bitb & inflate_mask[infCodes->copy.get];
			s->bitb >>= infCodes->copy.get;
			s->bitk -= infCodes->copy.get;
			infCodes->mode = COPY;
		// o: copying bytes in window, waiting for space
		case COPY:			
			if(s->write - s->window < infCodes->copy.dist)
			{
				src = s->end - (infCodes->copy.dist - (s->write - s->window));
			}
			else
			{
				src = s->write - infCodes->copy.dist;
			}
			while(infCodes->len)
			{
				bytesToEnd = needout(z, s, bytesToEnd);
				if(!bytesToEnd)
				{
					return;
				}
				*s->write++ = (byte)(*src++);
				bytesToEnd--;
				if(src == s->end)
				{
					src = s->window;
				}
				infCodes->len--;
			}
			infCodes->mode = START;
			break;
		// o: got literal, waiting for output space
		case LIT:			
			bytesToEnd = needout(z, s, bytesToEnd);
			if(!bytesToEnd)
			{
				return;
			}
			*s->write++ = (byte)infCodes->lit; 
			bytesToEnd--;
			infCodes->mode = START;
			break;
		// o: got eob, possibly more output
		case WASH:			
			// return unused byte, if any
			if(s->bitk > 7)		  
			{
				s->bitk -= 8;
				z->avail_in++;
				z->total_in--;
				// can always return one
				z->next_in--;			
			}
			inflate_flush(z, s);
			bytesToEnd = get_remaining(s);
			if(s->read != s->write)
			{
				inflate_error = "Inflate data: read != write while in WASH";
				inflate_flush(z, s);
				return;
			}
			infCodes->mode = END;
		case END:
			z->error = Z_STREAM_END;
			inflate_flush(z, s);
			return;
		// x: got error
		case BADCODE:		
			z->error = Z_DATA_ERROR;
			inflate_flush(z, s);
			return;
		default:
			z->error = Z_STREAM_ERROR;
			inflate_flush(z, s);
			return;
		}
	}
}

// ===============================================================================
// ===============================================================================

static inflate_codes_state_t *inflate_codes_new(z_stream *z, uint32_t bl, uint32_t bd, inflate_huft_t *lengthTree, inflate_huft_t *distTree)
{
	inflate_codes_state_t		*c;

	c = (inflate_codes_state_t *)Z_Malloc(sizeof(inflate_codes_state_t), TAG_INFLATE, qtrue);
	c->mode = START;
	c->lbits = (byte)bl;
	c->dbits = (byte)bd;
	c->ltree = lengthTree;
	c->dtree = distTree;

	return(c);
}

// ===============================================================================
// Generate Huffman trees for efficient decoding

//	uint32_t b				// code lengths in bits (all assumed <= BMAX)
//	uint32_t n             // number of codes (assumed <= 288)
//	uint32_t s             // number of simple-valued codes (0..s-1)
//	const uint32_t *d      // list of base values for non-simple codes
//	const uint32_t *e      // list of extra bits for non-simple codes
//	inflate_huft ** t	// result: starting table
//	uint32_t *m            // maximum lookup bits, returns actual
//	inflate_huft *hp    // space for trees
//	uint32_t *hn           // hufts used in space
//	uint32_t *workspace    // working area: values in order of bit length
//
//   Given a list of code lengths and a maximum table size, make a set of
//   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
//   if the given code set is incomplete (the tables are still built in this
//   case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
//   lengths).
//
//   Huffman code decoding is performed using a multi-level table lookup.
//   The fastest way to decode is to simply build a lookup table whose
//   size is determined by the longest code.  However, the time it takes
//   to build this table can also be a factor if the data being decoded
//   is not very long.  The most common codes are necessarily the
//   shortest codes, so those codes dominate the decoding time, and hence
//   the speed.  The idea is you can have a shorter table that decodes the
//   shorter, more probable codes, and then point to subsidiary tables for
//   the longer codes.  The time it costs to decode the longer codes is
//   then traded against the time it takes to make longer tables.
//
//   This results of this trade are in the variables lbits and dbits
//   below.  lbits is the number of bits the first level table for literal/
//   length codes can decode in one step, and dbits is the same thing for
//   the distance codes.  Subsequent tables are also less than or equal to
//   those sizes.  These values may be adjusted either when all of the
//   codes are shorter than that, in which case the longest code length in
//   bits is used, or when the shortest code is *longer* than the requested
//   table size, in which case the length of the shortest code in bits is
//   used.
//
//   There are two different values for the two tables, since they code a
//   different number of possibilities each.  The literal/length table
//   codes 286 possible values, or in a flat code, a little over eight
//   bits.  The distance table codes 30 possible values, or a little less
//   than five bits, flat.  The optimum values for speed end up being
//   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
//   The optimum values may differ though from machine to machine, and
//   possibly even between compilers.  Your mileage may vary.
// ===============================================================================

static EStatus huft_build(uint32_t *b, uint32_t numCodes, uint32_t s, const uint32_t *d, const uint32_t *e, inflate_huft_t **t, uint32_t *m, inflate_huft_t *hp, uint32_t *hn, uint32_t *workspace)
{
	uint32_t			codeCounter;					// counter for codes of length bitsPerCode
	uint32_t			bitLengths[BMAX + 1] = { 0 };	// bit length count table
	uint32_t			bitOffsets[BMAX + 1];			// bit offsets, then code stack
	uint32_t			f;								// i repeats in table every f entries
	int 			maxCodeLen;						// maximum code length
	int 			tableLevel;						// table level
	uint32_t			i;								// counter, current code
	uint32_t			j;								// counter
	int 			bitsPerCode;					// number of bits in current code
	uint32_t 			bitsPerTable;					// bits per table (returned in m)
	int 			bitsBeforeTable;				// bits before this table == (bitsPerTable * tableLevel)
	uint32_t			*p; 							// pointer into bitLengths[], b[], or workspace[]
	inflate_huft_t	*q; 							// points to current table
	inflate_huft_t	r;								// table entry for structure assignment
	inflate_huft_t	*tableStack[BMAX];				// table stack
	uint32_t			*xp;							// pointer into bitOffsets
	int 			dummyCodes;						// number of dummy codes added
	uint32_t			entryCount;						// number of entries in current table

	// Generate counts for each bit length
	// assume all entries <= BMAX
	p = b;	
	i = numCodes;
	do
	{
		bitLengths[*p++]++;					
	} while(--i);

	// null input--all zero length codes
	if(bitLengths[0] == numCodes)				  
	{
		*t = NULL;
		*m = 0;
		return(Z_OK);
	}

	// Find minimum and maximum length, bound *m by those
	bitsPerTable = *m;
	for(j = 1; j <= BMAX; j++)
	{
		if(bitLengths[j])
		{
			break;
		}
	}
	// minimum code length
	bitsPerCode = j;						  

	if(bitsPerTable < j)
	{
		bitsPerTable = j;
	}
	for(i = BMAX; i; i--)
	{
		if(bitLengths[i])
		{
			break;
		}
	}
	// maximum code length
	maxCodeLen = i;						  

	if(bitsPerTable > i)
	{
		bitsPerTable = i;
	}
	*m = bitsPerTable;

	// Adjust last length count to fill out codes, if needed
	for(dummyCodes = 1 << j; j < i; j++, dummyCodes <<= 1)
	{
		dummyCodes -= bitLengths[j];
		if(dummyCodes < 0)
		{
			return(Z_DATA_ERROR);
		}
	}
	dummyCodes -= bitLengths[i];
	if(dummyCodes < 0)
	{
		return(Z_DATA_ERROR);
	}
	bitLengths[i] += dummyCodes;

	// Generate starting offsets into the value table for each length
	bitOffsets[1] = 0;
	j = 0;
	p = bitLengths + 1;
	xp = bitOffsets + 2;
	// note that i == maxCodeLen from above
	while(--i) 
	{			 
		j += *p++;
		*xp++ = j;
	}

	// Make a table of values in order of bit lengths
	p = b;
	i = 0;
	do
	{
		j = *p++;
		if(j)
		{
			workspace[bitOffsets[j]++] = i;
		}
	} while(++i < numCodes);

	// set numCodes to length of workspace
	numCodes = bitOffsets[maxCodeLen];					  

	// Generate the Huffman codes and for each, make the table entries
	bitOffsets[0] = 0;						// first Huffman code is zero
	i = 0;							
	p = workspace;							// grab values in bit order
	tableLevel = -1; 						// no tables yet--level -1
	bitsBeforeTable = bitsPerTable; 						// bits decoded == (bitsPerTable * tableLevel)
	bitsBeforeTable = -bitsBeforeTable;
	tableStack[0] = NULL;	// just to keep compilers happy
	q = NULL;		// ditto
	entryCount = 0;							// ditto

	// go through the bit lengths (bitsPerCode already is bits in shortest code)
	for(; bitsPerCode <= maxCodeLen; bitsPerCode++)
	{
		codeCounter = bitLengths[bitsPerCode];
		while(codeCounter--)
		{
			// here i is the Huffman code of length bitsPerCode bits for value *p
			// make tables up to required level
			while(bitsPerCode > bitsBeforeTable + bitsPerTable)
			{
				tableLevel++;
				bitsBeforeTable += bitsPerTable; 			// previous table always bitsPerTable bits

				// compute minimum size table less than or equal to bitsPerTable bits
				entryCount = maxCodeLen - bitsBeforeTable;
				entryCount = entryCount > bitsPerTable ? bitsPerTable : entryCount;				// table size upper limit
				j = bitsPerCode - bitsBeforeTable;
				f = 1 << j;
				if(f > codeCounter + 1)							// try a bitsPerCode-bitsBeforeTable bit table
				{										// too few codes for bitsPerCode-bitsBeforeTable bit table
					f -= codeCounter + 1; 						// deduct codes from patterns left
					xp = bitLengths + bitsPerCode;
					if(j < entryCount)
					{
						while(++j < entryCount) 					// try smaller tables up to entryCount bits
						{
							f <<= 1;
							if(f <= *++xp)
							{
								break;					// enough codes to use up j bits
							}
							f -= *xp;					// else deduct codes from patterns
						}
					}
				}
				entryCount = 1 << j; 							// table entries for j-bit table

				// allocate new table
				if(*hn + entryCount > MANY) 						// (note: doesn't matter for fixed)
				{
					return(Z_DATA_ERROR);				// not enough memory
				}
				q = hp + *hn;
				tableStack[tableLevel] = q;
				*hn += entryCount;

				// connect to last table, if there is one
				if(tableLevel)
				{
					bitOffsets[tableLevel] = i;							// save pattern for backing up
					r.Bits = (byte)bitsPerTable;   	 					// bits to dump before this table
					r.Exop = (byte)j;									// bits in this table
					j = i >> (bitsBeforeTable - bitsPerTable);
					r.base = q - tableStack[tableLevel - 1] - j; // offset to this table
					tableStack[tableLevel - 1][j] = r;					// connect to last table
				}
				else						   
				{
					*t = q; 							// first table is returned result
				}
			}

			// set up table entry in r
			r.Bits = (byte)(bitsPerCode - bitsBeforeTable);
			if(p >= workspace + numCodes)
			{
				r.Exop = 128 + 64;						// out of values--invalid code
			}
			else if(*p < s)
			{
				r.Exop = (byte)(*p < 256 ? 0 : 32 + 64);		// 256 is end-of-block
				r.base = *p++;							// simple code is just the value
			}
			else
			{
				r.Exop = (byte)(e[*p - s] + 16 + 64);		 	// non-simple--look up in lists
				r.base = d[*p++ - s];
			}

			// fill code-like entries with r
			f = 1 << (bitsPerCode - bitsBeforeTable);
			for(j = i >> bitsBeforeTable; j < entryCount; j += f)
			{
				q[j] = r;
			}

			// backwards increment the bitsPerCode-bit code i
			for(j = 1 << (bitsPerCode - 1); i & j; j >>= 1)
			{
				i ^= j;
			}
			i ^= j;

			// backup over finished tables
			while((i & ((1 << bitsBeforeTable) - 1)) != bitOffsets[tableLevel])
			{
				tableLevel--;									// don't need to update q
				bitsBeforeTable -= bitsPerTable;
			}
		}
	}

	// Return Z_BUF_ERROR if we were given an incomplete table
	if(dummyCodes && (maxCodeLen != 1))
	{
		return(Z_BUF_ERROR);
	}
	return(Z_OK);
}

// ===============================================================================
// uint32_t *c 				19 code lengths
// uint32_t *bb				bits tree desired/actual depth
// inflate_huft **tb		bits tree result
// inflate_huft *hp 		space for trees
// ===============================================================================

static void inflate_trees_bits(z_stream *z, uint32_t *c, uint32_t *bb, inflate_huft_t **tb, inflate_huft_t *hp)
{
	uint32_t	hn = 0;				// hufts used in space
	uint32_t	workspace[19];		// work area for huft_build

	z->error = huft_build(c, 19, 19, NULL, NULL, tb, bb, hp, &hn, workspace);
	if(z->error == Z_DATA_ERROR)
	{
		inflate_error = "Inflate data: Oversubscribed dynamic bit lengths tree";
	}
	else if((z->error == Z_BUF_ERROR) || !*bb)
	{
		inflate_error = "Inflate data: Incomplete dynamic bit lengths tree";
		z->error = Z_DATA_ERROR;
	}
}

// ===============================================================================
// uint32_t *c 				// that many (total) code lengths
// uint32_t *bl				// literal desired/actual bit depth
// uint32_t *bd				// distance desired/actual bit depth
// inflate_huft **tl		// literal/length tree result
// inflate_huft **td		// distance tree result
// inflate_huft *hp 		// space for trees
// ===============================================================================

static void inflate_trees_dynamic(z_stream *z, uint32_t numLiteral, uint32_t numDist, uint32_t *c, uint32_t *bl, uint32_t *bd, inflate_huft_t **tl, inflate_huft_t **td, inflate_huft_t *hp)
{
	uint32_t		hn = 0;				// hufts used in space
	uint32_t		workspace[288]; 	// work area for huft_build

	// build literal/length tree
	z->error = huft_build(c, numLiteral, 257, cplens, cplext, tl, bl, hp, &hn, workspace);
	if(z->error != Z_OK || !*bl)
	{
		inflate_error = "Inflate data: Erroneous literal/length tree";
		z->error = Z_DATA_ERROR;
		return;
	}
	// build distance tree
	z->error = huft_build(c + numLiteral, numDist, 0, cpdist, extra_dbits, td, bd, hp, &hn, workspace);
	if((z->error != Z_OK) || (!*bd && numLiteral > 257))
	{
		inflate_error = "Inflate data: Erroneous distance tree";
		z->error = Z_DATA_ERROR;
		return;
	}
}

// ===============================================================================
// uint32_t *bl				// literal desired/actual bit depth
// uint32_t *bd				// distance desired/actual bit depth
// inflate_huft **tl		// literal/length tree result
// inflate_huft **td		// distance tree result
// ===============================================================================

// Fixme: Calculate dynamically

static void inflate_trees_fixed(z_stream *z, uint32_t *bl, uint32_t *bd, inflate_huft_t **tl, inflate_huft_t **td)
{
	*bl = fixed_bl;
	*bd = fixed_bd;
	*tl = fixed_tl;
	*td = fixed_td;
	z->error = Z_OK;
}

// ===============================================================================
// ===============================================================================

static void inflate_blocks(inflate_blocks_state_t *s, z_stream *z)
{
	uint32_t					t;				// temporary storage
	uint32_t					bytesToEnd;		// bytes to end of window or read pointer
	uint32_t					bl, bd;
	inflate_huft_t			*lengthTree = NULL;
	inflate_huft_t			*distTree = NULL;
	inflate_codes_state_t	*c;

	// copy input/output information to locals (UPDATE macro restores)
	bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 

	// process input based on current state
	while(true)
	{
		switch (s->mode)
		{
		case TYPE:
			if(!getbits(z, s, 3))
			{
				return;
			}
			t = s->bitb & 7;
			s->last = !!(t & 1);

			switch (t >> 1)
			{
			case STORED_BLOCK:
				s->bitb >>= 3;
				s->bitk -= 3;
				t = s->bitk & 7;				// go to byte boundary
				s->bitb >>= t;
				s->bitk -= t;
				s->mode = LENS; 				// get length of stored block
				break;
			case STATIC_TREES:
				inflate_trees_fixed(z, &bl, &bd, &lengthTree, &distTree);
				s->decode.codes = inflate_codes_new(z, bl, bd, lengthTree, distTree);
				s->bitb >>= 3;
				s->bitk -= 3;
				s->mode = CODES;
				break;
			case DYN_TREES:
				s->bitb >>= 3;
				s->bitk -= 3;
				s->mode = TABLE;
				break;
			case MODE_ILLEGAL:
				s->bitb >>= 3;
				s->bitk -= 3;
				s->mode = BAD;
				inflate_error = "Inflate data: Invalid block type";
				z->error = Z_DATA_ERROR;
				inflate_flush(z, s);
				return;
			}
			break;
		case LENS:
			if(!getbits(z, s, 32))
			{
				return;
			}
			if(((~s->bitb) >> 16) != (s->bitb & 0xffff))
			{
				s->mode = BAD;
				inflate_error = "Inflate data: Invalid stored block lengths";
				z->error = Z_DATA_ERROR;
				inflate_flush(z, s);
				return;
			}
			s->left = s->bitb & 0xffff;
			s->bitb = 0;
			s->bitk = 0;								// dump bits
			s->mode = s->left ? STORED : (s->last ? DRY : TYPE);
			break;
		case STORED:
			if(!z->avail_in)
			{
				inflate_flush(z, s);
				return;
			}
			bytesToEnd = needout(z, s, bytesToEnd);
			if(!bytesToEnd)
			{
				return;
			}
			t = s->left;
			if(t > z->avail_in) 
			{
				t = z->avail_in;
			}
			if(t > bytesToEnd) 
			{
				t = bytesToEnd;
			}
			memcpy(s->write, z->next_in, t);
			z->next_in += t;
			z->avail_in -= t;
			z->total_in += t;
			s->write += t;
			bytesToEnd -= t;
			s->left -= t;
			if(s->left)
			{
				break;
			}
			s->mode = s->last ? DRY : TYPE;
			break;
		case TABLE:
			if(!getbits(z, s, 14))
			{
				return;
			}
			t = s->bitb & 0x3fff;
			s->trees.table = t;
			if((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
			{
				s->mode = BAD;
				inflate_error = "Inflate data: Too many length or distance symbols";
				z->error = Z_DATA_ERROR;
				inflate_flush(z, s);
				return;
			}
			t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
			s->trees.blens = (uint32_t *)Z_Malloc(t * sizeof(uint32_t), TAG_INFLATE, qfalse);
			s->bitb >>= 14;
			s->bitk -= 14;
			s->trees.index = 0;
			s->mode = BTREE;
		case BTREE:
			while(s->trees.index < 4 + (s->trees.table >> 10))
			{
				if(!getbits(z, s, 3))
				{
					return;
				}
				s->trees.blens[border[s->trees.index++]] = s->bitb & 7;
				s->bitb >>= 3;
				s->bitk -= 3;
			}
			while(s->trees.index < 19)
			{
				s->trees.blens[border[s->trees.index++]] = 0;
			}
			s->trees.bb = 7;
			inflate_trees_bits(z, s->trees.blens, &s->trees.bb, &s->trees.tb, s->hufts);
			if(z->error != Z_OK)
			{
				Z_Free(s->trees.blens);
				s->mode = BAD;
				inflate_flush(z, s);
				return;
			}
			s->trees.index = 0;
			s->mode = DTREE;
		case DTREE:
			while(t = s->trees.table, s->trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
			{
				inflate_huft_t *h;
				uint32_t i, j, c;

				t = s->trees.bb;
				if(!getbits(z, s, t))
				{
					return;
				}
				h = s->trees.tb + (s->bitb & inflate_mask[t]);
				t = h->Bits;
				c = h->base;
				if(c < 16)
				{
					s->bitb >>= t;
					s->bitk -= t;
					s->trees.blens[s->trees.index++] = c;
				}
				else	// c == 16..18
				{
					i = (c == 18) ? 7 : c - 14;
					j = (c == 18) ? 11 : 3;
					if(!getbits(z, s, t + i))
					{
						return;
					}
					s->bitb >>= t;
					s->bitk -= t;
					j += s->bitb & inflate_mask[i];
					s->bitb >>= i;
					s->bitk -= i;
					i = s->trees.index;
					t = s->trees.table;
					if(i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
					{
						Z_Free(s->trees.blens);
						s->mode = BAD;
						inflate_error = "Inflate data: Invalid bit length repeat";
						z->error = Z_DATA_ERROR;
						inflate_flush(z, s);
						return;
					}
					c = (c == 16) ? s->trees.blens[i - 1] : 0;
					do
					{
						s->trees.blens[i++] = c;
					} while(--j);
					s->trees.index = i;
				}
			}
			s->trees.tb = NULL;

			bl = 9; 					// must be <= 9 for lookahead assumptions
			bd = 6; 					// must be <= 9 for lookahead assumptions
			t = s->trees.table;
			inflate_trees_dynamic(z, 257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), s->trees.blens, &bl, &bd, &lengthTree, &distTree, s->hufts);
			Z_Free(s->trees.blens);
			if(z->error != Z_OK)
			{
				s->mode = BAD;
				inflate_flush(z, s);
				return;
			}
			c = inflate_codes_new(z, bl, bd, lengthTree, distTree);
			s->decode.codes = c;
			s->mode = CODES;
		case CODES:
			inflate_codes(z, s);
			if(z->error != Z_STREAM_END)
			{
				inflate_flush(z, s);
				return;
			}
			z->error = Z_OK;
			Z_Free(s->decode.codes);
			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 
			if(!s->last)
			{
				s->mode = TYPE;
				break;
			}
			s->mode = DRY;
		case DRY:
			inflate_flush(z, s);
			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
			if(s->read != s->write)
			{
				inflate_error = "Inflate data: read != write in DRY";
				inflate_flush(z, s);
				return;
			}
			s->mode = DONE;
		case DONE:
			z->error = Z_STREAM_END;
			inflate_flush(z, s);
			return;
		case BAD:
		default:
			z->error = Z_DATA_ERROR;
			inflate_flush(z, s);
			return;
		}
	}
}

// -------------------------------------------------------------------------------------------------
// Controlling routines
// -------------------------------------------------------------------------------------------------

EStatus inflateEnd(z_stream *z)
{
	assert(z);

	if(z->istate->blocks)
	{
		inflate_blocks_free(z, z->istate->blocks);
		z->istate->blocks = NULL;
	}
	if(z->istate)
	{
		Z_Free(z->istate);
		z->istate = NULL;
	}
	return(Z_OK);
}

// ===============================================================================
// ===============================================================================

EStatus inflateInit(z_stream *z, EFlush flush, int noWrap)
{
	// initialize state
	assert(z);

	inflate_error = "OK";

	z->istate = (inflate_state *)Z_Malloc(sizeof(inflate_state), TAG_INFLATE, qtrue);
	z->istate->blocks = NULL;

	// handle nowrap option (no zlib header or check)
	z->istate->nowrap = noWrap;
	z->istate->wbits = MAX_WBITS;

	// create inflate_blocks state
	z->istate->blocks = inflate_blocks_new(z, NULL);

	z->status = Z_OK;
	if(flush == Z_FINISH)
	{
		z->status = Z_BUF_ERROR;
	}

	// reset state
	z->istate->mode = imMETHOD;
	if(z->istate->nowrap)
	{
		z->istate->mode = imBLOCKS;
	}
	inflate_blocks_reset(z, z->istate->blocks);
	return(Z_OK);
}

// ===============================================================================
// ===============================================================================

EStatus inflate(z_stream *z)
{
	uint32_t		b;

	// Sanity check data
	assert(z);
	assert(z->istate);

	while(true)
	{
		switch (z->istate->mode)
		{
		case imMETHOD:
			if(!z->avail_in)
			{
				return(z->status);
			}
			z->istate->method = *z->next_in++;
			z->avail_in--;
			z->total_in++;
			if((z->istate->method & 0xf) != ZF_DEFLATED)
			{
				z->istate->mode = imBAD;
				inflate_error = "Inflate data: Unknown compression method";
				return(Z_DATA_ERROR);
			}
			if((z->istate->method >> 4) + 8 > z->istate->wbits)
			{
				z->istate->mode = imBAD;
				inflate_error = "Inflate data: Invalid window size";
				return(Z_DATA_ERROR);
			}
			z->istate->mode = imFLAG;
			break;
		case imFLAG:
			if(!z->avail_in)
			{
				return(z->status);
			}
			b = *z->next_in++;
			z->avail_in--;
			z->total_in++;
			if(((z->istate->method << 8) + b) % 31)
			{
				z->istate->mode = imBAD;
				inflate_error = "Inflate data: Incorrect header check";
				return(Z_DATA_ERROR);
			}
			z->istate->mode = imBLOCKS;
			break;
		case imBLOCKS:
			inflate_blocks(z->istate->blocks, z);
			
			// Make sure everything processed ok
			if(z->error == Z_DATA_ERROR)
			{
				z->istate->mode = imBAD;
				return(Z_DATA_ERROR);
			}

			if(z->error != Z_STREAM_END)
			{
				return(z->status);
			}
			z->istate->calcadler = z->istate->adler;
			inflate_blocks_reset(z, z->istate->blocks);
			if(z->istate->nowrap)
			{
				z->istate->mode = imDONE;
				break;
			}
			z->istate->mode = imCHECK4;
			break;
		case imCHECK4:
			if(!z->avail_in)
			{
				return(z->status);
			}
			z->istate->adler = *z->next_in++ << 24;
			z->avail_in--;
			z->total_in++;
			z->istate->mode = imCHECK3;
			break;
		case imCHECK3:
			if(!z->avail_in)
			{
				return(z->status);
			}
			z->istate->adler += *z->next_in++ << 16;
			z->avail_in--;
			z->total_in++;
			z->istate->mode = imCHECK2;
			break;
		case imCHECK2:
			if(!z->avail_in)
			{
				return(z->status);
			}
			z->istate->adler += *z->next_in++ << 8;
			z->avail_in--;
			z->total_in++;
			z->istate->mode = imCHECK1;
			break;
		case imCHECK1:
			if(!z->avail_in)
			{
				return(z->status);
			}
			z->istate->adler += *z->next_in++;
			z->avail_in--;
			z->total_in++;

			if(z->istate->calcadler != z->istate->adler)
			{
				inflate_error = "Inflate data: Failed Adler checksum";
				z->istate->mode = imBAD;
				break;
			}
			z->istate->mode = imDONE;
			break;
		case imDONE:
			return(Z_STREAM_END);
		case imBAD:
			return(Z_DATA_ERROR);
		default:
			return(Z_STREAM_ERROR);
		}
	}
	assert(0);
	return(Z_OK);
}

// ===============================================================================
// ===============================================================================

const char *inflateError(void)
{
	return(inflate_error);
}

// ===============================================================================
// External calls
// ===============================================================================

bool InflateFile(byte *src, uint32_t compressedSize, byte *dst, uint32_t uncompressedSize, int noWrap)
{
	z_stream	z = { 0 };

	inflateInit(&z, Z_FINISH, noWrap);

	z.next_in = src;
	z.avail_in = compressedSize;
	z.next_out = dst;
	z.avail_out = uncompressedSize;

#ifdef _TIMING
	int temp = timeGetTime();
#endif
	if(inflate(&z) != Z_STREAM_END)
	{
		inflate_error = "Inflate data: Stream did not end";
		inflateEnd(&z);
		return(false);
	}
#ifdef _TIMING
	totalInflateTime += timeGetTime() - temp;
	totalInflateCount++;
#endif

	if(z.avail_in)
	{
		inflate_error = "Inflate data: Remaining input data at stream end";
		inflateEnd(&z);
		return(false);
	}
	if(z.avail_out)
	{
		inflate_error = "Inflate data: Remaining output space at stream end";
		inflateEnd(&z);
		return(false);
	}
	if(z.total_in != compressedSize)
	{
		inflate_error = "Inflate data: Number of processed bytes != compressed size";
		inflateEnd(&z);
		return(false);
	}
	if(z.total_out != uncompressedSize)
	{
		inflate_error = "Inflate data: Number of bytes output != uncompressed size";
		inflateEnd(&z);
		return(false);
	}
	inflateEnd(&z);
	return(true);
}

// end