Merge remote-tracking branch 'origin/master'

[unleashed/lotheac.git] / usr / src / uts / common / io / ppp / spppcomp / zlib.c

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Updated from zlib-1.0.4 to zlib-1.1.3 by James Carlson.
 *
 * This file is derived from various .h and .c files from the zlib-1.0.4
 * distribution by Jean-loup Gailly and Mark Adler, with some additions
 * by Paul Mackerras to aid in implementing Deflate compression and
 * decompression for PPP packets.  See zlib.h for conditions of
 * distribution and use.
 *
 * Changes that have been made include:
 * - added Z_PACKET_FLUSH (see zlib.h for details)
 * - added inflateIncomp and deflateOutputPending
 * - allow strm->next_out to be NULL, meaning discard the output
 *
 * $Id: zlib.c,v 1.11 1998/09/13 23:37:12 paulus Exp $
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

/*
 *  ==FILEVERSION 971210==
 *
 * This marker is used by the Linux installation script to determine
 * whether an up-to-date version of this file is already installed.
 */

#define NO_DUMMY_DECL
#define NO_ZCFUNCS
#define MY_ZCALLOC

#if defined(__FreeBSD__) && (defined(KERNEL) || defined(_KERNEL))
#define inflate inflate_ppp     /* FreeBSD already has an inflate :-( */
#endif


/* +++ zutil.h */
/*
 *
 * zutil.h -- internal interface and configuration of the compression library
 * Copyright (C) 1995-1998 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

/* From: zutil.h,v 1.16 1996/07/24 13:41:13 me Exp $ */

#ifndef _Z_UTIL_H
#define _Z_UTIL_H

#include "zlib.h"

#if defined(KERNEL) || defined(_KERNEL)
/* Assume this is a *BSD or SVR4 kernel */
#include <sys/types.h>
#include <sys/time.h>
#include <sys/systm.h>
#ifdef SOL2
#include <sys/cmn_err.h>
#endif
#define HAVE_MEMCPY
#define memcmp          bcmp

#else
#if defined(__KERNEL__)
/* Assume this is a Linux kernel */
#include <linux/string.h>
#define HAVE_MEMCPY

#else /* not kernel */

#include <stddef.h>
#ifdef NO_ERRNO_H
extern int errno;
#else
#include <errno.h>
#endif
#ifdef STDC
#include <string.h>
#include <stdlib.h>
#endif
#endif /* __KERNEL__ */
#endif /* _KERNEL || KERNEL */

#ifndef local
#define local static
#endif
/* compile with -Dlocal if your debugger can't find static symbols */

typedef unsigned char  uch;
typedef uch FAR uchf;
typedef unsigned short ush;
typedef ush FAR ushf;
typedef unsigned long  ulg;

static const char *z_errmsg[10]; /* indexed by 2-zlib_error */
/* (size given to avoid silly warnings with Visual C++) */

#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]

#define ERR_RETURN(strm, err) \
        return (strm->msg = ERR_MSG(err), (err))
/* To be used only when the state is known to be valid */

        /* common constants */

#ifndef DEF_WBITS
#define DEF_WBITS MAX_WBITS
#endif
/* default windowBits for decompression. MAX_WBITS is for compression only */

#if MAX_MEM_LEVEL >= 8
#define DEF_MEM_LEVEL 8
#else
#define DEF_MEM_LEVEL  MAX_MEM_LEVEL
#endif
/* default memLevel */

#define STORED_BLOCK 0
#define STATIC_TREES 1
#define DYN_TREES    2
/* The three kinds of block type */

#define MIN_MATCH  3
#define MAX_MATCH  258
/* The minimum and maximum match lengths */

#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */

        /* target dependencies */

#ifdef MSDOS
#define OS_CODE  0x00
#ifdef __TURBOC__
#include <alloc.h>
#else /* MSC or DJGPP */
#include <malloc.h>
#endif
#endif

#ifdef OS2
#define OS_CODE  0x06
#endif

#ifdef WIN32 /* Window 95 & Windows NT */
#define OS_CODE  0x0b
#endif

#if defined(VAXC) || defined(VMS)
#define OS_CODE  0x02
#define F_OPEN(name, mode) \
        fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
#endif

#ifdef AMIGA
#define OS_CODE  0x01
#endif

#if defined(ATARI) || defined(atarist)
#define OS_CODE  0x05
#endif

#ifdef MACOS
#define OS_CODE  0x07
#endif

#ifdef __50SERIES /* Prime/PRIMOS */
#define OS_CODE  0x0F
#endif

#ifdef TOPS20
#define OS_CODE  0x0a
#endif

#if defined(_BEOS_) || defined(RISCOS)
#define fdopen(fd, mode) NULL /* No fdopen() */
#endif

        /* Common defaults */

#ifndef OS_CODE
#define OS_CODE  0x03  /* assume Unix */
#endif

#ifndef F_OPEN
#define F_OPEN(name, mode) fopen((name), (mode))
#endif

        /* functions */

#ifdef HAVE_STRERROR
extern char *strerror OF((int));
#define zstrerror(errnum) strerror(errnum)
#else
#define zstrerror(errnum) ""
#endif

#if defined(pyr)
#define NO_MEMCPY
#endif
#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(_MSC_VER)
/*
 * Use our own functions for small and medium model with MSC <= 5.0.
 * You may have to use the same strategy for Borland C (untested).
 */
#define NO_MEMCPY
#endif
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
#define HAVE_MEMCPY
#endif
#ifdef HAVE_MEMCPY
#ifdef SMALL_MEDIUM /* MSDOS small or medium model */
#define zmemcpy _fmemcpy
#define zmemcmp _fmemcmp
#define zmemzero(dest, len) _fmemset(dest, 0, len)
#else
#define zmemcpy (void) memcpy
#define zmemcmp memcmp
#define zmemzero(dest, len) (void) memset(dest, 0, len)
#endif
#else
extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
extern void zmemzero OF((Bytef* dest, uInt len));
#endif

/* Diagnostic functions */
#ifdef DEBUG_ZLIB
#include <stdio.h>
#ifndef verbose
#define verbose 0
#endif
extern void z_error    OF((char *m));
#define Assert(cond, msg) { if (!(cond)) z_error(msg); }
#define Trace(x) {if (z_verbose >= 0) fprintf x; }
#define Tracev(x) {if (z_verbose > 0) fprintf x; }
#define Tracevv(x) {if (z_verbose > 1) fprintf x; }
#define Tracec(c, x) {if (z_verbose > 0 && (c)) fprintf x; }
#define Tracecv(c, x) {if (z_verbose > 1 && (c)) fprintf x; }
#else
#if defined(SOL2) && defined(DEBUG)
#define Assert(cond, msg)       ((cond) ? ((void)0) : panic(msg))
#else
#define Assert(cond, msg)       ((void)0)
#endif
#define Trace(x)        ((void)0)
#define Tracev(x)       ((void)0)
#define Tracevv(x)      ((void)0)
#define Tracec(c, x)    ((void)0)
#define Tracecv(c, x)   ((void)0)
#endif


typedef uLong (*check_func) OF((uLong check, const Bytef *buf, uInt len));

/* voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); */
/* void   zcfree  OF((voidpf opaque, voidpf ptr)); */

#define ZALLOC(strm, items, size) \
        (*((strm)->zalloc))((strm)->opaque, (items), (size))
#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
#define TRY_FREE(s, p) {if (p) ZFREE(s, p); }

#endif /* _Z_UTIL_H */
/* --- zutil.h */

/* +++ deflate.h */
/*
 * deflate.h -- internal compression state
 * Copyright (C) 1995-1998 Jean-loup Gailly
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

/* From: deflate.h,v 1.10 1996/07/02 12:41:00 me Exp $ */

#ifndef _DEFLATE_H
#define _DEFLATE_H

/* #include "zutil.h" */

/*
 * ===========================================================================
 * Internal compression state.
 */

#define LENGTH_CODES 29
/* number of length codes, not counting the special END_BLOCK code */

#define LITERALS  256
/* number of literal bytes 0..255 */

#define L_CODES (LITERALS+1+LENGTH_CODES)
/* number of Literal or Length codes, including the END_BLOCK code */

#define D_CODES   30
/* number of distance codes */

#define BL_CODES  19
/* number of codes used to transfer the bit lengths */

#define HEAP_SIZE (2*L_CODES+1)
/* maximum heap size */

#define MAX_BITS 15
/* All codes must not exceed MAX_BITS bits */

#define INIT_STATE    42
#define BUSY_STATE   113
#define FINISH_STATE 666
/* Stream status */


/* Data structure describing a single value and its code string. */
typedef struct ct_data_s {
        union {
                ush freq;       /* frequency count */
                ush code;       /* bit string */
        } fc;
        union {
                ush dad;        /* father node in Huffman tree */
                ush len;        /* length of bit string */
        } dl;
} FAR ct_data;

#define Freq fc.freq
#define Code fc.code
#define Dad  dl.dad
#define Len  dl.len

typedef struct static_tree_desc_s  static_tree_desc;

typedef struct tree_desc_s {
        ct_data *dyn_tree;      /* the dynamic tree */
        int     max_code;       /* largest code with non zero frequency */
        static_tree_desc *stat_desc;    /* the corresponding static tree */
} FAR tree_desc;

typedef ush Pos;
typedef Pos FAR Posf;
typedef unsigned IPos;

/*
 * A Pos is an index in the character window. We use short instead of
 * int to save space in the various tables. IPos is used only for
 * parameter passing.
 */

typedef struct deflate_state {
        z_streamp strm; /* pointer back to this zlib stream */
        int   status;   /* as the name implies */
        Bytef *pending_buf;     /* output still pending */
        ulg   pending_buf_size; /* size of pending_buf */
        Bytef *pending_out;     /* next pending byte to output to the stream */
        int   pending;  /* nb of bytes in the pending buffer */
        int   noheader; /* suppress zlib header and adler32 */
        Byte  data_type;        /* UNKNOWN, BINARY or ASCII */
        Byte  method;   /* STORED (for zip only) or DEFLATED */
        /* value of flush param for previous deflate call */
        int   last_flush;

        /* used by deflate.c: */

        uInt  w_size;   /* LZ77 window size (32K by default) */
        uInt  w_bits;   /* log2(w_size)  (8..16) */
        uInt  w_mask;   /* w_size - 1 */

        Bytef *window;
        /*
         * Sliding window. Input bytes are read into the second half
         * of the window, and move to the first half later to keep a
         * dictionary of at least wSize bytes. With this organization,
         * matches are limited to a distance of wSize-MAX_MATCH bytes,
         * but this ensures that IO is always performed with a length
         * multiple of the block size. Also, it limits the window size
         * to 64K, which is quite useful on MSDOS.  To do: use the
         * user input buffer as sliding window.
         */

        ulg window_size;
        /*
         * Actual size of window: 2*wSize, except when the user input
         * buffer is directly used as sliding window.
         */

        Posf *prev;
        /*
         * Link to older string with same hash index. To limit the
         * size of this array to 64K, this link is maintained only for
         * the last 32K strings.  An index in this array is thus a
         * window index modulo 32K.
         */

        Posf *head;     /* Heads of the hash chains or NIL. */

        uInt  ins_h;    /* hash index of string to be inserted */
        uInt  hash_size;        /* number of elements in hash table */
        uInt  hash_bits;        /* log2(hash_size) */
        uInt  hash_mask;        /* hash_size-1 */

        uInt  hash_shift;
        /*
         * Number of bits by which ins_h must be shifted at each input
         * step. It must be such that after MIN_MATCH steps, the
         * oldest byte no longer takes part in the hash key, that is:
         * hash_shift * MIN_MATCH >= hash_bits
         */

        long block_start;
        /*
         * Window position at the beginning of the current output
         * block. Gets negative when the window is moved backwards.
         */

        uInt match_length;      /* length of best match */
        IPos prev_match;        /* previous match */
        int match_available;    /* set if previous match exists */
        uInt strstart;  /* start of string to insert */
        uInt match_start;       /* start of matching string */
        uInt lookahead; /* number of valid bytes ahead in window */

        uInt prev_length;
        /*
         * Length of the best match at previous step. Matches not
         * greater than this are discarded. This is used in the lazy
         * match evaluation.
         */

        uInt max_chain_length;
        /*
         * To speed up deflation, hash chains are never searched
         * beyond *this length.  A higher limit improves compression
         * ratio but *degrades the speed.
         */

        uInt max_lazy_match;
        /*
         * Attempt to find a better match only when the current match
         * is strictly smaller than this value. This mechanism is used
         * only for compression levels >= 4.
         */
#define max_insert_length  max_lazy_match
        /*
         * Insert new strings in the hash table only if the match
         * length is not greater than this length. This saves time but
         * degrades compression.  max_insert_length is used only for
         * compression levels <= 3.
         */

        int level;      /* compression level (1..9) */
        int strategy;   /* favor or force Huffman coding */

        uInt good_match;
        /* Use a faster search when the previous match is longer than this */

        int nice_match; /* Stop searching when current match exceeds this */

        /* used by trees.c: */
        /* Didn't use ct_data typedef below to supress compiler warning */
        struct ct_data_s dyn_ltree[HEAP_SIZE];  /* literal and length tree */
        struct ct_data_s dyn_dtree[2*D_CODES+1];        /* distance tree */
        /* Huffman tree for bit lengths */
        struct ct_data_s bl_tree[2*BL_CODES+1];

        struct tree_desc_s l_desc;      /* desc. for literal tree */
        struct tree_desc_s d_desc;      /* desc. for distance tree */
        struct tree_desc_s bl_desc;     /* desc. for bit length tree */

        ush bl_count[MAX_BITS+1];
        /* number of codes at each bit length for an optimal tree */

        int heap[2*L_CODES+1];  /* heap used to build the Huffman trees */
        int heap_len;   /* number of elements in the heap */
        int heap_max;   /* element of largest frequency */
        /*
         * The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0]
         * is not used.  The same heap array is used to build all
         * trees.
         */

        uch depth[2*L_CODES+1];
        /*
         * Depth of each subtree used as tie breaker for trees of
         * equal frequency
         */

        uchf *l_buf;    /* buffer for literals or lengths */

        uInt lit_bufsize;
        /*
         * Size of match buffer for literals/lengths.  There are 4
         * reasons for limiting lit_bufsize to 64K:
         *
         *   - frequencies can be kept in 16 bit counters
         *
         *   - if compression is not successful for the first block,
         *   all input data is still in the window so we can still
         *   emit a stored block even when input comes from standard
         *   input.  (This can also be done for all blocks if
         *   lit_bufsize is not greater than 32K.)
         *
         *   - if compression is not successful for a file smaller
         *   than 64K, we can even emit a stored file instead of a
         *   stored block (saving 5 bytes).  This is applicable only
         *   for zip (not gzip or zlib).
         *
         *   - creating new Huffman trees less frequently may not
         *   provide fast adaptation to changes in the input data
         *   statistics. (Take for example a binary file with poorly
         *   compressible code followed by a highly compressible
         *   string table.) Smaller buffer sizes give fast adaptation
         *   but have of course the overhead of transmitting trees
         *   more frequently.
         *
         *   - I can't count above 4
         */

        uInt last_lit;  /* running index in l_buf */

        ushf *d_buf;
        /*
         * Buffer for distances. To simplify the code, d_buf and l_buf
         * have the same number of elements. To use different lengths,
         * an extra flag array would be necessary.
         */

        ulg opt_len;    /* bit length of current block with optimal trees */
        ulg static_len; /* bit length of current block with static trees */
        uInt matches;   /* number of string matches in current block */
        int last_eob_len;       /* bit length of EOB code for last block */

        ulg compressed_len;     /* total bit length of compressed file PPP */
#ifdef DEBUG_ZLIB
        ulg bits_sent;  /* bit length of the compressed data */
#endif

        ush bi_buf;
        /*
         * Output buffer. bits are inserted starting at the bottom
         * (least significant bits).
         */
        int bi_valid;
        /*
         * Number of valid bits in bi_buf.  All bits above the last
         * valid bit are always zero.
         */

} FAR deflate_state;

/*
 * Output a byte on the stream.  IN assertion: there is enough room in
 * pending_buf.
 */
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c); }


#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
/*
 * Minimum amount of lookahead, except at the end of the input file.
 * See deflate.c for comments about the MIN_MATCH+1.
 */

#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
/*
 * In order to simplify the code, particularly on 16 bit machines,
 * match distances are limited to MAX_DIST instead of WSIZE.
 */

        /* in trees.c */
void _tr_init           OF((deflate_state *s));
int  _tr_tally          OF((deflate_state *s, unsigned dist, unsigned lc));
void  _tr_flush_block   OF((deflate_state *s, charf *buf, ulg stored_len,
    int eof));
void _tr_align          OF((deflate_state *s));
void _tr_stored_block   OF((deflate_state *s, charf *buf, ulg stored_len,
    int eof));
void _tr_stored_type_only OF((deflate_state *));        /* PPP */

#define d_code(dist) \
        ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
/*
 * Mapping from a distance to a distance code. dist is the distance - 1 and
 * must not have side effects. _dist_code[256] and _dist_code[257] are never
 * used.
 */

#ifndef DEBUG_ZLIB
/* Inline versions of _tr_tally for speed: */

local uch _length_code[];
local uch _dist_code[];

#define _tr_tally_lit(s, c, flush) \
        {       uch cc = (c); \
                s->d_buf[s->last_lit] = 0; \
                s->l_buf[s->last_lit++] = cc; \
                s->dyn_ltree[cc].Freq++; \
                flush = (s->last_lit == s->lit_bufsize-1); \
        }
#define _tr_tally_dist(s, distance, length, flush) \
        {       uch len = (length); \
                ush dist = (distance); \
                s->d_buf[s->last_lit] = dist; \
                s->l_buf[s->last_lit++] = len; \
                dist--; \
                s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
                s->dyn_dtree[d_code(dist)].Freq++; \
                flush = (s->last_lit == s->lit_bufsize-1); \
        }
#else
#define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
#define _tr_tally_dist(s, distance, length, flush) \
                flush = _tr_tally(s, distance, length)
#endif

#endif
/* --- deflate.h */

/* +++ deflate.c */
/*
 * deflate.c -- compress data using the deflation algorithm
 * Copyright (C) 1995-1998 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 *  ALGORITHM
 *
 *      The "deflation" process depends on being able to identify portions
 *      of the input text which are identical to earlier input (within a
 *      sliding window trailing behind the input currently being processed).
 *
 *      The most straightforward technique turns out to be the fastest for
 *      most input files: try all possible matches and select the longest.
 *      The key feature of this algorithm is that insertions into the string
 *      dictionary are very simple and thus fast, and deletions are avoided
 *      completely. Insertions are performed at each input character, whereas
 *      string matches are performed only when the previous match ends. So it
 *      is preferable to spend more time in matches to allow very fast string
 *      insertions and avoid deletions. The matching algorithm for small
 *      strings is inspired from that of Rabin & Karp. A brute force approach
 *      is used to find longer strings when a small match has been found.
 *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
 *      (by Leonid Broukhis).
 *         A previous version of this file used a more sophisticated algorithm
 *      (by Fiala and Greene) which is guaranteed to run in linear amortized
 *      time, but has a larger average cost, uses more memory and is patented.
 *      However the F&G algorithm may be faster for some highly redundant
 *      files if the parameter max_chain_length (described below) is too large.
 *
 *  ACKNOWLEDGEMENTS
 *
 *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
 *      I found it in 'freeze' written by Leonid Broukhis.
 *      Thanks to many people for bug reports and testing.
 *
 *  REFERENCES
 *
 *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
 *      Available in ftp://ds.internic.net/rfc/rfc1951.txt
 *
 *      A description of the Rabin and Karp algorithm is given in the book
 *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
 *
 *      Fiala,E.R., and Greene,D.H.
 *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
 *
 */

/* From: deflate.c,v 1.15 1996/07/24 13:40:58 me Exp $ */

/* #include "deflate.h" */

const char deflate_copyright[] =
" deflate 1.1.3 Copyright 1995-1998 Jean-loup Gailly ";
/*
 * 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.
 */

/*
 * ===========================================================================
 *  Function prototypes.
 */
typedef enum {
        /* block not completed, need more input or more output */
        need_more,
        block_done,     /* block flush performed */
        /* finish started, need only more output at next deflate */
        finish_started,
        finish_done     /* finish done, accept no more input or output */
} block_state;

typedef block_state (*compress_func) OF((deflate_state *s, int flush));
/* Compression function. Returns the block state after the call. */

local void fill_window  OF((deflate_state *s));
local block_state deflate_stored OF((deflate_state *s, int flush));
local block_state deflate_fast  OF((deflate_state *s, int flush));
local block_state deflate_slow  OF((deflate_state *s, int flush));
local void lm_init      OF((deflate_state *s));
local void putShortMSB  OF((deflate_state *s, uInt b));
local void flush_pending        OF((z_streamp strm));
local int read_buf      OF((z_streamp strm, Bytef *buf, unsigned size));
#ifdef ASMV
void match_init OF((void));     /* asm code initialization */
uInt longest_match      OF((deflate_state *s, IPos cur_match));
#else
local uInt longest_match        OF((deflate_state *s, IPos cur_match));
#endif

#ifdef DEBUG_ZLIB
local void check_match OF((deflate_state *s, IPos start, IPos match,
    int length));
#endif

/*
 * ===========================================================================
 * Local data
 */

#define NIL 0
/* Tail of hash chains */

#ifndef TOO_FAR
#define TOO_FAR 4096
#endif
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */

#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
/*
 * Minimum amount of lookahead, except at the end of the input file.
 * See deflate.c for comments about the MIN_MATCH+1.
 */

/*
 * Values for max_lazy_match, good_match and max_chain_length,
 * depending on the desired pack level (0..9). The values given below
 * have been tuned to exclude worst case performance for pathological
 * files. Better values may be found for specific files.
 */
typedef struct config_s {
        ush good_length;        /* reduce lazy search above this match length */
        ush max_lazy;   /* do not perform lazy search above this match length */
        ush nice_length;        /* quit search above this match length */
        ush max_chain;
        compress_func func;
} config;

