#else    register uch *strend = window + strstart + MAX_MATCH;    register uch scan_end1  = scan[best_len-1];    register uch scan_end   = scan[best_len];#endif    /* Do not waste too much time if we already have a good match: */    if (prev_length >= good_match) {        chain_length >>= 2;    }    Assert(strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");    do {        Assert(cur_match < strstart, "no future");        match = 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 (*(ush*)(match+best_len-1) != scan_end ||            *(ush*)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.         */        scan++, match++;        do {        } while (*(ush*)(scan+=2) == *(ush*)(match+=2) &&                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&                 *(ush*)(scan+=2) == *(ush*)(match+=2) &&                 scan < strend);        /* The funny "do {}" generates better code on most compilers */        /* Here, scan <= window+strstart+257 */        Assert(scan <= window+(unsigned)(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++;        /* 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);        len = MAX_MATCH - (int)(strend - scan);        scan = strend - MAX_MATCH;#endif /* UNALIGNED_OK */        if (len > best_len) {            match_start = cur_match;            best_len = len;            if (len >= nice_match) break;#ifdef UNALIGNED_OK            scan_end = *(ush*)(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);    return best_len;}#endif /* ASMV */#ifdef DEBUG/* =========================================================================== * Check that the match at match_start is indeed a match. */local void check_match(start, match, length)    IPos start, match;    int length;{    /* check that the match is indeed a match */    if (memcmp((char*)window + match,                (char*)window + start, length) != EQUAL) {        fprintf(stderr,            " start %d, match %d, length %d\n",            start, match, length);        error("invalid match");    }    if (verbose > 1) {        fprintf(stderr,"\\[%d,%d]", start-match, length);        do { putc(window[start++], stderr); } while (--length != 0);    }}#else#  define check_match(start, match, length)#endif/* =========================================================================== * Fill the window when the lookahead becomes insufficient. * Updates strstart and lookahead, and sets eofile if end of input file. * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0 * OUT assertions: at least one byte has been read, or eofile is set; *    file reads are performed for at least two bytes (required for the *    translate_eol option). */local void fill_window(){    register unsigned n, m;    unsigned more = (unsigned)(window_size - (ulg)lookahead - (ulg)strstart);    /* Amount of free space at the end of the window. */    /* 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.     */    if (more == (unsigned)EOF) {        /* Very unlikely, but possible on 16 bit machine if strstart == 0         * and lookahead == 1 (input done one byte at time)         */        more--;    } else if (strstart >= WSIZE+MAX_DIST) {        /* By the IN assertion, the window is not empty so we can't confuse         * more == 0 with more == 64K on a 16 bit machine.         */        Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");        memcpy((char*)window, (char*)window+WSIZE, (unsigned)WSIZE);        match_start -= WSIZE;        strstart    -= WSIZE; /* we now have strstart >= MAX_DIST: */        block_start -= (long) WSIZE;        for (n = 0; n < HASH_SIZE; n++) {            m = head[n];            head[n] = (Pos)(m >= WSIZE ? m-WSIZE : NIL);        }        for (n = 0; n < WSIZE; n++) {            m = prev[n];            prev[n] = (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.             */        }        more += WSIZE;    }    /* At this point, more >= 2 */    if (!eofile) {        n = read_buf((char*)window+strstart+lookahead, more);        if (n == 0 || n == (unsigned)EOF) {            eofile = 1;        } else {            lookahead += n;        }    }}/* =========================================================================== * 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(eof) \   flush_block(block_start >= 0L ? (char*)&window[(unsigned)block_start] : \                (char*)NULL, (long)strstart - block_start, (eof))/* =========================================================================== * Processes a new input file and return its compressed length. This * function does not perform lazy evaluationof 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 ulg deflate_fast(){    IPos hash_head; /* head of the hash chain */    int flush;      /* set if current block must be flushed */    unsigned match_length = 0;  /* length of best match */    prev_length = MIN_MATCH-1;    while (lookahead != 0) {        /* Insert the string window[strstart .. strstart+2] in the         * dictionary, and set hash_head to the head of the hash chain:         */        INSERT_STRING(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 && strstart - hash_head <= MAX_DIST) {            /* 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).             */            match_length = longest_match (hash_head);            /* longest_match() sets match_start */            if (match_length > lookahead) match_length = lookahead;        }        if (match_length >= MIN_MATCH) {            check_match(strstart, match_start, match_length);            flush = ct_tally(strstart-match_start, match_length - MIN_MATCH);            lookahead -= 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 (match_length <= max_insert_length) {                match_length--; /* string at strstart already in hash table */                do {                    strstart++;                    INSERT_STRING(strstart, hash_head);                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are                     * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH                     * these bytes are garbage, but it does not matter since                     * the next lookahead bytes will be emitted as literals.                     */                } while (--match_length != 0);	        strstart++;             } else {	        strstart += match_length;	        match_length = 0;	        ins_h = window[strstart];	        UPDATE_HASH(ins_h, window[strstart+1]);#if MIN_MATCH != 3                Call UPDATE_HASH() MIN_MATCH-3 more times#endif            }        } else {            /* No match, output a literal byte */            Tracevv((stderr,"%c",window[strstart]));            flush = ct_tally (0, window[strstart]);            lookahead--;	    strstart++;         }        if (flush) FLUSH_BLOCK(0), block_start = strstart;        /* 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.         */        while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window();    }    return FLUSH_BLOCK(1); /* eof */}/* =========================================================================== * 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. */ulg deflate(){    IPos hash_head;          /* head of hash chain */    IPos prev_match;         /* previous match */    int flush;               /* set if current block must be flushed */    int match_available = 0; /* set if previous match exists */    register unsigned match_length = MIN_MATCH-1; /* length of best match */#ifdef DEBUG    extern long isize;        /* byte length of input file, for debug only */#endif    if (compr_level <= 3) return deflate_fast(); /* optimized for speed */    /* Process the input block. */    while (lookahead != 0) {        /* Insert the string window[strstart .. strstart+2] in the         * dictionary, and set hash_head to the head of the hash chain:         */        INSERT_STRING(strstart, hash_head);        /* Find the longest match, discarding those <= prev_length.         */        prev_length = match_length, prev_match = match_start;        match_length = MIN_MATCH-1;        if (hash_head != NIL && prev_length < max_lazy_match &&            strstart - hash_head <= MAX_DIST) {            /* 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).             */            match_length = longest_match (hash_head);            /* longest_match() sets match_start */            if (match_length > lookahead) match_length = lookahead;            /* Ignore a length 3 match if it is too distant: */            if (match_length == MIN_MATCH && strstart-match_start > TOO_FAR){                /* If prev_match is also MIN_MATCH, match_start is garbage                 * but we will ignore the current match anyway.                 */                match_length--;            }        }        /* If there was a match at the previous step and the current         * match is not better, output the previous match:         */        if (prev_length >= MIN_MATCH && match_length <= prev_length) {            check_match(strstart-1, prev_match, prev_length);            flush = ct_tally(strstart-1-prev_match, prev_length - MIN_MATCH);            /* Insert in hash table all strings up to the end of the match.             * strstart-1 and strstart are already inserted.             */            lookahead -= prev_length-1;            prev_length -= 2;            do {                strstart++;                INSERT_STRING(strstart, hash_head);                /* strstart never exceeds WSIZE-MAX_MATCH, so there are                 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH                 * these bytes are garbage, but it does not matter since the                 * next lookahead bytes will always be emitted as literals.                 */            } while (--prev_length != 0);            match_available = 0;            match_length = MIN_MATCH-1;            strstart++;            if (flush) FLUSH_BLOCK(0), block_start = strstart;        } else if (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",window[strstart-1]));            if (ct_tally (0, window[strstart-1])) {                FLUSH_BLOCK(0), block_start = strstart;            }            strstart++;            lookahead--;        } else {            /* There is no previous match to compare with, wait for             * the next step to decide.             */            match_available = 1;            strstart++;            lookahead--;        }        Assert (strstart <= isize && lookahead <= isize, "a bit too far");        /* 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.         */        while (lookahead < MIN_LOOKAHEAD && !eofile) fill_window();    }    if (match_available) ct_tally (0, window[strstart-1]);    return FLUSH_BLOCK(1); /* eof */}