bflush = _tr_tally(s, s->strstart - s->match_start, s->match_length - MIN_MATCH);
_tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH, bflush);
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);            bflush = _tr_tally(s, s->strstart - s->match_start,                               s->match_length - MIN_MATCH);            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.             */            if (s->match_length <= s->max_insert_length &&                s->lookahead >= MIN_MATCH) {                s->match_length--; /* string at strstart already in hash table */                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 {                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]));            bflush = _tr_tally (s, 0, s->window[s->strstart]);            s->lookahead--;            s->strstart++;         }        if (bflush) FLUSH_BLOCK(s, 0);    }    FLUSH_BLOCK(s, flush == Z_FINISH);    return flush == Z_FINISH ? finish_done : block_done;}