local const config configuration_table[10] = {
/*      good lazy nice chain */
/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
/* 1 */ {4,    4,  8,    4, deflate_fast}, /* maximum speed, no lazy matches */
/* 2 */ {4,    5, 16,    8, deflate_fast},
/* 3 */ {4,    6, 32,   32, deflate_fast},

/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
/* 5 */ {8,   16, 32,   32, deflate_slow},
/* 6 */ {8,   16, 128, 128, deflate_slow},
/* 7 */ {8,   32, 128, 256, deflate_slow},
/* 8 */ {32, 128, 258, 1024, deflate_slow},
/* 9 */ {32, 258, 258, 4096, deflate_slow}};    /* maximum compression */

/*
 * Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
 * meaning.
 */

#define EQUAL 0
/* result of memcmp for equal strings */

#ifndef NO_DUMMY_DECL
struct static_tree_desc_s {int dummy; };        /* for buggy compilers */
#endif

/*
 * ===========================================================================
 * Update a hash value with the given input byte
 * IN  assertion: all calls to to UPDATE_HASH are made with consecutive
 *    input characters, so that a running hash key can be computed from the
 *    previous key instead of complete recalculation each time.
 */
#define UPDATE_HASH(s, h, c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)


/*
 * ===========================================================================
 * Insert string str in the dictionary and set match_head to the previous head
 * of the hash chain (the most recent string with same hash key). Return
 * the previous length of the hash chain.
 * If this file is compiled with -DFASTEST, the compression level is forced
 * to 1, and no hash chains are maintained.
 * IN  assertion: all calls to to INSERT_STRING are made with consecutive
 *    input characters and the first MIN_MATCH bytes of str are valid
 *    (except for the last MIN_MATCH-1 bytes of the input file).
 */
#ifdef FASTEST
#define INSERT_STRING(s, str, match_head) \
        (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
        match_head = s->head[s->ins_h], \
        s->head[s->ins_h] = (Pos)(str))
#else
#define INSERT_STRING(s, str, match_head) \
        (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
        s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
        s->head[s->ins_h] = (Pos)(str))
#endif

/*
 * ===========================================================================
 * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
 * prev[] will be initialized on the fly.
 */
#define CLEAR_HASH(s) \
    s->head[s->hash_size-1] = NIL; \
    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof (*s->head));

/* ========================================================================= */
int
deflateInit_(strm, level, version, stream_size)
    z_streamp strm;
    int level;
    const char *version;
    int stream_size;
{
        (void) deflate_copyright;
        return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
            Z_DEFAULT_STRATEGY, version, stream_size);
        /* To do: ignore strm->next_in if we use it as window */
}

/* ========================================================================= */
int deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
    version, stream_size)
    z_streamp strm;
    int  level;
    int  method;
    int  windowBits;
    int  memLevel;
    int  strategy;
    const char *version;
    int stream_size;
{
        deflate_state *s;
        int noheader = 0;
        static const char *my_version = ZLIB_VERSION;

        ushf *overlay;
        /*
         * We overlay pending_buf and d_buf+l_buf. This works since
         * the average output size for (length, distance) codes is <=
         * 24 bits.
         */

        if (version == Z_NULL || version[0] != my_version[0] ||
            stream_size != sizeof (z_stream)) {
                return (Z_VERSION_ERROR);
        }
        if (strm == Z_NULL)
                return (Z_STREAM_ERROR);

        strm->msg = Z_NULL;
#ifndef NO_ZCFUNCS
        if (strm->zalloc == Z_NULL) {
                strm->zalloc = zcalloc;
                strm->opaque = (voidpf)0;
        }
        if (strm->zfree == Z_NULL) strm->zfree = zcfree;
#endif

        if (level == Z_DEFAULT_COMPRESSION) level = 6;
#ifdef FASTEST
        level = 1;
#endif

        if (windowBits < 0) { /* undocumented feature: suppress zlib header */
                noheader = 1;
                windowBits = -windowBits;
        }
        if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
            windowBits <= 8 || windowBits > 15 || level < 0 || level > 9 ||
            strategy < 0 || strategy > Z_HUFFMAN_ONLY) {
                return (Z_STREAM_ERROR);
        }
        s = (deflate_state *) ZALLOC(strm, 1, sizeof (deflate_state));
        if (s == Z_NULL)
                return (Z_MEM_ERROR);
        strm->state = (struct internal_state FAR *)s;
        s->strm = strm;

        s->noheader = noheader;
        s->w_bits = windowBits;
        s->w_size = 1 << s->w_bits;
        s->w_mask = s->w_size - 1;

        s->hash_bits = memLevel + 7;
        s->hash_size = 1 << s->hash_bits;
        s->hash_mask = s->hash_size - 1;
        s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);

        s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof (Byte));
        s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof (Pos));
        s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof (Pos));

        s->lit_bufsize = 1 << (memLevel + 6);   /* 16K elements by default */

        overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof (ush)+2);
        s->pending_buf = (uchf *) overlay;
        s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof (ush)+2L);

        if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
            s->pending_buf == Z_NULL) {
                strm->msg = ERR_MSG(Z_MEM_ERROR);
                s->status = INIT_STATE;
                (void) deflateEnd(strm);
                return (Z_MEM_ERROR);
        }
        s->d_buf = overlay + s->lit_bufsize/sizeof (ush);
        s->l_buf = s->pending_buf + (1+sizeof (ush))*s->lit_bufsize;

        s->level = level;
        s->strategy = strategy;
        s->method = (Byte)method;

        return (deflateReset(strm));
}

/* ========================================================================= */
int
deflateSetDictionary(strm, dictionary, dictLength)
    z_streamp strm;
    const Bytef *dictionary;
    uInt  dictLength;
{
        deflate_state *s;
        uInt length = dictLength;
        uInt n;
        IPos hash_head = 0;

        if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL)
                return (Z_STREAM_ERROR);

        s = (deflate_state *) strm->state;
        if (s->status != INIT_STATE)
                return (Z_STREAM_ERROR);

        strm->adler = adler32(strm->adler, dictionary, dictLength);

        if (length < MIN_MATCH)
                return (Z_OK);
        if (length > MAX_DIST(s)) {
                length = MAX_DIST(s);
#ifndef USE_DICT_HEAD
                /* use the tail of the dictionary */
                dictionary += dictLength - length;
#endif
        }
        Assert(length <= s->window_size, "dict copy");
        zmemcpy(s->window, dictionary, length);
        s->strstart = length;
        s->block_start = (long)length;

        /*
         * Insert all strings in the hash table (except for the last
         * two bytes).  s->lookahead stays null, so s->ins_h will be
         * recomputed at the next call of fill_window.
         */
        s->ins_h = s->window[0];
        UPDATE_HASH(s, s->ins_h, s->window[1]);
        for (n = 0; n <= length - MIN_MATCH; n++) {
                INSERT_STRING(s, n, hash_head);
        }
        if (hash_head) hash_head = 0;   /* to make compiler happy */
        return (Z_OK);
}

/* ========================================================================= */
int
deflateReset(strm)
    z_streamp strm;
{
        deflate_state *s;

        if (strm == Z_NULL || strm->state == Z_NULL ||
            strm->zalloc == Z_NULL || strm->zfree == Z_NULL)
                return (Z_STREAM_ERROR);

        strm->total_in = strm->total_out = 0;
        /* use zfree if we ever allocate msg dynamically */
        strm->msg = Z_NULL;
        strm->data_type = Z_UNKNOWN;

        s = (deflate_state *)strm->state;
        s->pending = 0;
        s->pending_out = s->pending_buf;

        if (s->noheader < 0) {
                /* was set to -1 by deflate(..., Z_FINISH); */
                s->noheader = 0;
        }
        s->status = s->noheader ? BUSY_STATE : INIT_STATE;
        strm->adler = 1;
        s->last_flush = Z_NO_FLUSH;

        _tr_init(s);
        lm_init(s);

        return (Z_OK);
}

/* ========================================================================= */
int
deflateParams(strm, level, strategy)
    z_streamp strm;
    int level;
    int strategy;
{
        deflate_state *s;
        compress_func func;
        int err = Z_OK;

        if (strm == Z_NULL || strm->state == Z_NULL)
                return (Z_STREAM_ERROR);
        s = (deflate_state *) strm->state;

        if (level == Z_DEFAULT_COMPRESSION) {
                level = 6;
        }
        if (level < 0 || level > 9 || strategy < 0 ||
            strategy > Z_HUFFMAN_ONLY) {
                return (Z_STREAM_ERROR);
        }
        func = configuration_table[s->level].func;

        if (func != configuration_table[level].func && strm->total_in != 0) {
                /* Flush the last buffer: */
                err = deflate(strm, Z_PARTIAL_FLUSH);
        }
        if (s->level != level) {
                s->level = level;
                s->max_lazy_match   = configuration_table[level].max_lazy;
                s->good_match   = configuration_table[level].good_length;
                s->nice_match   = configuration_table[level].nice_length;
                s->max_chain_length = configuration_table[level].max_chain;
        }
        s->strategy = strategy;
        return (err);
}

/*
 * =========================================================================
 * Put a short in the pending buffer. The 16-bit value is put in MSB order.
 * IN assertion: the stream state is correct and there is enough room in
 * pending_buf.
 */
local void
putShortMSB(s, b)
    deflate_state *s;
    uInt b;
{
        put_byte(s, (Byte)(b >> 8));
        put_byte(s, (Byte)(b & 0xff));
}

/*
 * =========================================================================
 * Flush as much pending output as possible. All deflate() output goes
 * through this function so some applications may wish to modify it
 * to avoid allocating a large strm->next_out buffer and copying into it.
 * (See also read_buf()).
 */
local void
flush_pending(strm)
    z_streamp strm;
{
        deflate_state *s = (deflate_state *) strm->state;
        unsigned len = s->pending;

        if (len > strm->avail_out) len = strm->avail_out;
        if (len == 0)
                return;

        if (strm->next_out != Z_NULL) {         /* PPP */
                zmemcpy(strm->next_out, s->pending_out, len);
                strm->next_out += len;
        }                                       /* PPP */
        s->pending_out += len;
        strm->total_out += len;
        strm->avail_out  -= len;
        s->pending -= len;
        if (s->pending == 0) {
                s->pending_out = s->pending_buf;
        }
}

/* ========================================================================= */
int
deflate(strm, flush)
    z_streamp strm;
    int flush;
{
        int old_flush;  /* value of flush param for previous deflate call */
        deflate_state *s;

        if (strm == Z_NULL || strm->state == Z_NULL ||
            flush > Z_FINISH || flush < 0) {
                return (Z_STREAM_ERROR);
        }
        s = (deflate_state *) strm->state;

        if (/* strm->next_out == Z_NULL || --- we allow null --- PPP */
                (strm->next_in == Z_NULL && strm->avail_in != 0) ||
            (s->status == FINISH_STATE && flush != Z_FINISH)) {
                ERR_RETURN(strm, Z_STREAM_ERROR);
        }
        if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);

        s->strm = strm; /* just in case */
        old_flush = s->last_flush;
        s->last_flush = flush;

        /* Write the zlib header */
        if (s->status == INIT_STATE) {

                uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
                uInt level_flags = (s->level-1) >> 1;

                if (level_flags > 3) level_flags = 3;
                header |= (level_flags << 6);
                if (s->strstart != 0) header |= PRESET_DICT;
                header += 31 - (header % 31);

                s->status = BUSY_STATE;
                putShortMSB(s, header);

                /* Save the adler32 of the preset dictionary: */
                if (s->strstart != 0) {
                        putShortMSB(s, (uInt)(strm->adler >> 16));
                        putShortMSB(s, (uInt)(strm->adler & 0xffff));
                }
                strm->adler = 1L;
        }

        /* Flush as much pending output as possible */
        if (s->pending != 0) {
                flush_pending(strm);
                if (strm->avail_out == 0) {
                        /*
                         * Since avail_out is 0, deflate will be
                         * called again with more output space, but
                         * possibly with both pending and avail_in
                         * equal to zero. There won't be anything to
                         * do, but this is not an error situation so
                         * make sure we return OK instead of BUF_ERROR
                         * at next call of deflate:
                         */
                        s->last_flush = -1;
                        return (Z_OK);
                }

                /*
                 * Make sure there is something to do and avoid
                 * duplicate consecutive flushes. For repeated and
                 * useless calls with Z_FINISH, we keep returning
                 * Z_STREAM_END instead of Z_BUFF_ERROR.
                 */
        } else if (strm->avail_in == 0 && flush <= old_flush &&
            flush != Z_FINISH) {
                ERR_RETURN(strm, Z_BUF_ERROR);
        }

        /* User must not provide more input after the first FINISH: */
        if (s->status == FINISH_STATE && strm->avail_in != 0) {
                ERR_RETURN(strm, Z_BUF_ERROR);
        }

        /* Start a new block or continue the current one. */
        if (strm->avail_in != 0 || s->lookahead != 0 ||
            (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
                block_state bstate;

                bstate = (*(configuration_table[s->level].func))(s, flush);

                if (bstate == finish_started || bstate == finish_done) {
                        s->status = FINISH_STATE;
                }
                if (bstate == need_more || bstate == finish_started) {
                        if (strm->avail_out == 0) {
                                /* avoid BUF_ERROR next call, see above */
                                s->last_flush = -1;
                        }
                        return (Z_OK);
                        /*
                         * If flush != Z_NO_FLUSH && avail_out == 0,
                         * the next call of deflate should use the
                         * same flush parameter to make sure that the
                         * flush is complete. So we don't have to
                         * output an empty block here, this will be
                         * done at next call. This also ensures that
                         * for a very small output buffer, we emit at
                         * most one empty block.
                         */
                }
                if (bstate == block_done) {
                        if (flush == Z_PARTIAL_FLUSH) {
                                _tr_align(s);
                        } else if (flush == Z_PACKET_FLUSH) {   /* PPP */
                                /*
                                 * Output just the 3-bit `stored'
                                 * block type value, but not a zero
                                 * length.  Added for PPP.
                                 */
                                _tr_stored_type_only(s);        /* PPP */
                        } else { /* FULL_FLUSH or SYNC_FLUSH */
                                _tr_stored_block(s, (char *)0, 0L, 0);
                                /*
                                 * For a full flush, this empty block
                                 * will be recognized as a special
                                 * marker by inflate_sync().
                                 */
                                if (flush == Z_FULL_FLUSH) {
                                        CLEAR_HASH(s);  /* forget history */
                                }
                        }
                        flush_pending(strm);
                        if (strm->avail_out == 0) {
                                /* avoid BUF_ERROR at next call, see above */
                                s->last_flush = -1;
                                return (Z_OK);
                        }
                }
        }
        Assert(strm->avail_out > 0, "bug2");

        if (flush != Z_FINISH)
                return (Z_OK);
        if (s->noheader)
                return (Z_STREAM_END);

        /* Write the zlib trailer (adler32) */
        putShortMSB(s, (uInt)(strm->adler >> 16));
        putShortMSB(s, (uInt)(strm->adler & 0xffff));
        flush_pending(strm);
        /*
         * If avail_out is zero, the application will call deflate
         * again to flush the rest.
         */
        s->noheader = -1;       /* write the trailer only once! */
        return (s->pending != 0 ? Z_OK : Z_STREAM_END);
}

/* ========================================================================= */
int
deflateEnd(strm)
    z_streamp strm;
{
        int status;
        deflate_state *s;

        if (strm == Z_NULL || strm->state == Z_NULL)
                return (Z_STREAM_ERROR);
        s = (deflate_state *) strm->state;

        status = s->status;
        if (status != INIT_STATE && status != BUSY_STATE &&
            status != FINISH_STATE) {
                return (Z_STREAM_ERROR);
        }

        /* Deallocate in reverse order of allocations: */
        TRY_FREE(strm, s->pending_buf);
        TRY_FREE(strm, s->head);
        TRY_FREE(strm, s->prev);
        TRY_FREE(strm, s->window);

        ZFREE(strm, s);
        strm->state = Z_NULL;

        return (status == BUSY_STATE ? Z_DATA_ERROR : Z_OK);
}

/*
 * =========================================================================
 * Copy the source state to the destination state.
 * To simplify the source, this is not supported for 16-bit MSDOS (which
 * doesn't have enough memory anyway to duplicate compression states).
 */
int
deflateCopy(dest, source)
    z_streamp dest;
    z_streamp source;
{
#ifdef MAXSEG_64K
        return (Z_STREAM_ERROR);
#else
        deflate_state *ds;
        deflate_state *ss;
        ushf *overlay;

        if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL)
                return (Z_STREAM_ERROR);
        ss = (deflate_state *) source->state;

        zmemcpy(dest, source, sizeof (*dest));

        ds = (deflate_state *) ZALLOC(dest, 1, sizeof (deflate_state));
        if (ds == Z_NULL)
                return (Z_MEM_ERROR);
        dest->state = (struct internal_state FAR *) ds;
        zmemcpy(ds, ss, sizeof (*ds));
        ds->strm = dest;

        ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof (Byte));
        ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof (Pos));
        ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof (Pos));
        overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof (ush)+2);
        ds->pending_buf = (uchf *) overlay;

        if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
            ds->pending_buf == Z_NULL) {
                ds->status = INIT_STATE;
                (void) deflateEnd(dest);
                return (Z_MEM_ERROR);
        }
        /* following zmemcpy doesn't work for 16-bit MSDOS */
        zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof (Byte));
        zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof (Pos));
        zmemcpy(ds->head, ss->head, ds->hash_size * sizeof (Pos));
        zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);

        ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
        ds->d_buf = overlay + ds->lit_bufsize/sizeof (ush);
        ds->l_buf = ds->pending_buf + (1+sizeof (ush))*ds->lit_bufsize;

        ds->l_desc.dyn_tree = ds->dyn_ltree;
        ds->d_desc.dyn_tree = ds->dyn_dtree;
        ds->bl_desc.dyn_tree = ds->bl_tree;

        return (Z_OK);
#endif
}

/*
 * ===========================================================================
 * Return the number of bytes of output which are immediately available
 * for output from the decompressor.            ---PPP---
 */
int
deflateOutputPending(strm)
    z_streamp strm;
{
        if (strm == Z_NULL || strm->state == Z_NULL)
                return (0);

        return (((deflate_state *)(strm->state))->pending);
}

/*
 * ===========================================================================
 * Read a new buffer from the current input stream, update the adler32
 * and total number of bytes read.  All deflate() input goes through
 * this function so some applications may wish to modify it to avoid
 * allocating a large strm->next_in buffer and copying from it.
 * (See also flush_pending()).
 */
local int
read_buf(strm, buf, size)
    z_streamp strm;
    Bytef *buf;
    unsigned size;
{
        unsigned len = strm->avail_in;

        if (len > size) len = size;
        if (len == 0)
                return (0);

        strm->avail_in  -= len;

        if (!((deflate_state *)(strm->state))->noheader) {
                strm->adler = adler32(strm->adler, strm->next_in, len);
        }
        zmemcpy(buf, strm->next_in, len);
        strm->next_in  += len;
        strm->total_in += len;

        return ((int)len);
}

/*
 * ===========================================================================
 * Initialize the "longest match" routines for a new zlib stream
 */
local void
lm_init(s)
    deflate_state *s;
{
        s->window_size = (ulg)2L*s->w_size;

        CLEAR_HASH(s);

        /* Set the default configuration parameters: */
        s->max_lazy_match   = configuration_table[s->level].max_lazy;
        s->good_match   = configuration_table[s->level].good_length;
        s->nice_match   = configuration_table[s->level].nice_length;
        s->max_chain_length = configuration_table[s->level].max_chain;

        s->strstart = 0;
        s->block_start = 0L;
        s->lookahead = 0;
        s->match_length = s->prev_length = MIN_MATCH-1;
        s->match_available = 0;
        s->ins_h = 0;
#ifdef ASMV
        match_init();   /* initialize the asm code */
#endif
}

/*
 * ===========================================================================
 * Set match_start to the longest match starting at the given string and
 * return its length. Matches shorter or equal to prev_length are discarded,
 * in which case the result is equal to prev_length and match_start is
 * garbage.
 * IN assertions: cur_match is the head of the hash chain for the current
 *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
 * OUT assertion: the match length is not greater than s->lookahead.
 */
#ifndef ASMV
/*
 * For 80x86 and 680x0, an optimized version will be provided in
 * match.asm or match.S. The code will be functionally equivalent.
 */
