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;    if (windowBits < 0) { /* undocumented feature: suppress zlib header */        noheader = 1;        windowBits = -windowBits;    }    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||        windowBits < 9 || 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 = (char*)ERR_MSG(Z_MEM_ERROR);        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	dictionary += dictLength - length; /* use the tail of the dictionary */#endif    }    zmemcpy((charf *)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;    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */    strm->data_type = Z_UNKNOWN;    s = (deflate_state *)strm->state;    s->pending = 0;    s->pending_out = s->pending_buf;    if (s->noheader < 0) {        s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */    }    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) {	zmemcpy(strm->next_out, s->pending_out, len);	strm->next_out += len;    }    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_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) {	        s->last_flush = -1; /* avoid BUF_ERROR next call, see above */	    }	    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) {		/* Output just the 3-bit `stored' block type value,		   but not a zero length. */		_tr_stored_type_only(s);            } 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) {	      s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */	      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;