#ifndef FASTEST
local uInt
longest_match(s, cur_match)
    deflate_state *s;
    IPos cur_match;     /* current match */
{
        /* max hash chain length */
        unsigned chain_length = s->max_chain_length;
        register Bytef *scan = s->window + s->strstart; /* current string */
        register Bytef *match;  /* matched string */
        register int len;       /* length of current match */
        int best_len = s->prev_length;  /* best match length so far */
        int nice_match = s->nice_match; /* stop if match long enough */
        IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
            s->strstart - (IPos)MAX_DIST(s) : NIL;
        /*
         * Stop when cur_match becomes <= limit. To simplify the code,
         * we prevent matches with the string of window index 0.
         */
        Posf *prev = s->prev;
        uInt wmask = s->w_mask;

#ifdef UNALIGNED_OK
        /*
         * Compare two bytes at a time. Note: this is not always
         * beneficial.  Try with and without -DUNALIGNED_OK to check.
         */
        register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
        register ush scan_start = *(ushf*)scan;
        register ush scan_end   = *(ushf*)(scan+best_len-1);
#else
        register Bytef *strend = s->window + s->strstart + MAX_MATCH;
        register Byte scan_end1  = scan[best_len-1];
        register Byte scan_end   = scan[best_len];
#endif

        /*
         * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2
         * multiple of 16.  It is easy to get rid of this optimization
         * if necessary.
         */
        Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");

        /* Do not waste too much time if we already have a good match: */
        if (s->prev_length >= s->good_match) {
                chain_length >>= 2;
        }
        /*
         * Do not look for matches beyond the end of the input. This
         * is necessary to make deflate deterministic.
         */
        if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;

        Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD,
            "need lookahead");

        do {
                Assert(cur_match <= s->strstart, "no future");
                match = s->window + cur_match;

                /*
                 * Skip to next match if the match length cannot
                 * increase or if the match length is less than 2:
                 */
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
                /*
                 * This code assumes sizeof (unsigned short) == 2. Do
                 * not use UNALIGNED_OK if your compiler uses a
                 * different size.
                 */
                if (*(ushf*)(match+best_len-1) != scan_end ||
                    *(ushf*)match != scan_start) continue;

                /*
                 * It is not necessary to compare scan[2] and match[2]
                 * since they are always equal when the other bytes
                 * match, given that the hash keys are equal and that
                 * HASH_BITS >= 8. Compare 2 bytes at a time at
                 * strstart+3, +5, ... up to strstart+257. We check
                 * for insufficient lookahead only every 4th
                 * comparison; the 128th check will be made at
                 * strstart+257. If MAX_MATCH-2 is not a multiple of
                 * 8, it is necessary to put more guard bytes at the
                 * end of the window, or to check more often for
                 * insufficient lookahead.
                 */
                Assert(scan[2] == match[2], "scan[2]?");
                scan++, match++;
                do {
                } while (*(ushf *)(scan += 2) == *(ushf *)(match += 2) &&
                    *(ushf *)(scan += 2) == *(ushf *)(match += 2) &&
                    *(ushf *)(scan += 2) == *(ushf *)(match += 2) &&
                    *(ushf *)(scan += 2) == *(ushf *)(match += 2) &&
                    scan < strend);
                /* The funny "do {}" generates better code on most compilers */

                /* Here, scan <= window+strstart+257 */
                Assert(scan <= s->window+(unsigned)(s->window_size-1),
                    "wild scan");
                if (*scan == *match) scan++;

                len = (MAX_MATCH - 1) - (int)(strend-scan);
                scan = strend - (MAX_MATCH-1);

#else /* UNALIGNED_OK */

                if (match[best_len]     != scan_end     ||
                    match[best_len-1]   != scan_end1    ||
                    *match              != *scan        ||
                    *++match            != scan[1])
                        continue;

                /*
                 * The check at best_len-1 can be removed because it
                 * will be made again later. (This heuristic is not
                 * always a win.)  It is not necessary to compare
                 * scan[2] and match[2] since they are always equal
                 * when the other bytes match, given that the hash
                 * keys are equal and that HASH_BITS >= 8.
                 */
                scan += 2, match++;
                Assert(*scan == *match, "match[2]?");

                /*
                 * We check for insufficient lookahead only every 8th
                 * comparison; the 256th check will be made at
                 * strstart+258.
                 */
                do {
                } while (*++scan == *++match && *++scan == *++match &&
                    *++scan == *++match && *++scan == *++match &&
                    *++scan == *++match && *++scan == *++match &&
                    *++scan == *++match && *++scan == *++match &&
                    scan < strend);

                Assert(scan <= s->window+(unsigned)(s->window_size-1),
                    "wild scan");

                len = MAX_MATCH - (int)(strend - scan);
                scan = strend - MAX_MATCH;

#endif /* UNALIGNED_OK */

                if (len > best_len) {
                        s->match_start = cur_match;
                        best_len = len;
                        if (len >= nice_match) break;
#ifdef UNALIGNED_OK
                        scan_end = *(ushf*)(scan+best_len-1);
#else
                        scan_end1  = scan[best_len-1];
                        scan_end   = scan[best_len];
#endif
                }
        } while ((cur_match = prev[cur_match & wmask]) > limit &&
            --chain_length != 0);

        if ((uInt)best_len <= s->lookahead)
                return (best_len);
        return (s->lookahead);
}
#else /* FASTEST */
/*
 * ---------------------------------------------------------------------------
 * Optimized version for level == 1 only
 */
local uInt
longest_match(s, cur_match)
deflate_state *s;
IPos cur_match;         /* current match */
{
        register Bytef *scan = s->window + s->strstart; /* current string */
        register Bytef *match;          /* matched string */
        register int len;                       /* length of current match */
        register Bytef *strend = s->window + s->strstart + MAX_MATCH;

        /*
         * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2
         * multiple of 16.  It is easy to get rid of this optimization
         * if necessary.
         */
        Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");

        Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD,
            "need lookahead");

        Assert(cur_match <= s->strstart, "no future");

        match = s->window + cur_match;

        /* Return failure if the match length is less than 2: */
        if (match[0] != scan[0] || match[1] != scan[1])
                return (MIN_MATCH-1);

        /*
         * The check at best_len-1 can be removed because it will be
         * made again later. (This heuristic is not always a win.)  It
         * is not necessary to compare scan[2] and match[2] since they
         * are always equal when the other bytes match, given that the
         * hash keys are equal and that HASH_BITS >= 8.
         */
        scan += 2, match += 2;
        Assert(*scan == *match, "match[2]?");

        /*
         * We check for insufficient lookahead only every 8th comparison;
         * the 256th check will be made at strstart+258.
         */
        do {
        } while (*++scan == *++match && *++scan == *++match &&
            *++scan == *++match && *++scan == *++match &&
            *++scan == *++match && *++scan == *++match &&
            *++scan == *++match && *++scan == *++match &&
            scan < strend);

        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");

        len = MAX_MATCH - (int)(strend - scan);

        if (len < MIN_MATCH)
                return (MIN_MATCH - 1);

        s->match_start = cur_match;
        return (len <= s->lookahead ? len : s->lookahead);
}
#endif /* FASTEST */
#endif /* ASMV */

#ifdef DEBUG_ZLIB
/*
 * ===========================================================================
 * Check that the match at match_start is indeed a match.
 */
local void
check_match(s, start, match, length)
    deflate_state *s;
    IPos start, match;
    int length;
{
        /* check that the match is indeed a match */
        if (zmemcmp(s->window + match, s->window + start, length) != EQUAL) {
                fprintf(stderr, " start %u, match %u, length %d\n",
                    start, match, length);
                do {
                        fprintf(stderr, "%c%c", s->window[match++],
                            s->window[start++]);
                } while (--length != 0);
                z_error("invalid match");
        }
        if (z_verbose > 1) {
                fprintf(stderr, "\\[%d,%d]", start-match, length);
                do { putc(s->window[start++], stderr); } while (--length != 0);
        }
}
#else
#define check_match(s, start, match, length)
#endif

/*
 * ===========================================================================
 * Fill the window when the lookahead becomes insufficient.
 * Updates strstart and lookahead.
 *
 * IN assertion: lookahead < MIN_LOOKAHEAD
 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
 *    At least one byte has been read, or avail_in == 0; reads are
 *    performed for at least two bytes (required for the zip translate_eol
 *    option -- not supported here).
 */
local void
fill_window(s)
    deflate_state *s;
{
        register unsigned n, m;
        register Posf *p;
        unsigned more;  /* Amount of free space at the end of the window. */
        uInt wsize = s->w_size;

        do {
                more = (unsigned)(s->window_size -(ulg)s->lookahead -
                    (ulg)s->strstart);

                /* Deal with !@#$% 64K limit: */
                if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
                        more = wsize;

                } else if (more == (unsigned)(-1)) {
                        /*
                         * Very unlikely, but possible on 16 bit
                         * machine if strstart == 0 and lookahead == 1
                         * (input done one byte at time)
                         */
                        more--;

                        /*
                         * If the window is almost full and there is
                         * insufficient lookahead, move the upper half
                         * to the lower one to make room in the upper
                         * half.
                         */
                } else if (s->strstart >= wsize+MAX_DIST(s)) {

                        Assert(wsize+wsize <= s->window_size, "wsize*2");
                        zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
                        s->match_start -= wsize;
                        /* we now have strstart >= MAX_DIST */
                        s->strstart    -= wsize;
                        s->block_start -= (long)wsize;

                        /*
                         * Slide the hash table (could be avoided with
                         * 32 bit values at the expense of memory
                         * usage). We slide even when level == 0 to
                         * keep the hash table consistent if we switch
                         * back to level > 0 later. (Using level 0
                         * permanently is not an optimal usage of
                         * zlib, so we don't care about this
                         * pathological case.)
                         */
                        n = s->hash_size;
                        p = &s->head[n];
                        do {
                                m = *--p;
                                *p = (Pos)(m >= wsize ? m-wsize : NIL);
                        } while (--n);

                        n = wsize;
#ifndef FASTEST
                        p = &s->prev[n];
                        do {
                                m = *--p;
                                *p = (Pos)(m >= wsize ? m-wsize : NIL);
                                /*
                                 * If n is not on any hash chain,
                                 * prev[n] is garbage but its value
                                 * will never be used.
                                 */
                        } while (--n);
#endif
                        more += wsize;
                }
                if (s->strm->avail_in == 0)
                        return;

                /*
                 * If there was no sliding:
                 *    strstart <= WSIZE+MAX_DIST-1 &&
                 *      lookahead <= MIN_LOOKAHEAD - 1 &&
                 *    more == window_size - lookahead - strstart
                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE +
                 *      MAX_DIST-1)
                 * => more >= window_size - 2*WSIZE + 2
                 * In the BIG_MEM or MMAP case (not yet supported),
                 *   window_size == input_size + MIN_LOOKAHEAD  &&
                 *   strstart + s->lookahead <= input_size =>
                 *      more >= MIN_LOOKAHEAD.
                 * Otherwise, window_size == 2*WSIZE so more >= 2.
                 * If there was sliding, more >= WSIZE. So in all cases,
                 * more >= 2.
                 */
                Assert(more >= 2, "more < 2");
                Assert(s->strstart + s->lookahead + more <= s->window_size,
                    "read too much");

                n = read_buf(s->strm, s->window + s->strstart + s->lookahead,
                    more);
                s->lookahead += n;

                /* Initialize the hash value now that we have some input: */
                if (s->lookahead >= MIN_MATCH) {
                        s->ins_h = s->window[s->strstart];
                        UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
#if MIN_MATCH != 3
                        Call UPDATE_HASH() MIN_MATCH-3 more times
#endif
                            }
                /*
                 * If the whole input has less than MIN_MATCH bytes,
                 * ins_h is garbage, but this is not important since
                 * only literal bytes will be emitted.
                 */

        } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
}

/*
 * ===========================================================================
 * Flush the current block, with given end-of-file flag.
 * IN assertion: strstart is set to the end of the current match.
 */
#define FLUSH_BLOCK_ONLY(s, eof) { \
        _tr_flush_block(s, (s->block_start >= 0L ? \
                (charf *)&s->window[(unsigned)s->block_start] : \
                (charf *)Z_NULL), \
                (ulg)((long)s->strstart - s->block_start), \
                (eof)); \
        s->block_start = s->strstart; \
        flush_pending(s->strm); \
        Tracev((stderr, "[FLUSH]")); \
}

/* Same but force premature exit if necessary. */
#define FLUSH_BLOCK(s, eof) { \
        FLUSH_BLOCK_ONLY(s, eof); \
        if (s->strm->avail_out == 0) \
                return ((eof) ? finish_started : need_more); \
}

/*
 * ===========================================================================
 * Copy without compression as much as possible from the input stream, return
 * the current block state.
 * This function does not insert new strings in the dictionary since
 * uncompressible data is probably not useful. This function is used
 * only for the level=0 compression option.
 * NOTE: this function should be optimized to avoid extra copying from
 * window to pending_buf.
 */
local block_state
deflate_stored(s, flush)
    deflate_state *s;
    int flush;
{
        /*
         * Stored blocks are limited to 0xffff bytes, pending_buf is
         * limited to pending_buf_size, and each stored block has a 5
         * byte header:
         */
        ulg max_block_size = 0xffff;
        ulg max_start;

        if (max_block_size > s->pending_buf_size - 5) {
                max_block_size = s->pending_buf_size - 5;
        }

        /* Copy as much as possible from input to output: */
        for (;;) {
                /* Fill the window as much as possible: */
                if (s->lookahead <= 1) {

                        Assert(s->strstart < s->w_size+MAX_DIST(s) ||
                            s->block_start >= (long)s->w_size,
                            "slide too late");

                        fill_window(s);
                        if (s->lookahead == 0 && flush == Z_NO_FLUSH)
                                return (need_more);

                        if (s->lookahead == 0)
                                break;  /* flush the current block */
                }
                Assert(s->block_start >= 0L, "block gone");

                s->strstart += s->lookahead;
                s->lookahead = 0;

                /* Emit a stored block if pending_buf will be full: */
                max_start = s->block_start + max_block_size;
                if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
                        /*
                         * strstart == 0 is possible when wraparound
                         * on 16-bit machine
                         */
                        s->lookahead = (uInt)(s->strstart - max_start);
                        s->strstart = (uInt)max_start;
                        FLUSH_BLOCK(s, 0);
                }
                /*
                 * Flush if we may have to slide, otherwise
                 * block_start may become negative and the data will
                 * be gone:
                 */
                if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
                        FLUSH_BLOCK(s, 0);
                }
        }
        FLUSH_BLOCK(s, flush == Z_FINISH);
        return (flush == Z_FINISH ? finish_done : block_done);
}

/*
 * ===========================================================================
 * Compress as much as possible from the input stream, return the current
 * block state.
 * This function does not perform lazy evaluation of matches and inserts
 * new strings in the dictionary only for unmatched strings or for short
 * matches. It is used only for the fast compression options.
 */
local block_state
deflate_fast(s, flush)
    deflate_state *s;
    int flush;
{
        IPos hash_head = NIL;   /* head of the hash chain */
        int bflush;     /* set if current block must be flushed */

        for (;;) {
                /*
                 * Make sure that we always have enough lookahead,
                 * except at the end of the input file. We need
                 * MAX_MATCH bytes for the next match, plus MIN_MATCH
                 * bytes to insert the string following the next
                 * match.
                 */
                if (s->lookahead < MIN_LOOKAHEAD) {
                        fill_window(s);
                        if (s->lookahead < MIN_LOOKAHEAD &&
                            flush == Z_NO_FLUSH) {
                                return (need_more);
                        }
                        if (s->lookahead == 0)
                                break;  /* flush the current block */
                }

                /*
                 * Insert the string window[strstart .. strstart+2] in
                 * the dictionary, and set hash_head to the head of
                 * the hash chain:
                 */
                if (s->lookahead >= MIN_MATCH) {
                        INSERT_STRING(s, s->strstart, hash_head);
                }

                /*
                 * Find the longest match, discarding those <=
                 * prev_length.  At this point we have always
                 * match_length < MIN_MATCH
                 */
                if (hash_head != NIL && s->strstart - hash_head <=
                    MAX_DIST(s)) {
                        /*
                         * To simplify the code, we prevent matches
                         * with the string of window index 0 (in
                         * particular we have to avoid a match of the
                         * string with itself at the start of the
                         * input file).
                         */
                        if (s->strategy != Z_HUFFMAN_ONLY) {
                                s->match_length = longest_match(s, hash_head);
                        }
                        /* longest_match() sets match_start */
                }
                if (s->match_length >= MIN_MATCH) {
                        check_match(s, s->strstart, s->match_start,
                            s->match_length);

                        _tr_tally_dist(s, s->strstart - s->match_start,
                            s->match_length - MIN_MATCH, bflush);

                        s->lookahead -= s->match_length;

                        /*
                         * Insert new strings in the hash table only
                         * if the match length is not too large. This
                         * saves time but degrades compression.
                         */
#ifndef FASTEST
                        if (s->match_length <= s->max_insert_length &&
                            s->lookahead >= MIN_MATCH) {
                                /* string at strstart already in hash table */
                                s->match_length--;
                                do {
                                        s->strstart++;
                                        INSERT_STRING(s, s->strstart,
                                            hash_head);
                                        /*
                                         * strstart never exceeds
                                         * WSIZE-MAX_MATCH, so there
                                         * are always MIN_MATCH bytes
                                         * ahead.
                                         */
                                } while (--s->match_length != 0);
                                s->strstart++;
                        } else
#endif
                        {
                                s->strstart += s->match_length;
                                s->match_length = 0;
                                s->ins_h = s->window[s->strstart];
                                UPDATE_HASH(s, s->ins_h,
                                    s->window[s->strstart+1]);
#if MIN_MATCH != 3
                                Call UPDATE_HASH() MIN_MATCH-3 more times
#endif
                                /*
                                 * If lookahead < MIN_MATCH, ins_h is
                                 * garbage, but it does not matter
                                 * since it will be recomputed at next
                                 * deflate call.
                                 */
                        }
                } else {
                        /* No match, output a literal byte */
                        Tracevv((stderr, "%c", s->window[s->strstart]));
                        _tr_tally_lit(s, s->window[s->strstart], bflush);
                        s->lookahead--;
                        s->strstart++;
                }
                if (bflush) FLUSH_BLOCK(s, 0);
        }
        FLUSH_BLOCK(s, flush == Z_FINISH);
        return (flush == Z_FINISH ? finish_done : block_done);
}

/*
 * ===========================================================================
 * Same as above, but achieves better compression. We use a lazy
 * evaluation for matches: a match is finally adopted only if there is
 * no better match at the next window position.
 */
local block_state
deflate_slow(s, flush)
    deflate_state *s;
    int flush;
{
        IPos hash_head = NIL;   /* head of hash chain */
        int bflush;     /* set if current block must be flushed */

        /* Process the input block. */
        for (;;) {
                /*
                 * Make sure that we always have enough lookahead,
                 * except at the end of the input file. We need
                 * MAX_MATCH bytes for the next match, plus MIN_MATCH
                 * bytes to insert the string following the next
                 * match.
                 */
                if (s->lookahead < MIN_LOOKAHEAD) {
                        fill_window(s);
                        if (s->lookahead < MIN_LOOKAHEAD &&
                            flush == Z_NO_FLUSH) {
                                return (need_more);
                        }
                        /* flush the current block */
                        if (s->lookahead == 0)
                                break;
                }

                /*
                 * Insert the string window[strstart .. strstart+2] in
                 * the dictionary, and set hash_head to the head of
                 * the hash chain:
                 */
                if (s->lookahead >= MIN_MATCH) {
                        INSERT_STRING(s, s->strstart, hash_head);
                }

                /*
                 * Find the longest match, discarding those <=
                 * prev_length.
                 */
                s->prev_length = s->match_length;
                s->prev_match = s->match_start;
                s->match_length = MIN_MATCH-1;

                if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
                    s->strstart - hash_head <= MAX_DIST(s)) {
                        /*
                         * To simplify the code, we prevent matches
                         * with the string of window index 0 (in
                         * particular we have to avoid a match of the
                         * string with itself at the start of the
                         * input file).
                         */
                        if (s->strategy != Z_HUFFMAN_ONLY) {
                                s->match_length = longest_match(s, hash_head);
                        }
                        /* longest_match() sets match_start */

                        if (s->match_length <= 5 &&
                            (s->strategy == Z_FILTERED ||
                                (s->match_length == MIN_MATCH &&
                                    s->strstart - s->match_start > TOO_FAR))) {

                                /*
                                 * If prev_match is also MIN_MATCH,
                                 * match_start is garbage but we will
                                 * ignore the current match anyway.
                                 */
                                s->match_length = MIN_MATCH-1;
                        }
                }
                /*
                 * If there was a match at the previous step and the
                 * current match is not better, output the previous
                 * match:
                 */
                if (s->prev_length >= MIN_MATCH &&
                    s->match_length <= s->prev_length) {
                        uInt max_insert = s->strstart + s->lookahead -
                            MIN_MATCH;
                        /* Do not insert strings in hash table beyond this. */

                        check_match(s, s->strstart-1, s->prev_match,
                            s->prev_length);

                        _tr_tally_dist(s, s->strstart -1 - s->prev_match,
                            s->prev_length - MIN_MATCH, bflush);

                        /*
                         * Insert in hash table all strings up to the
                         * end of the match.  strstart-1 and strstart
                         * are already inserted. If there is not
                         * enough lookahead, the last two strings are
                         * not inserted in the hash table.
                         */
                        s->lookahead -= s->prev_length-1;
                        s->prev_length -= 2;
                        do {
                                if (++s->strstart <= max_insert) {
                                        INSERT_STRING(s, s->strstart,
                                            hash_head);
                                }
                        } while (--s->prev_length != 0);
                        s->match_available = 0;
                        s->match_length = MIN_MATCH-1;
                        s->strstart++;

                        if (bflush) FLUSH_BLOCK(s, 0);

                } else if (s->match_available) {
                        /*
                         * If there was no match at the previous
                         * position, output a single literal. If there
                         * was a match but the current match is
                         * longer, truncate the previous match to a
                         * single literal.
                         */
                        Tracevv((stderr, "%c", s->window[s->strstart-1]));
                        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
                        if (bflush) {
                                FLUSH_BLOCK_ONLY(s, 0);
                        }
                        s->strstart++;
                        s->lookahead--;
                        if (s->strm->avail_out == 0)
                                return (need_more);
                } else {
                        /*
                         * There is no previous match to compare with,
                         * wait for the next step to decide.
                         */
                        s->match_available = 1;
                        s->strstart++;
                        s->lookahead--;
                }
        }
        Assert(flush != Z_NO_FLUSH, "no flush?");
        if (s->match_available) {
                Tracevv((stderr, "%c", s->window[s->strstart-1]));
                _tr_tally_lit(s, s->window[s->strstart-1], bflush);
                s->match_available = 0;
        }
        FLUSH_BLOCK(s, flush == Z_FINISH);
        return (flush == Z_FINISH ? finish_done : block_done);
}
/* --- deflate.c */

/* +++ trees.c */
/*
 * trees.c -- output deflated data using Huffman coding
 * Copyright (C) 1995-1998 Jean-loup Gailly
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 *  ALGORITHM
 *
 *      The "deflation" process uses several Huffman trees. The more
 *      common source values are represented by shorter bit sequences.
 *
 *      Each code tree is stored in a compressed form which is itself
 * a Huffman encoding of the lengths of all the code strings (in
 * ascending order by source values).  The actual code strings are
 * reconstructed from the lengths in the inflate process, as described
 * in the deflate specification.
 *
 *  REFERENCES
 *
 *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
 *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
 *
 *      Storer, James A.
 *          Data Compression:  Methods and Theory, pp. 49-50.
 *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
 *
 *      Sedgewick, R.
 *          Algorithms, p290.
 *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
 */

/* From: trees.c,v 1.11 1996/07/24 13:41:06 me Exp $ */

/* #include "deflate.h" */

#ifdef DEBUG_ZLIB
#include <ctype.h>
#endif

/*
 * ===========================================================================
 * Constants
 */

#define MAX_BL_BITS 7
/* Bit length codes must not exceed MAX_BL_BITS bits */

#define END_BLOCK 256
/* end of block literal code */

#define REP_3_6         16
/* repeat previous bit length 3-6 times (2 bits of repeat count) */

#define REPZ_3_10       17
/* repeat a zero length 3-10 times  (3 bits of repeat count) */

#define REPZ_11_138     18
/* repeat a zero length 11-138 times  (7 bits of repeat count) */

/* extra bits for each length code */
local const int extra_lbits[LENGTH_CODES] = {
        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};

/* extra bits for each distance code */
local const int extra_dbits[D_CODES] = {
        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9,
        9, 10, 10, 11, 11, 12, 12, 13, 13};

/* extra bits for each bit length code */
local const int extra_blbits[BL_CODES] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};

local const uch bl_order[BL_CODES] = {
        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

/*
 * The lengths of the bit length codes are sent in order of decreasing
 * probability, to avoid transmitting the lengths for unused bit
 * length codes.
 */

#define Buf_size (8 * 2*sizeof (char))
/*
 * Number of bits used within bi_buf. (bi_buf might be implemented on
 * more than 16 bits on some systems.)
 */

/*
 * ===========================================================================
 * Local data. These are initialized only once.
 */
#define DIST_CODE_LEN  512 /* see definition of array dist_code below */

local ct_data static_ltree[L_CODES+2];
/*
 * The static literal tree. Since the bit lengths are imposed, there
 * is no need for the L_CODES extra codes used during heap
 * construction. However The codes 286 and 287 are needed to build a
 * canonical tree (see _tr_init below).
 */

local ct_data static_dtree[D_CODES];
/*
 * The static distance tree. (Actually a trivial tree since all codes
 * use 5 bits.)
 */

local uch _dist_code[512];
/*
 * distance codes. The first 256 values correspond to the distances 3
 * .. 258, the last 256 values correspond to the top 8 bits of the 15
 * bit distances.
 */

local uch _length_code[MAX_MATCH-MIN_MATCH+1];
/* length code for each normalized match length (0 == MIN_MATCH) */

local int base_length[LENGTH_CODES];
/* First normalized length for each code (0 = MIN_MATCH) */

local int base_dist[D_CODES];
/* First normalized distance for each code (0 = distance of 1) */

struct static_tree_desc_s {
        const ct_data *static_tree;     /* static tree or NULL */
        const intf    *extra_bits;      /* extra bits for each code or NULL */
        int     extra_base;     /* base index for extra_bits */
        int     elems;  /* max number of elements in the tree */
        int     max_length;     /* max bit length for the codes */
};

local static_tree_desc  static_l_desc = {
        static_ltree, extra_lbits, LITERALS+1,  L_CODES, MAX_BITS};

local static_tree_desc  static_d_desc = {
        static_dtree, extra_dbits, 0,           D_CODES, MAX_BITS};

local static_tree_desc  static_bl_desc = {
        (const ct_data *)0, extra_blbits, 0,            BL_CODES, MAX_BL_BITS};

/*
 * ===========================================================================
 * Local (static) routines in this file.
 */

local void tr_static_init OF((void));
local void init_block   OF((deflate_state *s));
local void pqdownheap   OF((deflate_state *s, ct_data *tree, int k));
local void gen_bitlen   OF((deflate_state *s, tree_desc *desc));
local void gen_codes    OF((ct_data *tree, int max_code, ushf *bl_count));
local void build_tree   OF((deflate_state *s, tree_desc *desc));
local void scan_tree    OF((deflate_state *s, ct_data *tree, int max_code));
local void send_tree    OF((deflate_state *s, ct_data *tree, int max_code));
local int  build_bl_tree        OF((deflate_state *s));
local void send_all_trees       OF((deflate_state *s, int lcodes, int dcodes,
    int blcodes));
local void compress_block OF((deflate_state *s, ct_data *ltree,
    ct_data *dtree));
local void set_data_type        OF((deflate_state *s));
local unsigned bi_reverse       OF((unsigned value, int length));
local void bi_windup    OF((deflate_state *s));
local void bi_flush     OF((deflate_state *s));
local void copy_block   OF((deflate_state *s, charf *buf, unsigned len,
    int header));

#ifndef DEBUG_ZLIB
#define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
/* Send a code of the given tree. c and tree must not have side effects */

#else /* DEBUG_ZLIB */
#define send_code(s, c, tree) \
        { if (z_verbose > 2) fprintf(stderr, "\ncd %3d ", (c)); \
        send_bits(s, tree[c].Code, tree[c].Len); }
#endif

/*
 * ===========================================================================
 * Output a short LSB first on the stream.
 * IN assertion: there is enough room in pendingBuf.
 */
#define put_short(s, w) { \
        put_byte(s, (uch)((w) & 0xff)); \
        put_byte(s, (uch)((ush)(w) >> 8)); \
}

/*
 * ===========================================================================
 * Send a value on a given number of bits.
 * IN assertion: length <= 16 and value fits in length bits.
 */
#ifdef DEBUG_ZLIB
local void send_bits    OF((deflate_state *s, int value, int length));

local void
send_bits(s, value, length)
    deflate_state *s;
    int value;  /* value to send */
    int length; /* number of bits */
{
        Tracevv((stderr, " l %2d v %4x ", length, value));
        Assert(length > 0 && length <= 15, "invalid length");
        s->bits_sent += (ulg)length;

        /*
         * If not enough room in bi_buf, use (valid) bits from bi_buf
         * and (16 - bi_valid) bits from value, leaving (width -
         * (16-bi_valid)) unused bits in value.
         */
        if (s->bi_valid > (int)Buf_size - length) {
                s->bi_buf |= (value << s->bi_valid);
                put_short(s, s->bi_buf);
                s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
                s->bi_valid += length - Buf_size;
        } else {
                s->bi_buf |= value << s->bi_valid;
                s->bi_valid += length;
        }
}
#else /* !DEBUG_ZLIB */

#define send_bits(s, value, length) \
{       int len = length; \
        if (s->bi_valid > (int)Buf_size - len) {\
                int val = value; \
                s->bi_buf |= (val << s->bi_valid); \
                put_short(s, s->bi_buf); \
                s->bi_buf = (ush)val >> (Buf_size - s->bi_valid); \
                s->bi_valid += len - Buf_size; \
        } else {\
                s->bi_buf |= (value) << s->bi_valid; \
                s->bi_valid += len; \
        }\
}
#endif /* DEBUG_ZLIB */


#define MAX(a, b) (a >= b ? a : b)
/* the arguments must not have side effects */

/*
 * ===========================================================================
 * Initialize the various 'constant' tables. In a multi-threaded environment,
 * this function may be called by two threads concurrently, but this is
 * harmless since both invocations do exactly the same thing.
 */
local void
tr_static_init()
{
        static int static_init_done = 0;
        int n;  /* iterates over tree elements */
        int bits;       /* bit counter */
        int length;     /* length value */
        int code;       /* code value */
        int dist;       /* distance index */
        ush bl_count[MAX_BITS+1];
        /* number of codes at each bit length for an optimal tree */

        if (static_init_done)
                return;

        /* For some embedded targets, global variables are not initialized: */
        static_l_desc.static_tree = static_ltree;
        static_l_desc.extra_bits = extra_lbits;
        static_d_desc.static_tree = static_dtree;
        static_d_desc.extra_bits = extra_dbits;
        static_bl_desc.extra_bits = extra_blbits;

        /* Initialize the mapping length (0..255) -> length code (0..28) */
        length = 0;
        for (code = 0; code < LENGTH_CODES-1; code++) {
                base_length[code] = length;
                for (n = 0; n < (1<<extra_lbits[code]); n++) {
                        _length_code[length++] = (uch)code;
                }
        }
        Assert(length == 256, "tr_static_init: length != 256");
        /*
         * Note that the length 255 (match length 258) can be
         * represented in two different ways: code 284 + 5 bits or
         * code 285, so we overwrite _length_code[255] to use the best
         * encoding:
         */
        _length_code[length-1] = (uch)code;

        /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
        dist = 0;
        for (code = 0; code < 16; code++) {
                base_dist[code] = dist;
                for (n = 0; n < (1<<extra_dbits[code]); n++) {
                        _dist_code[dist++] = (uch)code;
                }
        }
        Assert(dist == 256, "tr_static_init: dist != 256");
        dist >>= 7;     /* from now on, all distances are divided by 128 */
        for (; code < D_CODES; code++) {
                base_dist[code] = dist << 7;
                for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
                        _dist_code[256 + dist++] = (uch)code;
                }
        }
        Assert(dist == 256, "tr_static_init: 256+dist != 512");

        /* Construct the codes of the static literal tree */
        for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
        n = 0;
        while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
        while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
        while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
        while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
        /*
         * Codes 286 and 287 do not exist, but we must include them in the
         * tree construction to get a canonical Huffman tree (longest code
         * all ones)
         */
        gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);

        /* The static distance tree is trivial: */
        for (n = 0; n < D_CODES; n++) {
                static_dtree[n].Len = 5;
                static_dtree[n].Code = bi_reverse((unsigned)n, 5);
        }
        static_init_done = 1;
}

/*
 * ===========================================================================
 * Initialize the tree data structures for a new zlib stream.
 */
void
_tr_init(s)
    deflate_state *s;
{
        tr_static_init();

        s->l_desc.dyn_tree = s->dyn_ltree;
        s->l_desc.stat_desc = &static_l_desc;

        s->d_desc.dyn_tree = s->dyn_dtree;
        s->d_desc.stat_desc = &static_d_desc;

        s->bl_desc.dyn_tree = s->bl_tree;
        s->bl_desc.stat_desc = &static_bl_desc;

        s->bi_buf = 0;
        s->bi_valid = 0;
        s->last_eob_len = 8;    /* enough lookahead for inflate */
        s->compressed_len = 0L;         /* PPP */
#ifdef DEBUG_ZLIB
        s->bits_sent = 0L;
#endif

        /* Initialize the first block of the first file: */
        init_block(s);
}

/*
 * ===========================================================================
 * Initialize a new block.
 */
local void
init_block(s)
    deflate_state *s;
{
        int n;  /* iterates over tree elements */

        /* Initialize the trees. */
        for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
        for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
        for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;

        s->dyn_ltree[END_BLOCK].Freq = 1;
        s->opt_len = s->static_len = 0L;
        s->last_lit = s->matches = 0;
}

#define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */


/*
 * ===========================================================================
 * Remove the smallest element from the heap and recreate the heap with
 * one less element. Updates heap and heap_len.
 */
#define pqremove(s, tree, top) \
{\
        top = s->heap[SMALLEST]; \
        s->heap[SMALLEST] = s->heap[s->heap_len--]; \
        pqdownheap(s, tree, SMALLEST); \
}

/*
 * ===========================================================================
 * Compares to subtrees, using the tree depth as tie breaker when
 * the subtrees have equal frequency. This minimizes the worst case length.
 */
#define smaller(tree, n, m, depth) \
        (tree[n].Freq < tree[m].Freq || \
        (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
/*
 * ===========================================================================
 * Restore the heap property by moving down the tree starting at node k,
 * exchanging a node with the smallest of its two sons if necessary, stopping
 * when the heap property is re-established (each father smaller than its
 * two sons).
 */
local void
pqdownheap(s, tree, k)
    deflate_state *s;
    ct_data *tree;      /* the tree to restore */
    int k;      /* node to move down */
{
        int v = s->heap[k];
        int j = k << 1; /* left son of k */
        while (j <= s->heap_len) {
                /* Set j to the smallest of the two sons: */
                if (j < s->heap_len &&
                    smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
                        j++;
                }
                /* Exit if v is smaller than both sons */
                if (smaller(tree, v, s->heap[j], s->depth)) break;

                /* Exchange v with the smallest son */
                s->heap[k] = s->heap[j];  k = j;

                /* And continue down the tree, setting j to the left son of k */
                j <<= 1;
        }
        s->heap[k] = v;
}

/*
 * ===========================================================================
 * Compute the optimal bit lengths for a tree and update the total bit length
 * for the current block.
 * IN assertion: the fields freq and dad are set, heap[heap_max] and
 *    above are the tree nodes sorted by increasing frequency.
 * OUT assertions: the field len is set to the optimal bit length, the
 *     array bl_count contains the frequencies for each bit length.
 *     The length opt_len is updated; static_len is also updated if stree is
 *     not null.
 */
local void
gen_bitlen(s, desc)
    deflate_state *s;
    tree_desc *desc;    /* the tree descriptor */
{
        ct_data *tree  = desc->dyn_tree;
        int max_code   = desc->max_code;
        const ct_data *stree = desc->stat_desc->static_tree;
        const intf *extra    = desc->stat_desc->extra_bits;
        int base        = desc->stat_desc->extra_base;
        int max_length = desc->stat_desc->max_length;
        int h;  /* heap index */
        int n, m;       /* iterate over the tree elements */
        int bits;       /* bit length */
        int xbits;      /* extra bits */
        ush f;  /* frequency */
        /* number of elements with bit length too large */
        int overflow = 0;

        for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;

        /*
         * In a first pass, compute the optimal bit lengths (which may
         * overflow in the case of the bit length tree).
         */
        tree[s->heap[s->heap_max]].Len = 0;     /* root of the heap */

        for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
                n = s->heap[h];
                bits = tree[tree[n].Dad].Len + 1;
                if (bits > max_length) bits = max_length, overflow++;
                tree[n].Len = (ush)bits;
                /* We overwrite tree[n].Dad which is no longer needed */

                if (n > max_code) continue;     /* not a leaf node */

                s->bl_count[bits]++;
                xbits = 0;
                if (n >= base) xbits = extra[n-base];
                f = tree[n].Freq;
                s->opt_len += (ulg)f * (bits + xbits);
                if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
        }
        if (overflow == 0)
                return;

        Trace((stderr, "\nbit length overflow\n"));
        /* This happens for example on obj2 and pic of the Calgary corpus */

        /* Find the first bit length which could increase: */
        do {
                bits = max_length-1;
                while (s->bl_count[bits] == 0) bits--;
                s->bl_count[bits]--;    /* move one leaf down the tree */
                /* move one overflow item as its brother */
                s->bl_count[bits+1] += 2;
                s->bl_count[max_length]--;
                /*
                 * The brother of the overflow item also moves one
                 * step up, but this does not affect
                 * bl_count[max_length]
                 */
                overflow -= 2;
        } while (overflow > 0);

        /*
         * Now recompute all bit lengths, scanning in increasing
         * frequency.  h is still equal to HEAP_SIZE. (It is simpler
         * to reconstruct all lengths instead of fixing only the wrong
         * ones. This idea is taken from 'ar' written by Haruhiko
         * Okumura.)
         */
        for (bits = max_length; bits != 0; bits--) {
                n = s->bl_count[bits];
                while (n != 0) {
                        m = s->heap[--h];
                        if (m > max_code) continue;
                        if (tree[m].Len != (unsigned)bits) {
                                Trace((stderr, "code %d bits %d->%d\n", m,
                                    tree[m].Len, bits));
                                s->opt_len += ((long)bits - (long)tree[m].Len)
                                    *(long)tree[m].Freq;
                                tree[m].Len = (ush)bits;
                        }
                        n--;
                }
        }
}

/*
 * ===========================================================================
 * Generate the codes for a given tree and bit counts (which need not be
 * optimal).
 * IN assertion: the array bl_count contains the bit length statistics for
 * the given tree and the field len is set for all tree elements.
 * OUT assertion: the field code is set for all tree elements of non
 *     zero code length.
 */
local void
gen_codes(tree, max_code, bl_count)
    ct_data *tree;      /* the tree to decorate */
    int max_code;       /* largest code with non zero frequency */
    ushf *bl_count;     /* number of codes at each bit length */
{
        /* next code value for each bit length */
        ush next_code[MAX_BITS+1];
        ush code = 0;   /* running code value */
        int bits;       /* bit index */
        int n;  /* code index */

        /*
         * The distribution counts are first used to generate the code
         * values without bit reversal.
         */
        for (bits = 1; bits <= MAX_BITS; bits++) {
                next_code[bits] = code = (code + bl_count[bits-1]) << 1;
        }
        /*
         * Check that the bit counts in bl_count are consistent. The
         * last code must be all ones.
         */
        Assert(code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
            "inconsistent bit counts");
        Tracev((stderr, "\ngen_codes: max_code %d ", max_code));

        for (n = 0;  n <= max_code; n++) {
                int len = tree[n].Len;
                if (len == 0) continue;
                /* Now reverse the bits */
                tree[n].Code = bi_reverse(next_code[len]++, len);

                Tracecv(tree != static_ltree,
                    (stderr, "\nn %3d %c l %2d c %4x (%x) ",
                    n, (isgraph(n) ? n : ' '), len, tree[n].Code,
                        next_code[len]-1));
        }
}

/*
 * ===========================================================================
 * Construct one Huffman tree and assigns the code bit strings and lengths.
 * Update the total bit length for the current block.
 * IN assertion: the field freq is set for all tree elements.
 * OUT assertions: the fields len and code are set to the optimal bit length
 *     and corresponding code. The length opt_len is updated; static_len is
 *     also updated if stree is not null. The field max_code is set.
 */
local void
build_tree(s, desc)
    deflate_state *s;
    tree_desc *desc;    /* the tree descriptor */
{
        ct_data *tree   = desc->dyn_tree;
        const ct_data *stree  = desc->stat_desc->static_tree;
        int elems       = desc->stat_desc->elems;
        int n, m;       /* iterate over heap elements */
        int max_code = -1;      /* largest code with non zero frequency */
        int node;       /* new node being created */

        /*
         * Construct the initial heap, with least frequent element in
         * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and
         * heap[2*n+1].  heap[0] is not used.
         */
        s->heap_len = 0, s->heap_max = HEAP_SIZE;

        for (n = 0; n < elems; n++) {
                if (tree[n].Freq != 0) {
                        s->heap[++(s->heap_len)] = max_code = n;
                        s->depth[n] = 0;
                } else {
                        tree[n].Len = 0;
                }
        }

        /*
         * The pkzip format requires that at least one distance code
         * exists, and that at least one bit should be sent even if
         * there is only one possible code. So to avoid special checks
         * later on we force at least two codes of non zero frequency.
         */
        while (s->heap_len < 2) {
                node = s->heap[++(s->heap_len)] = (max_code < 2 ?
                    ++max_code : 0);
                tree[node].Freq = 1;
                s->depth[node] = 0;
                s->opt_len--; if (stree) s->static_len -= stree[node].Len;
                /* node is 0 or 1 so it does not have extra bits */
        }
        desc->max_code = max_code;

        /*
         * The elements heap[heap_len/2+1 .. heap_len] are leaves of
         * the tree, establish sub-heaps of increasing lengths:
         */
        for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);

        /*
         * Construct the Huffman tree by repeatedly combining the
         * least two frequent nodes.
         */
        node = elems;   /* next internal node of the tree */
        do {
                pqremove(s, tree, n);   /* n = node of least frequency */
                m = s->heap[SMALLEST];  /* m = node of next least frequency */

                /* keep the nodes sorted by frequency */
                s->heap[--(s->heap_max)] = n;
                s->heap[--(s->heap_max)] = m;

                /* Create a new node father of n and m */
                tree[node].Freq = tree[n].Freq + tree[m].Freq;
                s->depth[node] = (uch) (MAX(s->depth[n], s->depth[m]) + 1);
                tree[n].Dad = tree[m].Dad = (ush)node;
#ifdef DUMP_BL_TREE
                if (tree == s->bl_tree) {
                        fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)",
                            node, tree[node].Freq, n, tree[n].Freq, m,
                            tree[m].Freq);
                }
#endif
                /* and insert the new node in the heap */
                s->heap[SMALLEST] = node++;
                pqdownheap(s, tree, SMALLEST);

        } while (s->heap_len >= 2);

        s->heap[--(s->heap_max)] = s->heap[SMALLEST];

        /*
         * At this point, the fields freq and dad are set. We can now
         * generate the bit lengths.
         */
        gen_bitlen(s, (tree_desc *)desc);

        /* The field len is now set, we can generate the bit codes */
        gen_codes((ct_data *)tree, max_code, s->bl_count);
}

/*
 * ===========================================================================
 * Scan a literal or distance tree to determine the frequencies of the codes
 * in the bit length tree.
 */
local void
scan_tree(s, tree, max_code)
    deflate_state *s;
    ct_data *tree;      /* the tree to be scanned */
    int max_code;       /* and its largest code of non zero frequency */
{
        int n;  /* iterates over all tree elements */
        int prevlen = -1;       /* last emitted length */
        int curlen;     /* length of current code */
        int nextlen = tree[0].Len;      /* length of next code */
        int count = 0;  /* repeat count of the current code */
        int max_count = 7;      /* max repeat count */
        int min_count = 4;      /* min repeat count */

        if (nextlen == 0) max_count = 138, min_count = 3;
        tree[max_code+1].Len = (ush)0xffff;     /* guard */

        for (n = 0; n <= max_code; n++) {
                curlen = nextlen; nextlen = tree[n+1].Len;
                if (++count < max_count && curlen == nextlen) {
                        continue;
                } else if (count < min_count) {
                        s->bl_tree[curlen].Freq += count;
                } else if (curlen != 0) {
                        if (curlen != prevlen) s->bl_tree[curlen].Freq++;
                        s->bl_tree[REP_3_6].Freq++;
                } else if (count <= 10) {
                        s->bl_tree[REPZ_3_10].Freq++;
                } else {
                        s->bl_tree[REPZ_11_138].Freq++;
                }
                count = 0; prevlen = curlen;
                if (nextlen == 0) {
                        max_count = 138, min_count = 3;
                } else if (curlen == nextlen) {
                        max_count = 6, min_count = 3;
                } else {
                        max_count = 7, min_count = 4;
                }
        }
}

/*
 * ===========================================================================
 * Send a literal or distance tree in compressed form, using the codes in
 * bl_tree.
 */
local void
send_tree(s, tree, max_code)
    deflate_state *s;
    ct_data *tree;      /* the tree to be scanned */
    int max_code;       /* and its largest code of non zero frequency */
{
        int n;  /* iterates over all tree elements */
        int prevlen = -1;       /* last emitted length */
        int curlen;     /* length of current code */
        int nextlen = tree[0].Len;      /* length of next code */
        int count = 0;  /* repeat count of the current code */
        int max_count = 7;      /* max repeat count */
        int min_count = 4;      /* min repeat count */

        /* tree[max_code+1].Len = -1; */  /* guard already set */
        if (nextlen == 0) max_count = 138, min_count = 3;

        for (n = 0; n <= max_code; n++) {
                curlen = nextlen; nextlen = tree[n+1].Len;
                if (++count < max_count && curlen == nextlen) {
                        continue;
                } else if (count < min_count) {
                        do { send_code(s, curlen, s->bl_tree); }
                        while (--count != 0);

                } else if (curlen != 0) {
                        if (curlen != prevlen) {
                                send_code(s, curlen, s->bl_tree); count--;
                        }
                        Assert(count >= 3 && count <= 6, " 3_6?");
                        send_code(s, REP_3_6, s->bl_tree);
                        send_bits(s, count-3, 2);

                } else if (count <= 10) {
                        send_code(s, REPZ_3_10, s->bl_tree);
                        send_bits(s, count-3, 3);

                } else {
                        send_code(s, REPZ_11_138, s->bl_tree);
                        send_bits(s, count-11, 7);
                }
                count = 0; prevlen = curlen;
                if (nextlen == 0) {
                        max_count = 138, min_count = 3;
                } else if (curlen == nextlen) {
                        max_count = 6, min_count = 3;
                } else {
                        max_count = 7, min_count = 4;
                }
        }
}

/*
 * ===========================================================================
 * Construct the Huffman tree for the bit lengths and return the index in
 * bl_order of the last bit length code to send.
 */
local int
build_bl_tree(s)
    deflate_state *s;
{
        /* index of last bit length code of non zero freq */
        int max_blindex;

        /*
         * Determine the bit length frequencies for literal and
         * distance trees
         */
        scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
        scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);

        /* Build the bit length tree: */
        build_tree(s, (tree_desc *)(&(s->bl_desc)));
        /*
         * opt_len now includes the length of the tree
         * representations, except the lengths of the bit lengths
         * codes and the 5+5+4 bits for the counts.
         */

        /*
         * Determine the number of bit length codes to send. The pkzip
         * format requires that at least 4 bit length codes be
         * sent. (appnote.txt says 3 but the actual value used is 4.)
         */
        for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
                if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
        }
        /* Update opt_len to include the bit length tree and counts */
        s->opt_len += 3*(max_blindex+1) + 5+5+4;
        Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
            s->opt_len, s->static_len));

        return (max_blindex);
}

/*
 * ===========================================================================
 * Send the header for a block using dynamic Huffman trees: the counts, the
 * lengths of the bit length codes, the literal tree and the distance tree.
 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
 */
local void
send_all_trees(s, lcodes, dcodes, blcodes)
    deflate_state *s;
    int lcodes, dcodes, blcodes;        /* number of codes for each tree */
{
        int rank;       /* index in bl_order */

        Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4,
            "not enough codes");
        Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
            "too many codes");
        Tracev((stderr, "\nbl counts: "));
        send_bits(s, lcodes-257, 5);    /* not +255 as stated in appnote.txt */
        send_bits(s, dcodes-1,   5);
        send_bits(s, blcodes-4,  4);    /* not -3 as stated in appnote.txt */
        for (rank = 0; rank < blcodes; rank++) {
                Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
                send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
        }
#ifdef DEBUG_ZLIB
        Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
#endif

        /* literal tree */
        send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1);
#ifdef DEBUG_ZLIB
        Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
#endif

        /* distance tree */
        send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1);
#ifdef DEBUG_ZLIB
        Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
#endif
}

/*
 * ===========================================================================
 * Send a stored block
 */
void
_tr_stored_block(s, buf, stored_len, eof)
    deflate_state *s;
    charf *buf; /* input block */
    ulg stored_len;     /* length of input block */
    int eof;    /* true if this is the last block for a file */
{
        send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */
        s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; /* PPP */
        s->compressed_len += (stored_len + 4) << 3;     /* PPP */

        copy_block(s, buf, (unsigned)stored_len, 1);    /* with header */
}

/*
 * Send just the `stored block' type code without any length bytes or data.
 * ---PPP---
 */
void
_tr_stored_type_only(s)
    deflate_state *s;
{
        send_bits(s, (STORED_BLOCK << 1), 3);
        bi_windup(s);
        s->compressed_len = (s->compressed_len + 3) & ~7L;      /* PPP */
}


/*
 * ===========================================================================
 * Send one empty static block to give enough lookahead for inflate.
 * This takes 10 bits, of which 7 may remain in the bit buffer.
 * The current inflate code requires 9 bits of lookahead. If the
 * last two codes for the previous block (real code plus EOB) were coded
 * on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
 * the last real code. In this case we send two empty static blocks instead
 * of one. (There are no problems if the previous block is stored or fixed.)
 * To simplify the code, we assume the worst case of last real code encoded
 * on one bit only.
 */
void
_tr_align(s)
    deflate_state *s;
{
        send_bits(s, STATIC_TREES<<1, 3);
        send_code(s, END_BLOCK, static_ltree);
        s->compressed_len += 10L;       /* 3 for block type, 7 for EOB */
        bi_flush(s);
        /*
         * Of the 10 bits for the empty block, we have already sent
         * (10 - bi_valid) bits. The lookahead for the last real code
         * (before the EOB of the previous block) was thus at least
         * one plus the length of the EOB plus what we have just sent
         * of the empty static block.
         */
        if (1 + s->last_eob_len + 10 - s->bi_valid < 9) {
                send_bits(s, STATIC_TREES<<1, 3);
                send_code(s, END_BLOCK, static_ltree);
                s->compressed_len += 10L;
                bi_flush(s);
        }
        s->last_eob_len = 7;
}

/*
 * ===========================================================================
 * Determine the best encoding for the current block: dynamic trees, static
 * trees or store, and output the encoded block to the zip file.
 */
void
_tr_flush_block(s, buf, stored_len, eof)
    deflate_state *s;
    charf *buf; /* input block, or NULL if too old */
    ulg stored_len;     /* length of input block */
    int eof;    /* true if this is the last block for a file */
{
        ulg opt_lenb, static_lenb;      /* opt_len and static_len in bytes */
        /* index of last bit length code of non zero freq */
        int max_blindex = 0;

        /* Build the Huffman trees unless a stored block is forced */
        if (s->level > 0) {

                /* Check if the file is ascii or binary */
                if (s->data_type == Z_UNKNOWN) set_data_type(s);

                /* Construct the literal and distance trees */
                build_tree(s, (tree_desc *)(&(s->l_desc)));
                Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
                    s->static_len));

                build_tree(s, (tree_desc *)(&(s->d_desc)));
                Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
                    s->static_len));
                /*
                 * At this point, opt_len and static_len are the total
                 * bit lengths of the compressed block data, excluding
                 * the tree representations.
                 */

                /*
                 * Build the bit length tree for the above two trees,
                 * and get the index in bl_order of the last bit
                 * length code to send.
                 */
                max_blindex = build_bl_tree(s);

                /*
                 * Determine the best encoding. Compute first the
                 * block length in bytes
                 */
                opt_lenb = (s->opt_len+3+7)>>3;
                static_lenb = (s->static_len+3+7)>>3;

                Tracev((stderr,
                    "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
                    opt_lenb, s->opt_len, static_lenb, s->static_len,
                    stored_len, s->last_lit));

                if (static_lenb <= opt_lenb) opt_lenb = static_lenb;

        } else {
                Assert(buf != (char *)0, "lost buf");
                /* force a stored block */
                opt_lenb = static_lenb = stored_len + 5;
        }

        /*
         * If compression failed and this is the first and last block,
         * and if the .zip file can be seeked (to rewrite the local
         * header), the whole file is transformed into a stored file:
         */
#ifdef STORED_FILE_OK
#ifdef FORCE_STORED_FILE
#define FRC_STR_COND    eof && s->compressed_len == 0L /* force stored file */
#else
#define FRC_STR_COND    stored_len <= opt_lenb && eof && \
                        s->compressed_len == 0L && seekable()
#endif
        if (FRC_STR_COND) {
#undef FRC_STR_COND
                /*
                 * Since LIT_BUFSIZE <= 2*WSIZE, the input data must
                 * be there:
                 */
                if (buf == (charf*)0) error("block vanished");

                /* without header */
                copy_block(s, buf, (unsigned)stored_len, 0);
                s->compressed_len = stored_len << 3;
                s->method = STORED;
        } else
#endif /* STORED_FILE_OK */

#ifdef FORCE_STORED
#define FRC_STR_COND    buf != (char *)0        /* force stored block */
#else
                        /* 4: two words for the lengths */
#define FRC_STR_COND    stored_len+4 <= opt_lenb && buf != (char *)0
#endif
                if (FRC_STR_COND) {
#undef FRC_STR_COND
                        /*
                         * The test buf != NULL is only necessary if
                         * LIT_BUFSIZE > WSIZE.  Otherwise we can't
                         * have processed more than WSIZE input bytes
                         * since the last block flush, because
                         * compression would have been successful. If
                         * LIT_BUFSIZE <= WSIZE, it is never too late
                         * to transform a block into a stored block.
                         */
                        _tr_stored_block(s, buf, stored_len, eof);
#ifdef FORCE_STATIC
#define FRC_STAT_COND   static_lenb >= 0 /* force static trees */
#else
#define FRC_STAT_COND   static_lenb == opt_lenb
#endif
                } else if (FRC_STAT_COND) {
#undef FRC_STAT_COND
                        send_bits(s, (STATIC_TREES<<1)+eof, 3);
                        compress_block(s, (ct_data *)static_ltree,
                            (ct_data *)static_dtree);
                        s->compressed_len += 3 + s->static_len; /* PPP */
                } else {
                        send_bits(s, (DYN_TREES<<1)+eof, 3);
                        send_all_trees(s, s->l_desc.max_code+1,
                            s->d_desc.max_code+1,
                            max_blindex+1);
                        compress_block(s, (ct_data *)s->dyn_ltree,
                            (ct_data *)s->dyn_dtree);
                        s->compressed_len += 3 + s->opt_len;    /* PPP */
                }
#ifdef DEBUG_ZLIB
        Assert(s->compressed_len == s->bits_sent, "bad compressed size");
#endif
        /*
         * The above check is made mod 2^32, for files larger than 512
         * MB and uLong implemented on 32 bits.
         */
        init_block(s);

        if (eof) {
                bi_windup(s);
                s->compressed_len += 7; /* align on byte boundary PPP */
        }
        Tracev((stderr, "\ncomprlen %lu(%lu) ", s->compressed_len>>3,
            s->compressed_len-7*eof));

        /* return (s->compressed_len >> 3); */
}

/*
 * ===========================================================================
 * Save the match info and tally the frequency counts. Return true if
 * the current block must be flushed.
 */
int
_tr_tally(s, dist, lc)
    deflate_state *s;
    unsigned dist;      /* distance of matched string */
        /* match length-MIN_MATCH or unmatched char (if dist==0) */
    unsigned lc;
{
        s->d_buf[s->last_lit] = (ush)dist;
        s->l_buf[s->last_lit++] = (uch)lc;
        if (dist == 0) {
                /* lc is the unmatched char */
                s->dyn_ltree[lc].Freq++;
        } else {
                s->matches++;
                /* Here, lc is the match length - MIN_MATCH */
                dist--; /* dist = match distance - 1 */
                Assert((ush)dist < (ush)MAX_DIST(s) &&
                    (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
                    (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");

                s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
                s->dyn_dtree[d_code(dist)].Freq++;
        }

#ifdef TRUNCATE_BLOCK
        /* Try to guess if it is profitable to stop the current block here */
        if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
                /* Compute an upper bound for the compressed length */
                ulg out_length = (ulg)s->last_lit*8L;
                ulg in_length = (ulg)((long)s->strstart - s->block_start);
                int dcode;
                for (dcode = 0; dcode < D_CODES; dcode++) {
                        out_length += (ulg)s->dyn_dtree[dcode].Freq *
                            (5L+extra_dbits[dcode]);
                }
                out_length >>= 3;
                Tracev((stderr, "\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
                    s->last_lit, in_length, out_length,
                    100L - out_length*100L/in_length));
                if (s->matches < s->last_lit/2 && out_length < in_length/2)
                        return (1);
        }
#endif
        return (s->last_lit == s->lit_bufsize-1);
        /*
         * We avoid equality with lit_bufsize because of wraparound at 64K
         * on 16 bit machines and because stored blocks are restricted to
         * 64K-1 bytes.
         */
}

/*
 * ===========================================================================
 * Send the block data compressed using the given Huffman trees
 */
local void
compress_block(s, ltree, dtree)
    deflate_state *s;
    ct_data *ltree;     /* literal tree */
    ct_data *dtree;     /* distance tree */
{
        unsigned dist;  /* distance of matched string */
        int lc; /* match length or unmatched char (if dist == 0) */
        unsigned lx = 0;        /* running index in l_buf */
        unsigned code;  /* the code to send */
        int extra;      /* number of extra bits to send */

        if (s->last_lit != 0) do {
                dist = s->d_buf[lx];
                lc = s->l_buf[lx++];
                if (dist == 0) {
                        /* send a literal byte */
                        send_code(s, lc, ltree);
                        Tracecv(isgraph(lc), (stderr, " '%c' ", lc));
                } else {
                        /* Here, lc is the match length - MIN_MATCH */
                        code = _length_code[lc];
                        /* send the length code */
                        send_code(s, code+LITERALS+1, ltree);
                        extra = extra_lbits[code];
                        if (extra != 0) {
                                lc -= base_length[code];
                                /* send the extra length bits */
                                send_bits(s, lc, extra);
                        }
                        /* dist is now the match distance - 1 */
                        dist--;
                        code = d_code(dist);
                        Assert(code < D_CODES, "bad d_code");

                        /* send the distance code */
                        send_code(s, code, dtree);
                        extra = extra_dbits[code];
                        if (extra != 0) {
                                dist -= base_dist[code];
                                /* send the extra distance bits */
                                send_bits(s, dist, extra);
                        }
                } /* literal or match pair ? */

                /*
                 * Check that the overlay between pending_buf and
                 * d_buf+l_buf is ok:
                 */
                Assert(s->pending < s->lit_bufsize + 2*lx,
                    "pendingBuf overflow");

        } while (lx < s->last_lit);

        send_code(s, END_BLOCK, ltree);
        s->last_eob_len = ltree[END_BLOCK].Len;
}

/*
 * ===========================================================================
 * Set the data type to ASCII or BINARY, using a crude approximation:
 * binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
 * IN assertion: the fields freq of dyn_ltree are set and the total of all
 * frequencies does not exceed 64K (to fit in an int on 16 bit machines).
 */
local void
set_data_type(s)
    deflate_state *s;
{
        int n = 0;
        unsigned ascii_freq = 0;
        unsigned bin_freq = 0;
        while (n < 7)   bin_freq        += s->dyn_ltree[n++].Freq;
        while (n < 128) ascii_freq      += s->dyn_ltree[n++].Freq;
        while (n < LITERALS) bin_freq   += s->dyn_ltree[n++].Freq;
        s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ?
            Z_BINARY : Z_ASCII);
}

/*
 * ===========================================================================
 * Reverse the first len bits of a code, using straightforward code (a faster
 * method would use a table)
 * IN assertion: 1 <= len <= 15
 */
local unsigned
bi_reverse(code, len)
    unsigned code;      /* the value to invert */
    int len;    /* its bit length */
{
        register unsigned res = 0;
        do {
                res |= code & 1;
                code >>= 1, res <<= 1;
        } while (--len > 0);
        return (res >> 1);
}

/*
 * ===========================================================================
 * Flush the bit buffer, keeping at most 7 bits in it.
 */
local void
bi_flush(s)
    deflate_state *s;
{
        if (s->bi_valid == 16) {
                put_short(s, s->bi_buf);
                s->bi_buf = 0;
                s->bi_valid = 0;
        } else if (s->bi_valid >= 8) {
                put_byte(s, (Byte)s->bi_buf);
                s->bi_buf >>= 8;
                s->bi_valid -= 8;
        }
}

/*
 * ===========================================================================
 * Flush the bit buffer and align the output on a byte boundary
 */
local void
bi_windup(s)
    deflate_state *s;
{
        if (s->bi_valid > 8) {
                put_short(s, s->bi_buf);
        } else if (s->bi_valid > 0) {
                put_byte(s, (Byte)s->bi_buf);
        }
        s->bi_buf = 0;
        s->bi_valid = 0;
#ifdef DEBUG_ZLIB
        s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}

/*
 * ===========================================================================
 * Copy a stored block, storing first the length and its
 * one's complement if requested.
 */
local void
copy_block(s, buf, len, header)
    deflate_state *s;
    charf    *buf;      /* the input data */
    unsigned len;       /* its length */
    int header; /* true if block header must be written */
{
        bi_windup(s);   /* align on byte boundary */
        s->last_eob_len = 8;    /* enough lookahead for inflate */

        if (header) {
                put_short(s, (ush)len);
                put_short(s, (ush)~len);
#ifdef DEBUG_ZLIB
                s->bits_sent += 2*16;
#endif
        }
#ifdef DEBUG_ZLIB
        s->bits_sent += (ulg)len<<3;
#endif
        /* bundle up the put_byte(s, *buf++) calls PPP */
        Assert(s->pending + len < s->pending_buf_size, "pending_buf overrun");
        zmemcpy(&s->pending_buf[s->pending], buf, len); /* PPP */
        s->pending += len;                              /* PPP */
}
/* --- trees.c */

/* +++ inflate.c */
/*
 * inflate.c -- zlib interface to inflate modules
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */

/* +++ infblock.h */
/*
 * infblock.h -- header to use infblock.c
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

struct inflate_blocks_state;
typedef struct inflate_blocks_state FAR inflate_blocks_statef;

extern inflate_blocks_statef * inflate_blocks_new OF((
    z_streamp z,
    check_func c,       /* check function */
    uInt w));   /* window size */

extern int inflate_blocks OF((
    inflate_blocks_statef *,
    z_streamp,
    int));      /* initial return code */

extern void inflate_blocks_reset OF((
    inflate_blocks_statef *,
    z_streamp,
    uLongf *)); /* check value on output */

extern int inflate_blocks_free OF((
    inflate_blocks_statef *,
    z_streamp));

extern void inflate_set_dictionary OF((
    inflate_blocks_statef *s,
    const Bytef *d,  /* dictionary */
    uInt  n));  /* dictionary length */

extern int inflate_blocks_sync_point OF((
    inflate_blocks_statef *s));

/* PPP -- added function */
extern int inflate_addhistory OF((
    inflate_blocks_statef *,
    z_streamp));

/* PPP -- added function */
extern int inflate_packet_flush OF((
    inflate_blocks_statef *));
/* --- infblock.h */

#ifndef NO_DUMMY_DECL
struct inflate_blocks_state {int dummy; };      /* for buggy compilers */
#endif

/* inflate private state */
struct internal_state {

        /* mode */
        enum {
                METHOD, /* waiting for method byte */
                FLAG,   /* waiting for flag byte */
                DICT4,  /* four dictionary check bytes to go */
                DICT3,  /* three dictionary check bytes to go */
                DICT2,  /* two dictionary check bytes to go */
                DICT1,  /* one dictionary check byte to go */
                DICT0,  /* waiting for inflateSetDictionary */
                BLOCKS, /* decompressing blocks */
                CHECK4, /* four check bytes to go */
                CHECK3, /* three check bytes to go */
                CHECK2, /* two check bytes to go */
                CHECK1, /* one check byte to go */
                DONE,   /* finished check, done */
                BAD}    /* got an error--stay here */
        mode;   /* current inflate mode */

        /* mode dependent information */
        union {
                uInt method;    /* if FLAGS, method byte */
                struct {
                        uLong was;      /* computed check value */
                        uLong need;     /* stream check value */
                } check;        /* if CHECK, check values to compare */
                uInt marker;    /* if BAD, inflateSync's marker bytes count */
        } sub;  /* submode */

        /* mode independent information */
        int  nowrap;    /* flag for no wrapper */
        uInt wbits;     /* log2(window size)  (8..15, defaults to 15) */
        /* current inflate_blocks state */
        inflate_blocks_statef *blocks;
};


int
inflateReset(z)
z_streamp z;
{
        if (z == Z_NULL || z->state == Z_NULL)
                return (Z_STREAM_ERROR);
        z->total_in = z->total_out = 0;
        z->msg = Z_NULL;
        z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
        inflate_blocks_reset(z->state->blocks, z, Z_NULL);
        Trace((stderr, "inflate: reset\n"));
        return (Z_OK);
}


int
inflateEnd(z)
z_streamp z;
{
        if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
                return (Z_STREAM_ERROR);
        if (z->state->blocks != Z_NULL) {
                (void) inflate_blocks_free(z->state->blocks, z);
                z->state->blocks = Z_NULL;
        }
        ZFREE(z, z->state);
        z->state = Z_NULL;
        Trace((stderr, "inflate: end\n"));
        return (Z_OK);
}


int
inflateInit2_(z, w, version, stream_size)
z_streamp z;
int w;
const char *version;
int stream_size;
{
        if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
            stream_size != sizeof (z_stream))
                return (Z_VERSION_ERROR);

        /* initialize state */
        if (z == Z_NULL)
                return (Z_STREAM_ERROR);
        z->msg = Z_NULL;
#ifndef NO_ZCFUNCS
        if (z->zalloc == Z_NULL)
        {
                z->zalloc = zcalloc;
                z->opaque = (voidpf)0;
        }
        if (z->zfree == Z_NULL) z->zfree = zcfree;
#endif
        if ((z->state = (struct internal_state FAR *)
            ZALLOC(z, 1, sizeof (struct internal_state))) == Z_NULL)
                return (Z_MEM_ERROR);
        z->state->blocks = Z_NULL;

        /* handle undocumented nowrap option (no zlib header or check) */
        z->state->nowrap = 0;
        if (w < 0)
        {
                w = - w;
                z->state->nowrap = 1;
        }

        /* set window size */
        if (w < 8 || w > 15)
        {
                (void) inflateEnd(z);
                return (Z_STREAM_ERROR);
        }
        z->state->wbits = (uInt)w;

        /* create inflate_blocks state */
        if ((z->state->blocks =
            inflate_blocks_new(z, z->state->nowrap ?
                Z_NULL : adler32, (uInt)1 << w))
            == Z_NULL)
        {
                (void) inflateEnd(z);
                return (Z_MEM_ERROR);
        }
        Trace((stderr, "inflate: allocated\n"));

        /* reset state */
        (void) inflateReset(z);
        return (Z_OK);
}


int
inflateInit_(z, version, stream_size)
z_streamp z;
const char *version;
int stream_size;
{
        return (inflateInit2_(z, DEF_WBITS, version, stream_size));
}

/* PPP -- added "empty" label and changed f to Z_OK */
#define NEEDBYTE {if (z->avail_in == 0) goto empty; r = Z_OK; } ((void)0)
#define NEXTBYTE (z->avail_in--, z->total_in++, *z->next_in++)

int
inflate(z, f)
z_streamp z;
int f;
{
        int r;
        uInt b;

        if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL)
                return (Z_STREAM_ERROR);
        /* f = f == Z_FINISH ? Z_BUF_ERROR : Z_OK; -- PPP; Z_FINISH unused */
        r = Z_BUF_ERROR;
        /* CONSTCOND */
        while (1)
                switch (z->state->mode)
        {
        case METHOD:
                NEEDBYTE;
                if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED)
                {
                        z->state->mode = BAD;
                        z->msg = "unknown compression method";
                        /* can't try inflateSync */
                        z->state->sub.marker = 5;
                        break;
                }
                if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
                {
                        z->state->mode = BAD;
                        z->msg = "invalid window size";
                        /* can't try inflateSync */
                        z->state->sub.marker = 5;
                        break;
                }
                z->state->mode = FLAG;
                /* FALLTHRU */
        case FLAG:
                NEEDBYTE;
                b = NEXTBYTE;
                if (((z->state->sub.method << 8) + b) % 31)
                {
                        z->state->mode = BAD;
                        z->msg = "incorrect header check";
                        /* can't try inflateSync */
                        z->state->sub.marker = 5;
                        break;
                }
                Trace((stderr, "inflate: zlib header ok\n"));
                if (!(b & PRESET_DICT))
                {
                        z->state->mode = BLOCKS;
                        break;
                }
                z->state->mode = DICT4;
                /* FALLTHRU */
        case DICT4:
                NEEDBYTE;
                z->state->sub.check.need = (uLong)NEXTBYTE << 24;
                z->state->mode = DICT3;
                /* FALLTHRU */
        case DICT3:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE << 16;
                z->state->mode = DICT2;
                /* FALLTHRU */
        case DICT2:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE << 8;
                z->state->mode = DICT1;
                /* FALLTHRU */
        case DICT1:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE;
                z->adler = z->state->sub.check.need;
                z->state->mode = DICT0;
                return (Z_NEED_DICT);
        case DICT0:
                z->state->mode = BAD;
                z->msg = "need dictionary";
                z->state->sub.marker = 0;       /* can try inflateSync */
                return (Z_STREAM_ERROR);
        case BLOCKS:
                r = inflate_blocks(z->state->blocks, z, r);
                if (f == Z_PACKET_FLUSH && z->avail_in == 0 &&  /* PPP */
                    z->avail_out != 0)                          /* PPP */
                        r = inflate_packet_flush(z->state->blocks); /* PPP */
                if (r == Z_DATA_ERROR)
                {
                        z->state->mode = BAD;
                        /* can try inflateSync */
                        z->state->sub.marker = 0;
                        break;
                }
                /* PPP */
                if (r != Z_STREAM_END)
                        return (r);
                r = Z_OK;       /* PPP */
                inflate_blocks_reset(z->state->blocks, z,
                    &z->state->sub.check.was);
                if (z->state->nowrap)
                {
                        z->state->mode = DONE;
                        break;
                }
                z->state->mode = CHECK4;
                /* FALLTHRU */
        case CHECK4:
                NEEDBYTE;
                z->state->sub.check.need = (uLong)NEXTBYTE << 24;
                z->state->mode = CHECK3;
                /* FALLTHRU */
        case CHECK3:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE << 16;
                z->state->mode = CHECK2;
                /* FALLTHRU */
        case CHECK2:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE << 8;
                z->state->mode = CHECK1;
                /* FALLTHRU */
        case CHECK1:
                NEEDBYTE;
                z->state->sub.check.need += (uLong)NEXTBYTE;

                if (z->state->sub.check.was != z->state->sub.check.need)
                {
                        z->state->mode = BAD;
                        z->msg = "incorrect data check";
                        /* can't try inflateSync */
                        z->state->sub.marker = 5;
                        break;
                }
                Trace((stderr, "inflate: zlib check ok\n"));
                z->state->mode = DONE;
                /* FALLTHRU */
        case DONE:
                return (Z_STREAM_END);
        case BAD:
                return (Z_DATA_ERROR);
        default:
                return (Z_STREAM_ERROR);
        }

/* PPP -- packet flush handling */
empty:
        if (f != Z_PACKET_FLUSH)
                return (r);
        z->state->mode = BAD;
        z->msg = "need more for packet flush";
        z->state->sub.marker = 0;       /* can try inflateSync */
        return (Z_DATA_ERROR);
}


int
inflateSetDictionary(z, dictionary, dictLength)
z_streamp z;
const Bytef *dictionary;
uInt  dictLength;
{
        uInt length = dictLength;

        if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0)
                return (Z_STREAM_ERROR);

        if (adler32(1L, dictionary, dictLength) != z->adler)
                return (Z_DATA_ERROR);
        z->adler = 1L;

        if (length >= ((uInt)1<<z->state->wbits))
        {
                length = (1<<z->state->wbits)-1;
                dictionary += dictLength - length;
        }
        inflate_set_dictionary(z->state->blocks, dictionary, length);
        z->state->mode = BLOCKS;
        return (Z_OK);
}

/*
 * This subroutine adds the data at next_in/avail_in to the output history
 * without performing any output.  The output buffer must be "caught up";
 * i.e. no pending output (hence s->read equals s->write), and the state must
 * be BLOCKS (i.e. we should be willing to see the start of a series of
 * BLOCKS).  On exit, the output will also be caught up, and the checksum
 * will have been updated if need be.
 *
 * Added for PPP.
 */

int
inflateIncomp(z)
z_stream *z;
{
        if (z->state->mode != BLOCKS)
                return (Z_DATA_ERROR);
        return (inflate_addhistory(z->state->blocks, z));
}


int
inflateSync(z)
z_streamp z;
{
        uInt n; /* number of bytes to look at */
        Bytef *p;       /* pointer to bytes */
        uInt m; /* number of marker bytes found in a row */
        uLong r, w;     /* temporaries to save total_in and total_out */

        /* set up */
        if (z == Z_NULL || z->state == Z_NULL)
                return (Z_STREAM_ERROR);
        if (z->state->mode != BAD)
        {
                z->state->mode = BAD;
                z->state->sub.marker = 0;
        }
        if ((n = z->avail_in) == 0)
                return (Z_BUF_ERROR);
        p = z->next_in;
        m = z->state->sub.marker;

        /* search */
        while (n && m < 4)
        {
                static const Byte mark[4] = { 0, 0, 0xff, 0xff };
                if (*p == mark[m])
                        m++;
                else if (*p)
                        m = 0;
                else
                        /*
                         * This statement maps 2->2 and 3->1 because a
                         * mismatch with input byte 0x00 on the first
                         * 0xFF in the pattern means that we still
                         * have two contiguous zeros matched (thus
                         * offset 2 is kept), but a mismatch on the
                         * second 0xFF means that only one 0x00 byte
                         * has been matched.  (Boyer-Moore like
                         * search.)
                         */
                        m = 4 - m;
                p++, n--;
        }

        /* restore */
        z->total_in += p - z->next_in;
        z->next_in = p;
        z->avail_in = n;
        z->state->sub.marker = m;

        /* return no joy or set up to restart on a new block */
        if (m != 4)
                return (Z_DATA_ERROR);
        r = z->total_in;  w = z->total_out;
        (void) inflateReset(z);
        z->total_in = r;  z->total_out = w;
        z->state->mode = BLOCKS;
        return (Z_OK);
}

/*
 * Returns true if inflate is currently at the end of a block
 * generated by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by
 * one PPP implementation to provide an additional safety check. PPP
 * uses Z_SYNC_FLUSH but removes the length bytes of the resulting
 * empty stored block. When decompressing, PPP checks that at the end
 * of input packet, inflate is waiting for these length bytes.
 */
int
inflateSyncPoint(z)
z_streamp z;
{
        if (z == Z_NULL || z->state == Z_NULL || z->state->blocks == Z_NULL)
                return (Z_STREAM_ERROR);
        return (inflate_blocks_sync_point(z->state->blocks));
}

#undef NEEDBYTE
#undef NEXTBYTE
/* --- inflate.c */

/* +++ infblock.c */
/*
 * infblock.c -- interpret and process block types to last block
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */
/* #include "infblock.h" */

/* +++ inftrees.h */
/*
 * inftrees.h -- header to use inftrees.c
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

/*
 * Huffman code lookup table entry--this entry is four bytes for
 * machines that have 16-bit pointers (e.g. PC's in the small or
 * medium model).
 */

typedef struct inflate_huft_s FAR inflate_huft;

struct inflate_huft_s {
        union {
                struct {
                        Byte Exop;      /* number of extra bits or operation */
                        /* number of bits in this code or subcode */
                        Byte Bits;
                } what;
                Bytef *pad;     /* pad structure to a power of 2 (4 bytes for */
        } word; /*  16-bit, 8 bytes for 32-bit machines) */
        /* literal, length base, distance base, or table offset */
        uInt base;
};

/*
 * Maximum size of dynamic tree.  The maximum found in a long but non-
 * exhaustive search was 1004 huft structures (850 for length/literals
 * and 154 for distances, the latter actually the result of an
 * exhaustive search).  The actual maximum is not known, but the value
 * below is more than safe.
 */
#define MANY 1440

extern int inflate_trees_bits OF((
    uIntf *,                    /* 19 code lengths */
    uIntf *,                    /* bits tree desired/actual depth */
    inflate_huft * FAR *,       /* bits tree result */
    inflate_huft *,             /* space for trees */
    z_streamp));        /* for zalloc, zfree functions */

extern int inflate_trees_dynamic OF((
    uInt,       /* number of literal/length codes */
    uInt,       /* number of distance codes */
    uIntf *,    /* that many (total) code lengths */
    uIntf *,    /* literal desired/actual bit depth */
    uIntf *,    /* distance desired/actual bit depth */
    inflate_huft * FAR *,       /* literal/length tree result */
    inflate_huft * FAR *,       /* distance tree result */
    inflate_huft *,             /* space for trees */
    z_streamp));        /* for zalloc, zfree functions */

extern int inflate_trees_fixed OF((
    uIntf *,    /* literal desired/actual bit depth */
    uIntf *,    /* distance desired/actual bit depth */
    const inflate_huft * FAR *, /* literal/length tree result */
    const inflate_huft * FAR *, /* distance tree result */
    z_streamp));

/* --- inftrees.h */

/* +++ infcodes.h */
/*
 * infcodes.h -- header to use infcodes.c
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

struct inflate_codes_state;
typedef struct inflate_codes_state FAR inflate_codes_statef;

extern inflate_codes_statef *inflate_codes_new OF((
    uInt, uInt,
    const inflate_huft *, const inflate_huft *,
    z_streamp));

extern int inflate_codes OF((
    inflate_blocks_statef *,
    z_streamp,
    int));

extern void inflate_codes_free OF((
    inflate_codes_statef *,
    z_streamp));

/* --- infcodes.h */

/* +++ infutil.h */
/*
 * infutil.h -- types and macros common to blocks and codes
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

#ifndef _INFUTIL_H
#define _INFUTIL_H

typedef enum {
        TYPE,   /* get type bits (3, including end bit) */
        LENS,   /* get lengths for stored */
        STORED, /* processing stored block */
        TABLE,  /* get table lengths */
        BTREE,  /* get bit lengths tree for a dynamic block */
        DTREE,  /* get length, distance trees for a dynamic block */
        CODES,  /* processing fixed or dynamic block */
        DRY,    /* output remaining window bytes */
        DONEB,  /* finished last block, done */
        BADB}   /* got a data error--stuck here */
inflate_block_mode;

/* inflate blocks semi-private state */
struct inflate_blocks_state {

        /* mode */
        inflate_block_mode  mode;       /* current inflate_block mode */

        /* mode dependent information */
        union {
                uInt left;      /* if STORED, bytes left to copy */
                struct {
                        uInt table;     /* table lengths (14 bits) */
                        uInt index;     /* index into blens (or border) */
                        uIntf *blens;   /* bit lengths of codes */
                        uInt bb;        /* bit length tree depth */
                        inflate_huft *tb;       /* bit length decoding tree */
                } trees;        /* if DTREE, decoding info for trees */
                struct {
                        inflate_codes_statef *codes;
                } decode;       /* if CODES, current state */
        } sub;  /* submode */
        uInt last;      /* true if this block is the last block */

        /* mode independent information */
        uInt bitk;      /* bits in bit buffer */
        uLong bitb;     /* bit buffer */
        inflate_huft *hufts;  /* single malloc for tree space */
        Bytef *window;  /* sliding window */
        Bytef *end;     /* one byte after sliding window */
        Bytef *read;    /* window read pointer */
        Bytef *write;   /* window write pointer */
        check_func checkfn;     /* check function */
        uLong check;    /* check on output */

};


/* defines for inflate input/output */
/*   update pointers and return */
#define UPDBITS {s->bitb = b; s->bitk = k; }
#define UPDIN {z->avail_in = n; z->total_in += p-z->next_in; z->next_in = p; }
#define UPDOUT {s->write = q; }
#define UPDATE {UPDBITS UPDIN UPDOUT}
#define LEAVE {UPDATE return (inflate_flush(s, z, r)); }
/*   get bytes and bits */
#define LOADIN {p = z->next_in; n = z->avail_in; b = s->bitb; k = s->bitk; }
#define NEEDBYTE { if (n) r = Z_OK; else LEAVE }
#define NEXTBYTE (n--, *p++)
#define NEEDBITS(j) { while (k < (j)) { NEEDBYTE; b |= ((uLong)NEXTBYTE)<<k; \
        k += 8; }}
#define DUMPBITS(j) {b >>= (j); k -= (j); }
/*   output bytes */
#define WAVAIL (uInt)(q < s->read ? s->read-q-1 : s->end-q)
#define LOADOUT {q = s->write; m = (uInt)WAVAIL; }
#define WWRAP {if (q == s->end && s->read != s->window) {q = s->window; \
        m = (uInt)WAVAIL; }}
#define FLUSH {UPDOUT r = inflate_flush(s, z, r); LOADOUT}
#define NEEDOUT {if (m == 0) {WWRAP if (m == 0) { FLUSH WWRAP \
        if (m == 0) LEAVE }} r = Z_OK; }
#define OUTBYTE(a) {*q++ = (Byte)(a); m--; }
/*   load local pointers */
#define LOAD {LOADIN LOADOUT}

/* masks for lower bits (size given to avoid silly warnings with Visual C++) */
extern uInt inflate_mask[17];

/* copy as much as possible from the sliding window to the output area */
extern int inflate_flush OF((
    inflate_blocks_statef *,
    z_streamp,
    int));

#ifndef NO_DUMMY_DECL
struct internal_state {int dummy; };    /* for buggy compilers */
#endif

#endif
/* --- infutil.h */

#ifndef NO_DUMMY_DECL
struct inflate_codes_state {int dummy; };       /* for buggy compilers */
#endif

/* Table for deflate from PKZIP's appnote.txt. */
local const uInt border[] = { /* Order of the bit length code lengths */
        16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

/*
 * 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.
 */


void
inflate_blocks_reset(s, z, c)
inflate_blocks_statef *s;
z_streamp z;
uLongf *c;
{
        if (c != Z_NULL)
                *c = s->check;
        if ((s->mode == BTREE || s->mode == DTREE) &&
            s->sub.trees.blens != Z_NULL) {
                ZFREE(z, s->sub.trees.blens);
                s->sub.trees.blens = Z_NULL;
        }
        if (s->mode == CODES && s->sub.decode.codes != Z_NULL) {
                (void) inflate_codes_free(s->sub.decode.codes, z);
                s->sub.decode.codes = Z_NULL;
        }
        s->mode = TYPE;
        s->bitk = 0;
        s->bitb = 0;
        s->read = s->write = s->window;
        if (s->checkfn != Z_NULL)
                z->adler = s->check = (*s->checkfn)(0L, Z_NULL, 0);
        Trace((stderr, "inflate:   blocks reset\n"));
}

inflate_blocks_statef *
inflate_blocks_new(z, c, w)
z_streamp z;
check_func c;
uInt w;
{
        inflate_blocks_statef *s;

        if ((s = (inflate_blocks_statef *)ZALLOC
            (z, 1, sizeof (struct inflate_blocks_state))) == Z_NULL)
                return (s);
        s->hufts = (inflate_huft *)ZALLOC(z, MANY, sizeof (inflate_huft));
        if (s->hufts == Z_NULL) {
                ZFREE(z, s);
                return (Z_NULL);
        }
        if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
        {
                ZFREE(z, s->hufts);
                ZFREE(z, s);
                return (Z_NULL);
        }
        s->end = s->window + w;
        s->checkfn = c;
        s->mode = TYPE;
        Trace((stderr, "inflate:   blocks allocated\n"));
        inflate_blocks_reset(s, z, Z_NULL);
        return (s);
}


int
inflate_blocks(s, z, r)
inflate_blocks_statef *s;
z_streamp z;
int r;
{
        uInt t; /* temporary storage */
        uLong b;        /* bit buffer */
        uInt k; /* bits in bit buffer */
        Bytef *p;       /* input data pointer */
        uInt n; /* bytes available there */
        Bytef *q;       /* output window write pointer */
        uInt m; /* bytes to end of window or read pointer */

        /* copy input/output information to locals (UPDATE macro restores) */
        LOAD;

        /* process input based on current state */
        /* CONSTCOND */
        while (1)
                switch (s->mode)
        {
        case TYPE:
                NEEDBITS(3);
                t = (uInt)b & 7;
                s->last = t & 1;
                switch (t >> 1)
                {
                case 0:                 /* stored */
                        Trace((stderr, "inflate:     stored block%s\n",
                            s->last ? " (last)" : ""));
                        DUMPBITS(3);
                        t = k & 7;      /* go to byte boundary */
                        DUMPBITS(t);
                        s->mode = LENS; /* get length of stored block */
                        break;
                case 1:                 /* fixed */
                        Trace((stderr, "inflate:     fixed codes block%s\n",
                            s->last ? " (last)" : ""));
                        {
                                uInt bl, bd;
                                const inflate_huft *tl, *td;

                                (void) inflate_trees_fixed(&bl, &bd, &tl, &td,
                                    z);
                                s->sub.decode.codes = inflate_codes_new(bl,
                                    bd, tl, td, z);
                                if (s->sub.decode.codes == Z_NULL)
                                {
                                        r = Z_MEM_ERROR;
                                        LEAVE
                                }
                        }
                        DUMPBITS(3);
                        s->mode = CODES;
                        break;
                case 2:                 /* dynamic */
                        Trace((stderr, "inflate:     dynamic codes block%s\n",
                            s->last ? " (last)" : ""));
                        DUMPBITS(3);
                        s->mode = TABLE;
                        break;
                case 3:                 /* illegal */
                        DUMPBITS(3);
                        s->mode = BADB;
                        z->msg = "invalid block type";
                        r = Z_DATA_ERROR;
                        LEAVE
                }
                break;
        case LENS:
                NEEDBITS(32);
                if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
                {
                        s->mode = BADB;
                        z->msg = "invalid stored block lengths";
                        r = Z_DATA_ERROR;
                        LEAVE
                }
                s->sub.left = (uInt)b & 0xffff;
                b = k = 0;      /* dump bits */
                Tracev((stderr, "inflate:       stored length %u\n",
                    s->sub.left));
                s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE);
                break;
        case STORED:
                if (n == 0)
                        LEAVE
                NEEDOUT;
                t = s->sub.left;
                if (t > n) t = n;
                if (t > m) t = m;
                zmemcpy(q, p, t);
                p += t;  n -= t;
                q += t;  m -= t;
                if ((s->sub.left -= t) != 0)
                        break;
                Tracev((stderr,
                    "inflate:       stored end, %lu total out\n",
                    z->total_out + (q >= s->read ? q - s->read :
                        (s->end - s->read) + (q - s->window))));
                s->mode = s->last ? DRY : TYPE;
                break;
        case TABLE:
                NEEDBITS(14);
                s->sub.trees.table = t = (uInt)b & 0x3fff;
#ifndef PKZIP_BUG_WORKAROUND
                if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
                {
                        s->mode = BADB;
                        z->msg =
                            (char *)"too many length or distance symbols";
                        r = Z_DATA_ERROR;
                        LEAVE
                }
#endif
                t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
                /* if (t < 19) t = 19; */
                if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t,
                    sizeof (uInt))) == Z_NULL)
                {
                        r = Z_MEM_ERROR;
                        LEAVE
                }
                DUMPBITS(14);
                s->sub.trees.index = 0;
                Tracev((stderr, "inflate:       table sizes ok\n"));
                s->mode = BTREE;
                /* FALLTHRU */
        case BTREE:
                while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
                {
                        NEEDBITS(3);
                        s->sub.trees.blens[border[s->sub.trees.index++]] =
                            (uInt)b & 7;
                        DUMPBITS(3);
                }
                while (s->sub.trees.index < 19)
                        s->sub.trees.blens[border[s->sub.trees.index++]] =
                            0;
                s->sub.trees.bb = 7;
                t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
                    &s->sub.trees.tb, s->hufts, z);
                if (t != Z_OK)
                {
                        ZFREE(z, s->sub.trees.blens);
                        s->sub.trees.blens = Z_NULL;
                        r = t;
                        if (r == Z_DATA_ERROR)
                                s->mode = BADB;
                        LEAVE
                }
                s->sub.trees.index = 0;
                Tracev((stderr, "inflate:       bits tree ok\n"));
                s->mode = DTREE;
                /* FALLTHRU */
        case DTREE:
                while (t = s->sub.trees.table,
                    s->sub.trees.index < 258 + (t & 0x1f) +
                    ((t >> 5) & 0x1f))
                {
                        inflate_huft *h;
                        uInt i, j, c;

                        t = s->sub.trees.bb;
                        NEEDBITS(t);
                        h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
                        t = h->word.what.Bits;
                        c = h->base;
                        if (c < 16)
                        {
                                DUMPBITS(t);
                                s->sub.trees.blens[s->sub.trees.index++] =
                                    c;
                        } else { /* c == 16..18 */
                                i = c == 18 ? 7 : c - 14;
                                j = c == 18 ? 11 : 3;
                                NEEDBITS(t + i);
                                DUMPBITS(t);
                                j += (uInt)b & inflate_mask[i];
                                DUMPBITS(i);
                                i = s->sub.trees.index;
                                t = s->sub.trees.table;
                                if (i + j > 258 + (t & 0x1f) +
                                    ((t >> 5) & 0x1f) ||
                                    (c == 16 && i < 1))
                                {
                                        ZFREE(z, s->sub.trees.blens);
                                        s->sub.trees.blens = Z_NULL;
                                        s->mode = BADB;
                                        z->msg = "invalid bit length repeat";
                                        r = Z_DATA_ERROR;
                                        LEAVE
                                }
                                c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
                                do {
                                        s->sub.trees.blens[i++] = c;
                                } while (--j);
                                s->sub.trees.index = i;
                        }
                }
                s->sub.trees.tb = Z_NULL;
                {
                        uInt bl, bd;
                        inflate_huft *tl, *td;
                        inflate_codes_statef *c;

                                /* must be <= 9 for lookahead assumptions */
                        bl = 9;
                                /* must be <= 9 for lookahead assumptions */
                        bd = 6;
                        t = s->sub.trees.table;
                        t = inflate_trees_dynamic(257 + (t & 0x1f),
                            1 + ((t >> 5) & 0x1f),
                            s->sub.trees.blens, &bl, &bd, &tl, &td,
                            s->hufts, z);
                        ZFREE(z, s->sub.trees.blens);
                        s->sub.trees.blens = Z_NULL;
                        if (t != Z_OK)
                        {
                                if (t == (uInt)Z_DATA_ERROR)
                                        s->mode = BADB;
                                r = t;
                                LEAVE
                        }
                        Tracev((stderr, "inflate:       trees ok\n"));
                        if ((c = inflate_codes_new(bl, bd, tl, td, z)) ==
                            Z_NULL)
                        {
                                r = Z_MEM_ERROR;
                                LEAVE
                        }
                        s->sub.decode.codes = c;
                }
                s->mode = CODES;
                /* FALLTHRU */
        case CODES:
                UPDATE;
                if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
                        return (inflate_flush(s, z, r));
                r = Z_OK;
                (void) inflate_codes_free(s->sub.decode.codes, z);
                LOAD;
                Tracev((stderr, "inflate:       codes end, %lu total out\n",
                    z->total_out + (q >= s->read ? q - s->read :
                        (s->end - s->read) + (q - s->window))));
                if (!s->last)
                {
                        s->mode = TYPE;
                        break;
                }
                s->mode = DRY;
                /* FALLTHRU */
        case DRY:
                FLUSH;
                if (s->read != s->write)
                        LEAVE
                s->mode = DONEB;
                /* FALLTHRU */
        case DONEB:
                r = Z_STREAM_END;
                LEAVE
        case BADB:
                r = Z_DATA_ERROR;
                LEAVE
        default:
                r = Z_STREAM_ERROR;
                LEAVE
        }
        /* NOTREACHED */
        /* otherwise lint complains */
}


int
inflate_blocks_free(s, z)
inflate_blocks_statef *s;
z_streamp z;
{
        inflate_blocks_reset(s, z, Z_NULL);
        ZFREE(z, s->window);
        s->window = Z_NULL;
        ZFREE(z, s->hufts);
        s->hufts = Z_NULL;
        ZFREE(z, s);
        Trace((stderr, "inflate:   blocks freed\n"));
        return (Z_OK);
}


void
inflate_set_dictionary(s, d, n)
inflate_blocks_statef *s;
const Bytef *d;
uInt  n;
{
        Assert(s->window + n <= s->end, "set dict");
        zmemcpy((charf *)s->window, d, n);
        s->read = s->write = s->window + n;
}

/*
 * Returns true if inflate is currently at the end of a block
 * generated by Z_SYNC_FLUSH or Z_FULL_FLUSH.
 * IN assertion: s != Z_NULL
 */
int
inflate_blocks_sync_point(s)
inflate_blocks_statef *s;
{
        return (s->mode == LENS);
}

/*
 * This subroutine adds the data at next_in/avail_in to the output history
 * without performing any output.  The output buffer must be "caught up";
 * i.e. no pending output (hence s->read equals s->write), and the state must
 * be BLOCKS (i.e. we should be willing to see the start of a series of
 * BLOCKS).  On exit, the output will also be caught up, and the checksum
 * will have been updated if need be.
 */
int
inflate_addhistory(s, z)
inflate_blocks_statef *s;
z_stream *z;
{
        uLong b;        /* bit buffer */  /* NOT USED HERE */
        uInt k; /* bits in bit buffer */ /* NOT USED HERE */
        uInt t; /* temporary storage */
        Bytef *p;       /* input data pointer */
        uInt n; /* bytes available there */
        Bytef *q;       /* output window write pointer */
        uInt m; /* bytes to end of window or read pointer */

        if (s->read != s->write)
                return (Z_STREAM_ERROR);
        if (s->mode != TYPE)
                return (Z_DATA_ERROR);

        /* we're ready to rock */
        LOAD;
        /*
         * while there is input ready, copy to output buffer, moving
         * pointers as needed.
         */
        while (n) {
                t = n;  /* how many to do */
                /* is there room until end of buffer? */
                if (t > m) t = m;
                /* update check information */
                if (s->checkfn != Z_NULL)
                        s->check = (*s->checkfn)(s->check, q, t);
                zmemcpy(q, p, t);
                q += t;
                p += t;
                n -= t;
                z->total_out += t;
                s->read = q;    /* drag read pointer forward */
/* WWRAP */     /* expand WWRAP macro by hand to handle s->read */
                if (q == s->end) {
                        s->read = q = s->window;
                        m = WAVAIL;
                }
        }
        UPDATE;
        return (Z_OK);
}


/*
 * At the end of a Deflate-compressed PPP packet, we expect to have seen
 * a `stored' block type value but not the (zero) length bytes.
 */
int
inflate_packet_flush(s)
    inflate_blocks_statef *s;
{
        if (s->mode != LENS)
                return (Z_DATA_ERROR);
        s->mode = TYPE;
        return (Z_OK);
}
/* --- infblock.c */

/* +++ inftrees.c */
/*
 * inftrees.c -- generate Huffman trees for efficient decoding
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */
/* #include "inftrees.h" */

const char inflate_copyright[] =
" inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
/*
 * 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.
 */

#ifndef NO_DUMMY_DECL
struct internal_state  {int dummy; };   /* for buggy compilers */
#endif

/* simplify the use of the inflate_huft type with some defines */
#define exop word.what.Exop
#define bits word.what.Bits


local int huft_build OF((
        uIntf *,        /* code lengths in bits */
        uInt,           /* number of codes */
        uInt,           /* number of "simple" codes */
        const uIntf *,  /* list of base values for non-simple codes */
        const uIntf *,  /* list of extra bits for non-simple codes */
        inflate_huft * FAR*, /* result: starting table */
        uIntf *,        /* maximum lookup bits (returns actual) */
        inflate_huft *hp,       /* space for trees */
        uInt *hn,       /* hufts used in space */
        uIntf *v));     /* working area: values in order of bit length */

/* Tables for deflate from PKZIP's appnote.txt. */
local const uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */
        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};
        /* see note #13 above about 258 */
local const uInt cplext[31] = { /* Extra bits for literal codes 257..285 */
        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};
        /* 112==invalid */
local const uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */
        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};
local const uInt cpdext[30] = { /* Extra bits for distance codes */
        0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
        7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
        12, 12, 13, 13};

/*
 * 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.
 */


/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
#define BMAX 15         /* maximum bit length of any code */


local int
huft_build(b, n, s, d, e, t, m, hp, hn, v)
uIntf *b;       /* code lengths in bits (all assumed <= BMAX) */
uInt n; /* number of codes (assumed <= 288) */
uInt s; /* number of simple-valued codes (0..s-1) */
const uIntf *d; /* list of base values for non-simple codes */
const uIntf *e; /* list of extra bits for non-simple codes */
inflate_huft * FAR *t;  /* result: starting table */
uIntf *m;       /* maximum lookup bits, returns actual */
inflate_huft *hp;       /* space for trees */
uInt *hn;               /* hufts used in space */
uIntf *v;               /* 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), or Z_MEM_ERROR if not enough
 * memory.
 */
{

        uInt a; /* counter for codes of length k */
        uInt c[BMAX+1]; /* bit length count table */
        uInt f; /* i repeats in table every f entries */
        int g;  /* maximum code length */
        int h;  /* table level */
        register uInt i;        /* counter, current code */
        register uInt j;        /* counter */
        register int k; /* number of bits in current code */
        int l;  /* bits per table (returned in m) */
        register uIntf *p;      /* pointer into c[], b[], or v[] */
        inflate_huft *q;        /* points to current table */
        struct inflate_huft_s r; /* table entry for structure assignment */
        inflate_huft *u[BMAX];  /* table stack */
        uInt mask;      /* (1 << w) - 1, to avoid cc -O bug on HP */
        register int w; /* bits before this table == (l * h) */
        uInt x[BMAX+1]; /* bit offsets, then code stack */
        uIntf *xp;      /* pointer into x */
        int y;  /* number of dummy codes added */
        uInt z; /* number of entries in current table */

        (void) inflate_copyright;
        /* Generate counts for each bit length */
        p = c;
#define C0 *p++ = 0;
#define C2 C0 C0 C0 C0
#define C4 C2 C2 C2 C2
        C4      /* clear c[]--assume BMAX+1 is 16 */
            p = b;  i = n;
        do {
                c[*p++]++;      /* assume all entries <= BMAX */
        } while (--i);
        if (c[0] == n)          /* null input--all zero length codes */
        {
                *t = (inflate_huft *)Z_NULL;
                *m = 0;
                return (Z_OK);
        }


        /* Find minimum and maximum length, bound *m by those */
        l = *m;
        for (j = 1; j <= BMAX; j++)
                if (c[j])
                        break;
        k = j;  /* minimum code length */
        if ((uInt)l < j)
                l = j;
        for (i = BMAX; i; i--)
                if (c[i])
                        break;
        g = i;  /* maximum code length */
        if ((uInt)l > i)
                l = i;
        *m = l;


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


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


        /* Make a table of values in order of bit lengths */
        p = b;  i = 0;
        do {
                if ((j = *p++) != 0)
                        v[x[j]++] = i;
        } while (++i < n);
        n = x[g];       /* set n to length of v */


        /* Generate the Huffman codes and for each, make the table entries */
        x[0] = i = 0;   /* first Huffman code is zero */
        p = v;  /* grab values in bit order */
        h = -1; /* no tables yet--level -1 */
        w = -l; /* bits decoded == (l * h) */
        u[0] = (inflate_huft *)Z_NULL;  /* just to keep compilers happy */
        q = (inflate_huft *)Z_NULL;     /* ditto */
        z = 0;  /* ditto */

        /* go through the bit lengths (k already is bits in shortest code) */
        for (; k <= g; k++) {
                a = c[k];
                while (a--) {
                        /*
                         * here i is the Huffman code of length k bits
                         * for value *p.  make tables up to required
                         * level.
                         */
                        while (k > w + l) {
                                h++;
                                w += l; /* previous table always l bits */

                                /*
                                 * compute minimum size table less
                                 * than or equal to l bits
                                 */
                                z = g - w;
                                /* table size upper limit */
                                z = z > (uInt)l ? l : z;
                                /* try a k-w bit table */
                                if ((f = 1 << (j = k - w)) > a + 1) {
                                        /* too few codes for k-w bit table */
                                        /* deduct codes from patterns left */
                                        f -= a + 1;
                                        xp = c + k;
                                        if (j < z)
                                                /*
                                                 * try smaller tables
                                                 * up to z bits
                                                 */
                                                while (++j < z) {
                                                        /*
                                                         * enough
                                                         * codes to
                                                         * use up j
                                                         * bits
                                                         */
                                                        if ((f <<= 1) <= *++xp)
                                                                break;
                                                        f -= *xp;
                                                        /*
                                                         * else deduct
                                                         * codes from
                                                         * patterns
                                                         */
                                                }
                                }
                                /* table entries for j-bit table */
                                z = 1 << j;

                                /* allocate new table */
                                /* (note: doesn't matter for fixed) */
                                /* not enough memory */
                                if (*hn + z > MANY)
                                        return (Z_MEM_ERROR);
                                u[h] = q = hp + *hn;
                                *hn += z;

                                /* connect to last table, if there is one */
                                if (h) {
                                        /* save pattern for backing up */
                                        x[h] = i;
                                        /* bits to dump before this table */
                                        r.bits = (Byte)l;
                                        /* bits in this table */
                                        r.exop = (Byte)j;
                                        j = i >> (w - l);
                                        /* offset to this table */
                                        r.base = (uInt)(q - u[h-1] - j);
                                        /* connect to last table */
                                        u[h-1][j] = r;
                                } else
                                        /* first table is returned result */
                                        *t = q;
                        }

                        /* set up table entry in r */
                        r.bits = (Byte)(k - w);
                        if (p >= v + n)
                                /* out of values--invalid code */
                                r.exop = 128 + 64;
                        else if (*p < s)
                        {
                                /* 256 is end-of-block */
                                r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);
                                /* simple code is just the value */
                                r.base = *p++;
                        }
                        else
                        {
                                /* non-simple--look up in lists */
                                r.exop = (Byte)(e[*p - s] + 16 + 64);
                                r.base = d[*p++ - s];
                        }

                        /* fill code-like entries with r */
                        f = 1 << (k - w);
                        for (j = i >> w; j < z; j += f)
                                q[j] = r;

                        /* backwards increment the k-bit code i */
                        for (j = 1 << (k - 1); i & j; j >>= 1)
                                i ^= j;
                        i ^= j;

                        /* backup over finished tables */
                        mask = (1 << w) - 1;    /* needed on HP, cc -O bug */
                        while ((i & mask) != x[h])
                        {
                                h--;    /* don't need to update q */
                                w -= l;
                                mask = (1 << w) - 1;
                        }
                }
        }


        /* Return Z_BUF_ERROR if we were given an incomplete table */
        return (y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK);
}


int
inflate_trees_bits(c, bb, tb, hp, z)
uIntf *c;       /* 19 code lengths */
uIntf *bb;      /* bits tree desired/actual depth */
inflate_huft * FAR *tb; /* bits tree result */
inflate_huft *hp;       /* space for trees */
z_streamp z;    /* for zfree function */
{
        int r;
        uInt hn = 0;            /* hufts used in space */
        uIntf v[19];            /* work area for huft_build */

        r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb,
            hp, &hn, v);
        if (r == Z_DATA_ERROR)
                z->msg = "oversubscribed dynamic bit lengths tree";
        else if (r == Z_BUF_ERROR || *bb == 0)
        {
                z->msg = "incomplete dynamic bit lengths tree";
                r = Z_DATA_ERROR;
        }
        return (r);
}


int
inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, hp, z)
uInt nl;        /* number of literal/length codes */
uInt nd;        /* number of distance codes */
uIntf *c;       /* that many (total) code lengths */
uIntf *bl;      /* literal desired/actual bit depth */
uIntf *bd;      /* distance desired/actual bit depth */
inflate_huft * FAR *tl; /* literal/length tree result */
inflate_huft * FAR *td; /* distance tree result */
inflate_huft *hp;       /* space for trees */
z_streamp z;    /* for zfree function */
{
        int r;
        uInt hn = 0;            /* hufts used in space */
        uIntf v[288];           /* work area for huft_build */

        /* build literal/length tree */
        r = huft_build(c, nl, 257, cplens, cplext, tl, bl, hp, &hn, v);
        if (r != Z_OK || *bl == 0)
        {
                if (r == Z_DATA_ERROR)
                        z->msg = "oversubscribed literal/length tree";
                else if (r != Z_MEM_ERROR)
                {
                        z->msg = "incomplete literal/length tree";
                        r = Z_DATA_ERROR;
                }
                return (r);
        }

        /* build distance tree */
        r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, hp, &hn, v);
        if (r != Z_OK || (*bd == 0 && nl > 257))
        {
                if (r == Z_DATA_ERROR)
                        z->msg = "oversubscribed distance tree";
                else if (r == Z_BUF_ERROR) {
#ifdef PKZIP_BUG_WORKAROUND
                        r = Z_OK;
#else
                        z->msg = "incomplete distance tree";
                        r = Z_DATA_ERROR;
                } else if (r != Z_MEM_ERROR) {
                        z->msg = "empty distance tree with lengths";
                        r = Z_DATA_ERROR;
#endif
                }
                return (r);
        }

/* done */
        return (Z_OK);
}


/* build fixed tables only once--keep them here */
/* #define      BUILDFIXED */
#ifdef BUILDFIXED
local int fixed_built = 0;
#define FIXEDH 544      /* number of hufts used by fixed tables */
local inflate_huft fixed_mem[FIXEDH];
local uInt fixed_bl;
local uInt fixed_bd;
local inflate_huft *fixed_tl;
local inflate_huft *fixed_td;
#else
#include "inffixed.h"
#endif

/*ARGSUSED*/
int
inflate_trees_fixed(bl, bd, tl, td, z)
uIntf *bl;      /* literal desired/actual bit depth */
uIntf *bd;      /* distance desired/actual bit depth */
const inflate_huft * FAR *tl;   /* literal/length tree result */
const inflate_huft * FAR *td;   /* distance tree result */
z_streamp z;    /* for memory allocation */
{
#ifdef BUILDFIXED
        /*
         * build fixed tables if not already (multiple overlapped
         * executions ok)
         */
        if (!fixed_built)
        {
                int k;  /* temporary variable */
                uInt f = 0;     /* number of hufts used in fixed_mem */
                uIntf *c;       /* length list for huft_build */
                uIntf *v;

                /* allocate memory */
                if ((c = (uIntf*)ZALLOC(z, 288, sizeof (uInt))) == Z_NULL)
                        return (Z_MEM_ERROR);
                if ((v = (uIntf*)ZALLOC(z, 288, sizeof (uInt))) == Z_NULL)
                {
                        ZFREE(z, c);
                        return (Z_MEM_ERROR);
                }
                /* literal table */
                for (k = 0; k < 144; k++)
                        c[k] = 8;
                for (; k < 256; k++)
                        c[k] = 9;
                for (; k < 280; k++)
                        c[k] = 7;
                for (; k < 288; k++)
                        c[k] = 8;
                fixed_bl = 9;
                (void) huft_build(c, 288, 257, cplens, cplext, &fixed_tl,
                    &fixed_bl, fixed_mem, &f, v);

                /* distance table */
                for (k = 0; k < 30; k++)
                        c[k] = 5;
                fixed_bd = 5;
                (void) huft_build(c, 30, 0, cpdist, cpdext, &fixed_td,
                    &fixed_bd, fixed_mem, &f, v);

                /* done */
                ZFREE(z, v);
                ZFREE(z, c);
                fixed_built = 1;
        }
#endif
        *bl = fixed_bl;
        *bd = fixed_bd;
        *tl = fixed_tl;
        *td = fixed_td;
        return (Z_OK);
}
/* --- inftrees.c */

/* +++ infcodes.c */
/*
 * infcodes.c -- process literals and length/distance pairs
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */
/* #include "inftrees.h" */
/* #include "infblock.h" */
/* #include "infcodes.h" */
/* #include "infutil.h" */

/* +++ inffast.h */
/*
 * inffast.h -- header to use inffast.c
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/*
 * WARNING: this file should *not* be used by applications. It is part
 * of the implementation of the compression library and is subject to
 * change. Applications should only use zlib.h.
 */

extern int inflate_fast OF((
    uInt,
    uInt,
    const inflate_huft *,
    const inflate_huft *,
    inflate_blocks_statef *,
    z_streamp));
/* --- inffast.h */

/* simplify the use of the inflate_huft type with some defines */
#define exop word.what.Exop
#define bits word.what.Bits

/* inflate codes private state */
struct inflate_codes_state {

        /* mode */
        enum {  /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
                START,  /* x: set up for LEN */
                LEN,    /* i: get length/literal/eob next */
                LENEXT, /* i: getting length extra (have base) */
                DIST,   /* i: get distance next */
                DISTEXT,        /* i: getting distance extra */
                COPY,   /* o: copying bytes in window, waiting for space */
                LIT,    /* o: got literal, waiting for output space */
                WASH,   /* o: got eob, possibly still output waiting */
                END,    /* x: got eob and all data flushed */
                BADCODE}        /* x: got error */
        mode;   /* current inflate_codes mode */

        /* mode dependent information */
        uInt len;
        union {
                struct {
                        const inflate_huft *tree;       /* pointer into tree */
                        uInt need;      /* bits needed */
                } code; /* if LEN or DIST, where in tree */
                uInt lit;       /* if LIT, literal */
                struct {
                        uInt get;       /* bits to get for extra */
                        uInt dist;      /* distance back to copy from */
                } copy; /* if EXT or COPY, where and how much */
        } sub;  /* submode */

        /* mode independent information */
        Byte lbits;     /* ltree bits decoded per branch */
        Byte dbits;     /* dtree bits decoder per branch */
        const inflate_huft *ltree;      /* literal/length/eob tree */
        const inflate_huft *dtree;      /* distance tree */

};


inflate_codes_statef *
inflate_codes_new(bl, bd, tl, td, z)
uInt bl, bd;
const inflate_huft *tl;
const inflate_huft *td; /* need separate declaration for Borland C++ */
z_streamp z;
{
        inflate_codes_statef *c;

        if ((c = (inflate_codes_statef *)
            ZALLOC(z, 1, sizeof (struct inflate_codes_state))) != Z_NULL)
        {
                c->mode = START;
                c->lbits = (Byte)bl;
                c->dbits = (Byte)bd;
                c->ltree = tl;
                c->dtree = td;
                Tracev((stderr, "inflate:       codes new\n"));
        }
        return (c);
}


int
inflate_codes(s, z, r)
inflate_blocks_statef *s;
z_streamp z;
int r;
{
        uInt j; /* temporary storage */
        const inflate_huft *t;  /* temporary pointer */
        uInt e; /* extra bits or operation */
        uLong b;        /* bit buffer */
        uInt k; /* bits in bit buffer */
        Bytef *p;       /* input data pointer */
        uInt n; /* bytes available there */
        Bytef *q;       /* output window write pointer */
        uInt m; /* bytes to end of window or read pointer */
        Bytef *f;       /* pointer to copy strings from */
        inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */

        /* copy input/output information to locals (UPDATE macro restores) */
        LOAD;

        /* process input and output based on current state */
        /* CONSTCOND */
        while (1)
                /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
                switch (c->mode) {
                case START:     /* x: set up for LEN */
#ifndef SLOW
                        if (m >= 258 && n >= 10)
                        {
                                UPDATE;
                                r = inflate_fast(c->lbits, c->dbits,
                                    c->ltree, c->dtree, s, z);
                                LOAD;
                                if (r != Z_OK) {
                                        c->mode = r == Z_STREAM_END ?
                                            WASH : BADCODE;
                                        break;
                                }
                        }
#endif /* !SLOW */
                        c->sub.code.need = c->lbits;
                        c->sub.code.tree = c->ltree;
                        c->mode = LEN;
                        /* FALLTHRU */
                case LEN:       /* i: get length/literal/eob next */
                        j = c->sub.code.need;
                        NEEDBITS(j);
                        t = c->sub.code.tree +
                            ((uInt)b & inflate_mask[j]);
                        DUMPBITS(t->bits);
                        e = (uInt)(t->exop);
                        if (e == 0) {   /* literal */
                                c->sub.lit = t->base;
                                Tracevv((stderr, t->base >= 0x20 &&
                                    t->base < 0x7f ?
                                    "inflate:         literal '%c'\n" :
                                    "inflate:         literal 0x%02x\n",
                                    t->base));
                                c->mode = LIT;
                                break;
                        }
                        if (e & 16) {   /* length */
                                c->sub.copy.get = e & 15;
                                c->len = t->base;
                                c->mode = LENEXT;
                                break;
                        }
                        if ((e & 64) == 0) {    /* next table */
                                c->sub.code.need = e;
                                c->sub.code.tree = t + t->base;
                                break;
                        }
                        if (e & 32) {   /* end of block */
                                Tracevv((stderr,
                                    "inflate:         end of block\n"));
                                c->mode = WASH;
                                break;
                        }
                        c->mode = BADCODE;      /* invalid code */
                        z->msg = "invalid literal/length code";
                        r = Z_DATA_ERROR;
                        LEAVE
                case LENEXT:    /* i: getting length extra (have base) */
                        j = c->sub.copy.get;
                        NEEDBITS(j);
                        c->len += (uInt)b & inflate_mask[j];
                        DUMPBITS(j);
                        c->sub.code.need = c->dbits;
                        c->sub.code.tree = c->dtree;
                        Tracevv((stderr,
                            "inflate:         length %u\n", c->len));
                        c->mode = DIST;
                        /* FALLTHRU */
                case DIST:      /* i: get distance next */
                        j = c->sub.code.need;
                        NEEDBITS(j);
                        t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
                        DUMPBITS(t->bits);
                        e = (uInt)(t->exop);
                        if (e & 16) {   /* distance */
                                c->sub.copy.get = e & 15;
                                c->sub.copy.dist = t->base;
                                c->mode = DISTEXT;
                                break;
                        }
                        if ((e & 64) == 0) {    /* next table */
                                c->sub.code.need = e;
                                c->sub.code.tree = t + t->base;
                                break;
                        }
                        c->mode = BADCODE;      /* invalid code */
                        z->msg = "invalid distance code";
                        r = Z_DATA_ERROR;
                        LEAVE
                case DISTEXT:   /* i: getting distance extra */
                        j = c->sub.copy.get;
                        NEEDBITS(j);
                        c->sub.copy.dist += (uInt)b & inflate_mask[j];
                        DUMPBITS(j);
                        Tracevv((stderr,
                            "inflate:         distance %u\n",
                            c->sub.copy.dist));
                        c->mode = COPY;
                        /* FALLTHRU */
                case COPY:
                        /* o: copying bytes in window, waiting for space */
#ifndef __TURBOC__ /* Turbo C bug for following expression */
                        f = (uInt)(q - s->window) < c->sub.copy.dist ?
                            s->end - (c->sub.copy.dist - (q - s->window)) :
                                q - c->sub.copy.dist;
#else
                        f = q - c->sub.copy.dist;
                        if ((uInt)(q - s->window) < c->sub.copy.dist)
                                f = s->end - (c->sub.copy.dist -
                                    (uInt)(q - s->window));
#endif
                        while (c->len)
                        {
                                NEEDOUT;
                                OUTBYTE(*f++);
                                if (f == s->end)
                                        f = s->window;
                                c->len--;
                        }
                        c->mode = START;
                        break;
                case LIT:       /* o: got literal, waiting for output space */
                        NEEDOUT;
                        OUTBYTE(c->sub.lit);
                        c->mode = START;
                        break;
                case WASH:      /* o: got eob, possibly more output */
                        if (k > 7) {    /* return unused byte, if any */
                                Assert(k < 16,
                                    "inflate_codes grabbed too many bytes");
                                k -= 8;
                                n++;
                                p--;    /* can always return one */
                        }
                        FLUSH;
                        if (s->read != s->write)
                                LEAVE
                        c->mode = END;
                        /* FALLTHRU */
                case END:
                        r = Z_STREAM_END;
                        LEAVE
                case BADCODE:   /* x: got error */
                        r = Z_DATA_ERROR;
                        LEAVE
                default:
                        r = Z_STREAM_ERROR;
                        LEAVE
                }
        /* NOTREACHED */
        /* otherwise lint complains */
}


void
inflate_codes_free(c, z)
inflate_codes_statef *c;
z_streamp z;
{
        ZFREE(z, c);
        Tracev((stderr, "inflate:       codes free\n"));
}
/* --- infcodes.c */

/* +++ infutil.c */
/*
 * inflate_util.c -- data and routines common to blocks and codes
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */
/* #include "infblock.h" */
/* #include "inftrees.h" */
/* #include "infcodes.h" */
/* #include "infutil.h" */

#ifndef NO_DUMMY_DECL
struct inflate_codes_state {int dummy; };       /* for buggy compilers */
#endif

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


/* copy as much as possible from the sliding window to the output area */
int
inflate_flush(s, z, r)
inflate_blocks_statef *s;
z_streamp z;
int r;
{
        uInt n;
        Bytef *p;
        Bytef *q;

        /* local copies of source and destination pointers */
        p = z->next_out;
        q = s->read;

        /* compute number of bytes to copy as far as end of window */
        n = (uInt)((q <= s->write ? s->write : s->end) - q);
        if (n > z->avail_out) n = z->avail_out;
        if (n && r == Z_BUF_ERROR) r = Z_OK;

        /* update counters */
        z->avail_out -= n;
        z->total_out += n;

        /* update check information */
        if (s->checkfn != Z_NULL)
                z->adler = s->check = (*s->checkfn)(s->check, q, n);

        /* copy as far as end of window */
        if (p != Z_NULL) {      /* PPP */
                zmemcpy(p, q, n);
                p += n;
        }       /* PPP */
        q += n;

        /* see if more to copy at beginning of window */
        if (q == s->end)
        {
                /* wrap pointers */
                q = s->window;
                if (s->write == s->end)
                        s->write = s->window;

                /* compute bytes to copy */
                n = (uInt)(s->write - q);
                if (n > z->avail_out) n = z->avail_out;
                if (n && r == Z_BUF_ERROR) r = Z_OK;

                /* update counters */
                z->avail_out -= n;
                z->total_out += n;

                /* update check information */
                if (s->checkfn != Z_NULL)
                        z->adler = s->check = (*s->checkfn)(s->check, q, n);

                /* copy */
                if (p != Z_NULL) {      /* PPP */
                        zmemcpy(p, q, n);
                        p += n;
                }       /* PPP */
                q += n;
        }

        /* update pointers */
        z->next_out = p;
        s->read = q;

        /* done */
        return (r);
}
/* --- infutil.c */

/* +++ inffast.c */
/*
 * inffast.c -- process literals and length/distance pairs fast
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* #include "zutil.h" */
/* #include "inftrees.h" */
/* #include "infblock.h" */
/* #include "infcodes.h" */
/* #include "infutil.h" */
/* #include "inffast.h" */

#ifndef NO_DUMMY_DECL
struct inflate_codes_state {int dummy; };       /* for buggy compilers */
#endif

/* simplify the use of the inflate_huft type with some defines */
#define exop word.what.Exop
#define bits word.what.Bits

/* macros for bit input with no checking and for returning unused bytes */
#define GRABBITS(j) { while (k < (j)) {b |= ((uLong)NEXTBYTE)<<k; k += 8; }}
#define UNGRAB {c = z->avail_in-n; c = (k>>3) < c?k>>3:c; n += c; p -= c; \
        k -= c<<3; }

/*
 * 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.
 */

int
inflate_fast(bl, bd, tl, td, s, z)
uInt bl, bd;
const inflate_huft *tl;
const inflate_huft *td; /* need separate declaration for Borland C++ */
inflate_blocks_statef *s;
z_streamp z;
{
        const inflate_huft *t;  /* temporary pointer */
        uInt e; /* extra bits or operation */
        uLong b;        /* bit buffer */
        uInt k; /* bits in bit buffer */
        Bytef *p;       /* input data pointer */
        uInt n; /* bytes available there */
        Bytef *q;       /* output window write pointer */
        uInt m; /* bytes to end of window or read pointer */
        uInt ml;        /* mask for literal/length tree */
        uInt md;        /* mask for distance tree */
        uInt c; /* bytes to copy */
        uInt d; /* distance back to copy from */
        Bytef *r;       /* copy source pointer */

        /* load input, output, bit values */
        LOAD;

        /* initialize masks */
        ml = inflate_mask[bl];
        md = inflate_mask[bd];

        /* do until not enough input or output space for fast loop */
        do {    /* assume called with m >= 258 && n >= 10 */
                /* get literal/length code */
                /* max bits for literal/length code */
                GRABBITS(20);
                if ((e = (t = tl + ((uInt)b & ml))->exop) == 0) {
                        DUMPBITS(t->bits);
                        Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
                            "inflate:         * literal '%c'\n" :
                            "inflate:         * literal 0x%02x\n", t->base));
                        *q++ = (Byte)t->base;
                        m--;
                        continue;
                }
                do {
                        DUMPBITS(t->bits);
                        if (e & 16) {
                                /* get extra bits for length */
                                e &= 15;
                                c = t->base + ((uInt)b & inflate_mask[e]);
                                DUMPBITS(e);
                                Tracevv((stderr,
                                    "inflate:         * length %u\n", c));

                                /* decode distance base of block to copy */
                                GRABBITS(15);   /* max bits for distance code */
                                e = (t = td + ((uInt)b & md))->exop;
                                do {
                                        DUMPBITS(t->bits);
                                        if (e & 16) {
                                                /*
                                                 * get extra bits to
                                                 * add to distance
                                                 * base
                                                 */
                                                e &= 15;
                                                /* get extra bits (up to 13) */
                                                GRABBITS(e);
                                                d = t->base + ((uInt)b &
                                                    inflate_mask[e]);
                                                DUMPBITS(e);
                                                Tracevv((stderr,
                                                    "inflate:         * "
                                                    "distance %u\n", d));

                                                /* do the copy */
                                                m -= c;
                                                /* offset before dest */
                                                if ((uInt)(q - s->window) >= d)
                                                        /*  just copy */
                                                {
                                                        r = q - d;
                                                        /*
                                                         * minimum
                                                         * count is
                                                         * three, so
                                                         * unroll loop
                                                         * a little
                                                         */
                                                        *q++ = *r++;  c--;
                                                        *q++ = *r++;  c--;
                                                }
                                        /* else offset after destination */
                                                else {
        /* bytes from offset to end */
                                                        e = d - (uInt)(q -
                                                            s->window);
        /* pointer to offset */
                                                        r = s->end - e;
                                                        /* if source crosses */
                                                        if (c > e) {
        /* copy to end of window */
                                                                c -= e;
                                                                do {
                                                                        *q++ =
                                                                            *r
                                                                            ++;
                                                                } while (--e);
        /* copy rest from start of window */
                                                                r = s->window;
                                                        }
                                                }
                                                /* copy all or what's left */
                                                do {
                                                        *q++ = *r++;
                                                } while (--c);
                                                break;
                                        } else if ((e & 64) == 0) {
                                                t += t->base;
                                                e = (t += ((uInt)b &
                                                    inflate_mask[e]))->exop;
                                        } else {
                                                z->msg =
                                                    "invalid distance code";
                                                UNGRAB;
                                                UPDATE;
                                                return (Z_DATA_ERROR);
                                        }
                                        /* CONSTCOND */
                                } while (1);
                                break;
                        }
                        if ((e & 64) == 0)
                        {
                                t += t->base;
                                if ((e = (t += ((uInt)b &
                                    inflate_mask[e]))->exop) == 0)
                                {
                                        DUMPBITS(t->bits);
                                        Tracevv((stderr, t->base >= 0x20 &&
                                            t->base < 0x7f ?
                                            "inflate:         * literal '%c'\n"
                                            :
                                            "inflate:         * literal "
                                            "0x%02x\n", t->base));
                                        *q++ = (Byte)t->base;
                                        m--;
                                        break;
                                }
                        } else if (e & 32) {
                                Tracevv((stderr,
                                    "inflate:         * end of block\n"));
                                UNGRAB;
                                UPDATE;
                                return (Z_STREAM_END);
                        } else {
                                z->msg = "invalid literal/length code";
                                UNGRAB;
                                UPDATE;
                                return (Z_DATA_ERROR);
                        }
                        /* CONSTCOND */
                } while (1);
        } while (m >= 258 && n >= 10);

        /* not enough input or output--restore pointers and return */
        UNGRAB;
        UPDATE;
        return (Z_OK);
}
/* --- inffast.c */

/* +++ zutil.c */
/*
 * zutil.c -- target dependent utility functions for the compression library
 * Copyright (C) 1995-1998 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* From: zutil.c,v 1.17 1996/07/24 13:41:12 me Exp $ */

#ifdef DEBUG_ZLIB
#include <stdio.h>
#endif

/* #include "zutil.h" */

#ifndef NO_DUMMY_DECL
struct internal_state   {int dummy; };  /* for buggy compilers */
#endif

#ifndef STDC
extern void exit OF((int));
#endif

static const char *z_errmsg[10] = {
"need dictionary",      /* Z_NEED_DICT          2 */
"stream end",           /* Z_STREAM_END         1 */
"",                     /* Z_OK                 0 */
"file error",           /* Z_ERRNO              (-1) */
"stream error",         /* Z_STREAM_ERROR       (-2) */
"data error",           /* Z_DATA_ERROR         (-3) */
"insufficient memory",  /* Z_MEM_ERROR          (-4) */
"buffer error",         /* Z_BUF_ERROR          (-5) */
"incompatible version", /* Z_VERSION_ERROR      (-6) */
""};


const char *
zlibVersion()
{
        return (ZLIB_VERSION);
}

#ifdef DEBUG_ZLIB
void
z_error(m)
    char *m;
{
        fprintf(stderr, "%s\n", m);
        exit(1);
}
#endif

#ifndef HAVE_MEMCPY

void
zmemcpy(dest, source, len)
    Bytef* dest;
    const Bytef* source;
    uInt  len;
{
        if (len == 0)
                return;
        do {
                *dest++ = *source++;    /* ??? to be unrolled */
        } while (--len != 0);
}

int
zmemcmp(s1, s2, len)
const Bytef* s1;
const Bytef* s2;
uInt  len;
{
        uInt j;

        for (j = 0; j < len; j++) {
                if (s1[j] != s2[j])
                        return (2*(s1[j] > s2[j])-1);
        }
        return (0);
}

void
zmemzero(dest, len)
    Bytef* dest;
    uInt  len;
{
        if (len == 0)
                return;
        do {
                *dest++ = 0;    /* ??? to be unrolled */
        } while (--len != 0);
}
#endif

#ifdef __TURBOC__
#if (defined(__BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
/*
 * Small and medium model in Turbo C are for now limited to near
 * allocation with reduced MAX_WBITS and MAX_MEM_LEVEL
 */
#define MY_ZCALLOC

/*
 * Turbo C malloc() does not allow dynamic allocation of 64K bytes and
 * farmalloc(64K) returns a pointer with an offset of 8, so we must
 * fix the pointer. Warning: the pointer must be put back to its
 * original form in order to free it, use zcfree().
 */

#define MAX_PTR 10
/* 10*64K = 640K */

local int next_ptr = 0;

typedef struct ptr_table_s {
        voidpf org_ptr;
        voidpf new_ptr;
} ptr_table;

local ptr_table table[MAX_PTR];
/*
 * This table is used to remember the original form of pointers to
 * large buffers (64K). Such pointers are normalized with a zero
 * offset.  Since MSDOS is not a preemptive multitasking OS, this
 * table is not protected from concurrent access. This hack doesn't
 * work anyway on a protected system like OS/2. Use Microsoft C
 * instead.
 */

voidpf
zcalloc(voidpf opaque, unsigned items, unsigned size)
{
        voidpf buf = opaque;    /* just to make some compilers happy */
        ulg bsize = (ulg)items*size;

        /*
         * If we allocate less than 65520 bytes, we assume that
         * farmalloc will return a usable pointer which doesn't have
         * to be normalized.
         */
        if (bsize < 65520L) {
                buf = farmalloc(bsize);
                if (*(ush *)&buf != 0)
                        return (buf);
        } else {
                buf = farmalloc(bsize + 16L);
        }
        if (buf == NULL || next_ptr >= MAX_PTR)
                return (NULL);
        table[next_ptr].org_ptr = buf;

        /* Normalize the pointer to seg:0 */
        *((ush *)&buf+1) += ((ush)((uch *)buf-0) + 15) >> 4;
        *(ush *)&buf = 0;
        table[next_ptr++].new_ptr = buf;
        return (buf);
}

void
zcfree(voidpf opaque, voidpf ptr)
{
        int n;
        if (*(ush*)&ptr != 0) { /* object < 64K */
                farfree(ptr);
                return;
        }
        /* Find the original pointer */
        for (n = 0; n < next_ptr; n++) {
                if (ptr != table[n].new_ptr)
                        continue;

                farfree(table[n].org_ptr);
                while (++n < next_ptr) {
                        table[n-1] = table[n];
                }
                next_ptr--;
                return;
        }
        ptr = opaque;   /* just to make some compilers happy */
        Assert(0, "zcfree: ptr not found");
}
#endif
#endif /* __TURBOC__ */


#if defined(M_I86) && !defined(__32BIT__)
/* Microsoft C in 16-bit mode */

#define MY_ZCALLOC

#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
#define _halloc  halloc
#define _hfree   hfree
#endif

voidpf
zcalloc(voidpf opaque, unsigned items, unsigned size)
{
        if (opaque) opaque = 0; /* to make compiler happy */
        return (_halloc((long)items, size));
}

void
zcfree(voidpf opaque, voidpf ptr)
{
        if (opaque) opaque = 0; /* to make compiler happy */
        _hfree(ptr);
}

#endif /* MSC */


#ifndef MY_ZCALLOC /* Any system without a special alloc function */

#ifndef STDC
extern voidp  calloc OF((uInt items, uInt size));
extern void   free   OF((voidpf ptr));
#endif

voidpf
zcalloc(opaque, items, size)
    voidpf opaque;
    unsigned items;
    unsigned size;
{
        if (opaque) items += size - size;       /* make compiler happy */
        return ((voidpf)calloc(items, size));
}

/*ARGSUSED*/
void
zcfree(opaque, ptr)
    voidpf opaque;
    voidpf ptr;
{
        free(ptr);
}

#endif /* MY_ZCALLOC */
/* --- zutil.c */

/* +++ adler32.c */
/*
 * adler32.c -- compute the Adler-32 checksum of a data stream
 * Copyright (C) 1995-1998 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* From: adler32.c,v 1.10 1996/05/22 11:52:18 me Exp $ */

/* #include "zlib.h" */

#define BASE 65521L /* largest prime smaller than 65536 */
#define NMAX 5552
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */

#define DO1(buf, i)  {s1 += buf[i]; s2 += s1; }
#define DO2(buf, i)  DO1(buf, i); DO1(buf, i+1);
#define DO4(buf, i)  DO2(buf, i); DO2(buf, i+2);
#define DO8(buf, i)  DO4(buf, i); DO4(buf, i+4);
#define DO16(buf)   DO8(buf, 0); DO8(buf, 8);

/* ========================================================================= */
uLong
adler32(adler, buf, len)
    uLong adler;
    const Bytef *buf;
    uInt len;
{
        unsigned long s1 = adler & 0xffff;
        unsigned long s2 = (adler >> 16) & 0xffff;
        int k;

        if (buf == Z_NULL)
                return (1L);

        while (len > 0) {
                k = len < NMAX ? len : NMAX;
                len -= k;
                while (k >= 16) {
                        DO16(buf);
                        buf += 16;
                        k -= 16;
                }
                if (k != 0) do {
                        s1 += *buf++;
                        s2 += s1;
                } while (--k);
                s1 %= BASE;
                s2 %= BASE;
        }
        return ((s2 << 16) | s1);
}
/* --- adler32.c */