zlib 1.2.0.5v1.2.0.5

14 files changed, 1153 insertions, 2198 deletions

diff --git a/contrib/vstudio/vc70_32/gvmat32.asm b/contrib/masmx86/gvmat32.asm
index 320348f..ec360e6 100644
--- a/contrib/vstudio/vc70_32/gvmat32.asm
+++ b/contrib/masmx86/gvmat32.asm
@@ -1,905 +1,905 @@
-;

-; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86

-; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.

-; File written by Gilles Vollant, by modifiying the longest_match

-;  from Jean-loup Gailly in deflate.c

-; It need wmask == 0x7fff

-;     (assembly code is faster with a fixed wmask)

-;

-; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)

-;   I compile with : "ml /coff /Zi /c gvmat32.asm"

-;

-

-;uInt longest_match_7fff(s, cur_match)

-;    deflate_state *s;

-;    IPos cur_match;                             /* current match */

-

-        NbStack         equ     76

-        cur_match       equ     dword ptr[esp+NbStack-0]

-        str_s           equ     dword ptr[esp+NbStack-4]

-; 5 dword on top (ret,ebp,esi,edi,ebx)

-        adrret          equ     dword ptr[esp+NbStack-8]

-        pushebp         equ     dword ptr[esp+NbStack-12]

-        pushedi         equ     dword ptr[esp+NbStack-16]

-        pushesi         equ     dword ptr[esp+NbStack-20]

-        pushebx         equ     dword ptr[esp+NbStack-24]

-

-        chain_length    equ     dword ptr [esp+NbStack-28]

-        limit           equ     dword ptr [esp+NbStack-32]

-        best_len        equ     dword ptr [esp+NbStack-36]

-        window          equ     dword ptr [esp+NbStack-40]

-        prev            equ     dword ptr [esp+NbStack-44]

-        scan_start      equ      word ptr [esp+NbStack-48]

-        wmask           equ     dword ptr [esp+NbStack-52]

-        match_start_ptr equ     dword ptr [esp+NbStack-56]

-        nice_match      equ     dword ptr [esp+NbStack-60]

-        scan            equ     dword ptr [esp+NbStack-64]

-

-        windowlen       equ     dword ptr [esp+NbStack-68]

-        match_start     equ     dword ptr [esp+NbStack-72]

-        strend          equ     dword ptr [esp+NbStack-76]

-        NbStackAdd      equ     (NbStack-24)

-

-    .386p

-

-    name    gvmatch

-    .MODEL  FLAT

-

-

-

-;  all the +4 offsets are due to the addition of pending_buf_size (in zlib

-;  in the deflate_state structure since the asm code was first written

-;  (if you compile with zlib 1.0.4 or older, remove the +4).

-;  Note : these value are good with a 8 bytes boundary pack structure

-    dep_chain_length    equ     70h+4

-    dep_window          equ     2ch+4

-    dep_strstart        equ     60h+4

-    dep_prev_length     equ     6ch+4

-    dep_nice_match      equ     84h+4

-    dep_w_size          equ     20h+4

-    dep_prev            equ     34h+4

-    dep_w_mask          equ     28h+4

-    dep_good_match      equ     80h+4

-    dep_match_start     equ     64h+4

-    dep_lookahead       equ     68h+4

-

-

-_TEXT                   segment

-

-IFDEF NOUNDERLINE

-                        public  longest_match_7fff

-                        public  longest_match_686

-;                        public  match_init

-ELSE

-                        public  _longest_match_7fff

-                        public  _longest_match_686

-;                        public  _match_init

-ENDIF

-

-    MAX_MATCH           equ     258

-    MIN_MATCH           equ     3

-    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)

-

-

-

-IFDEF NOUNDERLINE

-;match_init      proc near

-;                ret

-;match_init      endp

-ELSE

-;_match_init     proc near

-;                ret

-;_match_init     endp

-ENDIF

-

-

-IFDEF NOUNDERLINE

-longest_match_7fff   proc near

-ELSE

-_longest_match_7fff  proc near

-ENDIF

-

-        mov     edx,[esp+4]

-

-

-

-        push    ebp

-        push    edi

-        push    esi

-        push    ebx

-

-        sub     esp,NbStackAdd

-

-; initialize or check the variables used in match.asm.

-        mov     ebp,edx

-

-; chain_length = s->max_chain_length

-; if (prev_length>=good_match) chain_length >>= 2

-        mov     edx,[ebp+dep_chain_length]

-        mov     ebx,[ebp+dep_prev_length]

-        cmp     [ebp+dep_good_match],ebx

-        ja      noshr

-        shr     edx,2

-noshr:

-; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop

-        inc     edx

-        mov     edi,[ebp+dep_nice_match]

-        mov     chain_length,edx

-        mov     eax,[ebp+dep_lookahead]

-        cmp     eax,edi

-; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;

-        jae     nolookaheadnicematch

-        mov     edi,eax

-nolookaheadnicematch:

-; best_len = s->prev_length

-        mov     best_len,ebx

-

-; window = s->window

-        mov     esi,[ebp+dep_window]

-        mov     ecx,[ebp+dep_strstart]

-        mov     window,esi

-

-        mov     nice_match,edi

-; scan = window + strstart

-        add     esi,ecx

-        mov     scan,esi

-; dx = *window

-        mov     dx,word ptr [esi]

-; bx = *(window+best_len-1)

-        mov     bx,word ptr [esi+ebx-1]

-        add     esi,MAX_MATCH-1

-; scan_start = *scan

-        mov     scan_start,dx

-; strend = scan + MAX_MATCH-1

-        mov     strend,esi

-; bx = scan_end = *(window+best_len-1)

-

-;    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?

-;        s->strstart - (IPos)MAX_DIST(s) : NIL;

-

-        mov     esi,[ebp+dep_w_size]

-        sub     esi,MIN_LOOKAHEAD

-; here esi = MAX_DIST(s)

-        sub     ecx,esi

-        ja      nodist

-        xor     ecx,ecx

-nodist:

-        mov     limit,ecx

-

-; prev = s->prev

-        mov     edx,[ebp+dep_prev]

-        mov     prev,edx

-

-;

-        mov     edx,dword ptr [ebp+dep_match_start]

-        mov     bp,scan_start

-        mov     eax,cur_match

-        mov     match_start,edx

-

-        mov     edx,window

-        mov     edi,edx

-        add     edi,best_len

-        mov     esi,prev

-        dec     edi

-; windowlen = window + best_len -1

-        mov     windowlen,edi

-

-        jmp     beginloop2

-        align   4

-

-; here, in the loop

-;       eax = ax = cur_match

-;       ecx = limit

-;        bx = scan_end

-;        bp = scan_start

-;       edi = windowlen (window + best_len -1)

-;       esi = prev

-

-

-;// here; chain_length <=16

-normalbeg0add16:

-        add     chain_length,16

-        jz      exitloop

-normalbeg0:

-        cmp     word ptr[edi+eax],bx

-        je      normalbeg2noroll

-rcontlabnoroll:

-; cur_match = prev[cur_match & wmask]

-        and     eax,7fffh

-        mov     ax,word ptr[esi+eax*2]

-; if cur_match > limit, go to exitloop

-        cmp     ecx,eax

-        jnb     exitloop

-; if --chain_length != 0, go to exitloop

-        dec     chain_length

-        jnz     normalbeg0

-        jmp     exitloop

-

-normalbeg2noroll:

-; if (scan_start==*(cur_match+window)) goto normalbeg2

-        cmp     bp,word ptr[edx+eax]

-        jne     rcontlabnoroll

-        jmp     normalbeg2

-

-contloop3:

-        mov     edi,windowlen

-

-; cur_match = prev[cur_match & wmask]

-        and     eax,7fffh

-        mov     ax,word ptr[esi+eax*2]

-; if cur_match > limit, go to exitloop

-        cmp     ecx,eax

-jnbexitloopshort1:

-        jnb     exitloop

-; if --chain_length != 0, go to exitloop

-

-

-; begin the main loop

-beginloop2:

-        sub     chain_length,16+1

-; if chain_length <=16, don't use the unrolled loop

-        jna     normalbeg0add16

-

-do16:

-        cmp     word ptr[edi+eax],bx

-        je      normalbeg2dc0

-

-maccn   MACRO   lab

-        and     eax,7fffh

-        mov     ax,word ptr[esi+eax*2]

-        cmp     ecx,eax

-        jnb     exitloop

-        cmp     word ptr[edi+eax],bx

-        je      lab

-        ENDM

-

-rcontloop0:

-        maccn   normalbeg2dc1

-

-rcontloop1:

-        maccn   normalbeg2dc2

-

-rcontloop2:

-        maccn   normalbeg2dc3

-

-rcontloop3:

-        maccn   normalbeg2dc4

-

-rcontloop4:

-        maccn   normalbeg2dc5

-

-rcontloop5:

-        maccn   normalbeg2dc6

-

-rcontloop6:

-        maccn   normalbeg2dc7

-

-rcontloop7:

-        maccn   normalbeg2dc8

-

-rcontloop8:

-        maccn   normalbeg2dc9

-

-rcontloop9:

-        maccn   normalbeg2dc10

-

-rcontloop10:

-        maccn   short normalbeg2dc11

-

-rcontloop11:

-        maccn   short normalbeg2dc12

-

-rcontloop12:

-        maccn   short normalbeg2dc13

-

-rcontloop13:

-        maccn   short normalbeg2dc14

-

-rcontloop14:

-        maccn   short normalbeg2dc15

-

-rcontloop15:

-        and     eax,7fffh

-        mov     ax,word ptr[esi+eax*2]

-        cmp     ecx,eax

-        jnb     exitloop

-

-        sub     chain_length,16

-        ja      do16

-        jmp     normalbeg0add16

-

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-

-normbeg MACRO   rcontlab,valsub

-; if we are here, we know that *(match+best_len-1) == scan_end

-        cmp     bp,word ptr[edx+eax]

-; if (match != scan_start) goto rcontlab

-        jne     rcontlab

-; calculate the good chain_length, and we'll compare scan and match string

-        add     chain_length,16-valsub

-        jmp     iseq

-        ENDM

-

-

-normalbeg2dc11:

-        normbeg rcontloop11,11

-

-normalbeg2dc12:

-        normbeg short rcontloop12,12

-

-normalbeg2dc13:

-        normbeg short rcontloop13,13

-

-normalbeg2dc14:

-        normbeg short rcontloop14,14

-

-normalbeg2dc15:

-        normbeg short rcontloop15,15

-

-normalbeg2dc10:

-        normbeg rcontloop10,10

-

-normalbeg2dc9:

-        normbeg rcontloop9,9

-

-normalbeg2dc8:

-        normbeg rcontloop8,8

-

-normalbeg2dc7:

-        normbeg rcontloop7,7

-

-normalbeg2dc6:

-        normbeg rcontloop6,6

-

-normalbeg2dc5:

-        normbeg rcontloop5,5

-

-normalbeg2dc4:

-        normbeg rcontloop4,4

-

-normalbeg2dc3:

-        normbeg rcontloop3,3

-

-normalbeg2dc2:

-        normbeg rcontloop2,2

-

-normalbeg2dc1:

-        normbeg rcontloop1,1

-

-normalbeg2dc0:

-        normbeg rcontloop0,0

-

-

-; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end

-

-normalbeg2:

-        mov     edi,window

-

-        cmp     bp,word ptr[edi+eax]

-        jne     contloop3                   ; if *(ushf*)match != scan_start, continue

-

-iseq:

-; if we are here, we know that *(match+best_len-1) == scan_end

-; and (match == scan_start)

-

-        mov     edi,edx

-        mov     esi,scan                    ; esi = scan

-        add     edi,eax                     ; edi = window + cur_match = match

-

-        mov     edx,[esi+3]                 ; compare manually dword at match+3

-        xor     edx,[edi+3]                 ; and scan +3

-

-        jz      begincompare                ; if equal, go to long compare

-

-; we will determine the unmatch byte and calculate len (in esi)

-        or      dl,dl

-        je      eq1rr

-        mov     esi,3

-        jmp     trfinval

-eq1rr:

-        or      dx,dx

-        je      eq1

-

-        mov     esi,4

-        jmp     trfinval

-eq1:

-        and     edx,0ffffffh

-        jz      eq11

-        mov     esi,5

-        jmp     trfinval

-eq11:

-        mov     esi,6

-        jmp     trfinval

-

-begincompare:

-        ; here we now scan and match begin same

-        add     edi,6

-        add     esi,6

-        mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes

-        repe    cmpsd                       ; loop until mismatch

-

-        je      trfin                       ; go to trfin if not unmatch

-; we determine the unmatch byte

-        sub     esi,4

-        mov     edx,[edi-4]

-        xor     edx,[esi]

-

-        or      dl,dl

-        jnz     trfin

-        inc     esi

-

-        or      dx,dx

-        jnz     trfin

-        inc     esi

-

-        and     edx,0ffffffh

-        jnz     trfin

-        inc     esi

-

-trfin:

-        sub     esi,scan          ; esi = len

-trfinval:

-; here we have finised compare, and esi contain len of equal string

-        cmp     esi,best_len        ; if len > best_len, go newbestlen

-        ja      short newbestlen

-; now we restore edx, ecx and esi, for the big loop

-        mov     esi,prev

-        mov     ecx,limit

-        mov     edx,window

-        jmp     contloop3

-

-newbestlen:

-        mov     best_len,esi        ; len become best_len

-

-        mov     match_start,eax     ; save new position as match_start

-        cmp     esi,nice_match      ; if best_len >= nice_match, exit

-        jae     exitloop

-        mov     ecx,scan

-        mov     edx,window          ; restore edx=window

-        add     ecx,esi

-        add     esi,edx

-

-        dec     esi

-        mov     windowlen,esi       ; windowlen = window + best_len-1

-        mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end

-

-; now we restore ecx and esi, for the big loop :

-        mov     esi,prev

-        mov     ecx,limit

-        jmp     contloop3

-

-exitloop:

-; exit : s->match_start=match_start

-        mov     ebx,match_start

-        mov     ebp,str_s

-        mov     ecx,best_len

-        mov     dword ptr [ebp+dep_match_start],ebx        

-        mov     eax,dword ptr [ebp+dep_lookahead]

-        cmp     ecx,eax

-        ja      minexlo

-        mov     eax,ecx

-minexlo:

-; return min(best_len,s->lookahead)

-        

-; restore stack and register ebx,esi,edi,ebp

-        add     esp,NbStackAdd

-

-        pop     ebx

-        pop     esi

-        pop     edi

-        pop     ebp

-        ret

-InfoAuthor:

-; please don't remove this string !

-; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!

-        db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah

-

-

-

-IFDEF NOUNDERLINE

-longest_match_7fff   endp

-ELSE

-_longest_match_7fff  endp

-ENDIF

-

-

-IFDEF NOUNDERLINE

-cpudetect32     proc near

-ELSE

-_cpudetect32    proc near

-ENDIF

-

-        push    ebx

-

-        pushfd                  ; push original EFLAGS

-        pop     eax             ; get original EFLAGS

-        mov     ecx, eax        ; save original EFLAGS

-        xor     eax, 40000h     ; flip AC bit in EFLAGS

-        push    eax             ; save new EFLAGS value on stack

-        popfd                   ; replace current EFLAGS value

-        pushfd                  ; get new EFLAGS

-        pop     eax             ; store new EFLAGS in EAX

-        xor     eax, ecx        ; can’t toggle AC bit, processor=80386

-        jz      end_cpu_is_386  ; jump if 80386 processor

-        push    ecx

-        popfd                   ; restore AC bit in EFLAGS first

-

-        pushfd

-        pushfd

-        pop     ecx

-                        

-        mov     eax, ecx        ; get original EFLAGS

-        xor     eax, 200000h    ; flip ID bit in EFLAGS

-        push    eax             ; save new EFLAGS value on stack

-        popfd                   ; replace current EFLAGS value

-        pushfd                  ; get new EFLAGS

-        pop             eax                 ; store new EFLAGS in EAX

-        popfd                   ; restore original EFLAGS

-        xor             eax, ecx        ; can’t toggle ID bit,

-        je              is_old_486              ; processor=old

-

-        mov     eax,1

-        db      0fh,0a2h        ;CPUID   

-

-exitcpudetect:

-        pop     ebx

-        ret

-

-end_cpu_is_386:

-        mov     eax,0300h

-        jmp     exitcpudetect

-

-is_old_486:

-        mov     eax,0400h

-        jmp     exitcpudetect

-

-IFDEF NOUNDERLINE

-cpudetect32     endp

-ELSE

-_cpudetect32    endp

-ENDIF

-

-

-

-

-MAX_MATCH       equ     258

-MIN_MATCH       equ     3

-MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)

-MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)

-

-

-;;; stack frame offsets

-

-chainlenwmask   equ  esp + 0    ; high word: current chain len

-                                        ; low word: s->wmask

-window          equ  esp + 4    ; local copy of s->window

-windowbestlen   equ  esp + 8    ; s->window + bestlen

-scanstart       equ  esp + 16   ; first two bytes of string

-scanend         equ  esp + 12   ; last two bytes of string

-scanalign       equ  esp + 20   ; dword-misalignment of string

-nicematch       equ  esp + 24   ; a good enough match size

-bestlen         equ  esp + 28   ; size of best match so far

-scan            equ  esp + 32   ; ptr to string wanting match

-

-LocalVarsSize   equ 36

-;       saved ebx       byte esp + 36

-;       saved edi       byte esp + 40

-;       saved esi       byte esp + 44

-;       saved ebp       byte esp + 48

-;       return address  byte esp + 52

-deflatestate    equ  esp + 56   ; the function arguments

-curmatch        equ  esp + 60

-

-;;; Offsets for fields in the deflate_state structure. These numbers

-;;; are calculated from the definition of deflate_state, with the

-;;; assumption that the compiler will dword-align the fields. (Thus,

-;;; changing the definition of deflate_state could easily cause this

-;;; program to crash horribly, without so much as a warning at

-;;; compile time. Sigh.)

-

-dsWSize         equ 36

-dsWMask         equ 44

-dsWindow        equ 48

-dsPrev          equ 56

-dsMatchLen      equ 88

-dsPrevMatch     equ 92

-dsStrStart      equ 100

-dsMatchStart    equ 104

-dsLookahead     equ 108

-dsPrevLen       equ 112

-dsMaxChainLen   equ 116

-dsGoodMatch     equ 132

-dsNiceMatch     equ 136

-

-

-;;; match.asm -- Pentium-Pro-optimized version of longest_match()

-;;; Written for zlib 1.1.2

-;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>

-;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html

-;;;

-;;; This is free software; you can redistribute it and/or modify it

-;;; under the terms of the GNU General Public License.

-

-;GLOBAL _longest_match, _match_init

-

-

-;SECTION        .text

-

-;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)

-

-;_longest_match:

-IFDEF NOUNDERLINE

-longest_match_686   proc near

-ELSE

-_longest_match_686  proc near

-ENDIF

-

-

-;;; Save registers that the compiler may be using, and adjust esp to

-;;; make room for our stack frame.

-

-                push    ebp

-                push    edi

-                push    esi

-                push    ebx

-                sub     esp, LocalVarsSize

-

-;;; Retrieve the function arguments. ecx will hold cur_match

-;;; throughout the entire function. edx will hold the pointer to the

-;;; deflate_state structure during the function's setup (before

-;;; entering the main loop.

-

-                mov     edx, [deflatestate]

-                mov     ecx, [curmatch]

-

-;;; uInt wmask = s->w_mask;

-;;; unsigned chain_length = s->max_chain_length;

-;;; if (s->prev_length >= s->good_match) {

-;;;     chain_length >>= 2;

-;;; }

-

-                mov     eax, [edx + dsPrevLen]

-                mov     ebx, [edx + dsGoodMatch]

-                cmp     eax, ebx

-                mov     eax, [edx + dsWMask]

-                mov     ebx, [edx + dsMaxChainLen]

-                jl      LastMatchGood

-                shr     ebx, 2

-LastMatchGood:

-

-;;; chainlen is decremented once beforehand so that the function can

-;;; use the sign flag instead of the zero flag for the exit test.

-;;; It is then shifted into the high word, to make room for the wmask

-;;; value, which it will always accompany.

-

-                dec     ebx

-                shl     ebx, 16

-                or      ebx, eax

-                mov     [chainlenwmask], ebx

-

-;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;

-

-                mov     eax, [edx + dsNiceMatch]

-                mov     ebx, [edx + dsLookahead]

-                cmp     ebx, eax

-                jl      LookaheadLess

-                mov     ebx, eax

-LookaheadLess:  mov     [nicematch], ebx

-

-;;; register Bytef *scan = s->window + s->strstart;

-

-                mov     esi, [edx + dsWindow]

-                mov     [window], esi

-                mov     ebp, [edx + dsStrStart]

-                lea     edi, [esi + ebp]

-                mov     [scan], edi

-

-;;; Determine how many bytes the scan ptr is off from being

-;;; dword-aligned.

-

-                mov     eax, edi

-                neg     eax

-                and     eax, 3

-                mov     [scanalign], eax

-

-;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?

-;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;

-

-                mov     eax, [edx + dsWSize]

-                sub     eax, MIN_LOOKAHEAD

-                sub     ebp, eax

-                jg      LimitPositive

-                xor     ebp, ebp

-LimitPositive:

-

-;;; int best_len = s->prev_length;

-

-                mov     eax, [edx + dsPrevLen]

-                mov     [bestlen], eax

-

-;;; Store the sum of s->window + best_len in esi locally, and in esi.

-

-                add     esi, eax

-                mov     [windowbestlen], esi

-

-;;; register ush scan_start = *(ushf*)scan;

-;;; register ush scan_end   = *(ushf*)(scan+best_len-1);

-;;; Posf *prev = s->prev;

-

-                movzx   ebx, word ptr [edi]

-                mov     [scanstart], ebx

-                movzx   ebx, word ptr [edi + eax - 1]

-                mov     [scanend], ebx

-                mov     edi, [edx + dsPrev]

-

-;;; Jump into the main loop.

-

-                mov     edx, [chainlenwmask]

-                jmp     short LoopEntry

-

-align 4

-

-;;; do {

-;;;     match = s->window + cur_match;

-;;;     if (*(ushf*)(match+best_len-1) != scan_end ||

-;;;         *(ushf*)match != scan_start) continue;

-;;;     [...]

-;;; } while ((cur_match = prev[cur_match & wmask]) > limit

-;;;          && --chain_length != 0);

-;;;

-;;; Here is the inner loop of the function. The function will spend the

-;;; majority of its time in this loop, and majority of that time will

-;;; be spent in the first ten instructions.

-;;;

-;;; Within this loop:

-;;; ebx = scanend

-;;; ecx = curmatch

-;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)

-;;; esi = windowbestlen - i.e., (window + bestlen)

-;;; edi = prev

-;;; ebp = limit

-

-LookupLoop:

-                and     ecx, edx

-                movzx   ecx, word ptr [edi + ecx*2]

-                cmp     ecx, ebp

-                jbe     LeaveNow

-                sub     edx, 00010000h

-                js      LeaveNow

-LoopEntry:      movzx   eax, word ptr [esi + ecx - 1]

-                cmp     eax, ebx

-                jnz     LookupLoop

-                mov     eax, [window]

-                movzx   eax, word ptr [eax + ecx]

-                cmp     eax, [scanstart]

-                jnz     LookupLoop

-

-;;; Store the current value of chainlen.

-

-                mov     [chainlenwmask], edx

-

-;;; Point edi to the string under scrutiny, and esi to the string we

-;;; are hoping to match it up with. In actuality, esi and edi are

-;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is

-;;; initialized to -(MAX_MATCH_8 - scanalign).

-

-                mov     esi, [window]

-                mov     edi, [scan]

-                add     esi, ecx

-                mov     eax, [scanalign]

-                mov     edx, 0fffffef8h; -(MAX_MATCH_8)

-                lea     edi, [edi + eax + 0108h] ;MAX_MATCH_8]

-                lea     esi, [esi + eax + 0108h] ;MAX_MATCH_8]

-

-;;; Test the strings for equality, 8 bytes at a time. At the end,

-;;; adjust edx so that it is offset to the exact byte that mismatched.

-;;;

-;;; We already know at this point that the first three bytes of the

-;;; strings match each other, and they can be safely passed over before

-;;; starting the compare loop. So what this code does is skip over 0-3

-;;; bytes, as much as necessary in order to dword-align the edi

-;;; pointer. (esi will still be misaligned three times out of four.)

-;;;

-;;; It should be confessed that this loop usually does not represent

-;;; much of the total running time. Replacing it with a more

-;;; straightforward "rep cmpsb" would not drastically degrade

-;;; performance.

-

-LoopCmps:

-                mov     eax, [esi + edx]

-                xor     eax, [edi + edx]

-                jnz     LeaveLoopCmps

-                mov     eax, [esi + edx + 4]

-                xor     eax, [edi + edx + 4]

-                jnz     LeaveLoopCmps4

-                add     edx, 8

-                jnz     LoopCmps

-                jmp     short LenMaximum

-LeaveLoopCmps4: add     edx, 4

-LeaveLoopCmps:  test    eax, 0000FFFFh

-                jnz     LenLower

-                add     edx,  2

-                shr     eax, 16

-LenLower:       sub     al, 1

-                adc     edx, 0

-

-;;; Calculate the length of the match. If it is longer than MAX_MATCH,

-;;; then automatically accept it as the best possible match and leave.

-

-                lea     eax, [edi + edx]

-                mov     edi, [scan]

-                sub     eax, edi

-                cmp     eax, MAX_MATCH

-                jge     LenMaximum

-

-;;; If the length of the match is not longer than the best match we

-;;; have so far, then forget it and return to the lookup loop.

-

-                mov     edx, [deflatestate]

-                mov     ebx, [bestlen]

-                cmp     eax, ebx

-                jg      LongerMatch

-                mov     esi, [windowbestlen]

-                mov     edi, [edx + dsPrev]

-                mov     ebx, [scanend]

-                mov     edx, [chainlenwmask]

-                jmp     LookupLoop

-

-;;;         s->match_start = cur_match;

-;;;         best_len = len;

-;;;         if (len >= nice_match) break;

-;;;         scan_end = *(ushf*)(scan+best_len-1);

-

-LongerMatch:    mov     ebx, [nicematch]

-                mov     [bestlen], eax

-                mov     [edx + dsMatchStart], ecx

-                cmp     eax, ebx

-                jge     LeaveNow

-                mov     esi, [window]

-                add     esi, eax

-                mov     [windowbestlen], esi

-                movzx   ebx, word ptr [edi + eax - 1]

-                mov     edi, [edx + dsPrev]

-                mov     [scanend], ebx

-                mov     edx, [chainlenwmask]

-                jmp     LookupLoop

-

-;;; Accept the current string, with the maximum possible length.

-

-LenMaximum:     mov     edx, [deflatestate]

-                mov     dword ptr [bestlen], MAX_MATCH

-                mov     [edx + dsMatchStart], ecx

-

-;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;

-;;; return s->lookahead;

-

-LeaveNow:

-                mov     edx, [deflatestate]

-                mov     ebx, [bestlen]

-                mov     eax, [edx + dsLookahead]

-                cmp     ebx, eax

-                jg      LookaheadRet

-                mov     eax, ebx

-LookaheadRet:

-

-;;; Restore the stack and return from whence we came.

-

-                add     esp, LocalVarsSize

-                pop     ebx

-                pop     esi

-                pop     edi

-                pop     ebp

-

-                ret

-; please don't remove this string !

-; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!

-        db     0dh,0ah,"asm686 with masm, code optimised assembly code from Brian Raiter, written 1998",0dh,0ah

-

-IFDEF NOUNDERLINE

-longest_match_686   endp

-ELSE

-_longest_match_686  endp

-ENDIF

-

-_TEXT   ends

-end

+;
+; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
+; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
+; File written by Gilles Vollant, by modifiying the longest_match
+;  from Jean-loup Gailly in deflate.c
+; It need wmask == 0x7fff
+;     (assembly code is faster with a fixed wmask)
+;
+; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
+;   I compile with : "ml /coff /Zi /c gvmat32.asm"
+;
+
+;uInt longest_match_7fff(s, cur_match)
+;    deflate_state *s;
+;    IPos cur_match;                             /* current match */
+
+        NbStack         equ     76
+        cur_match       equ     dword ptr[esp+NbStack-0]
+        str_s           equ     dword ptr[esp+NbStack-4]
+; 5 dword on top (ret,ebp,esi,edi,ebx)
+        adrret          equ     dword ptr[esp+NbStack-8]
+        pushebp         equ     dword ptr[esp+NbStack-12]
+        pushedi         equ     dword ptr[esp+NbStack-16]
+        pushesi         equ     dword ptr[esp+NbStack-20]
+        pushebx         equ     dword ptr[esp+NbStack-24]
+
+        chain_length    equ     dword ptr [esp+NbStack-28]
+        limit           equ     dword ptr [esp+NbStack-32]
+        best_len        equ     dword ptr [esp+NbStack-36]
+        window          equ     dword ptr [esp+NbStack-40]
+        prev            equ     dword ptr [esp+NbStack-44]
+        scan_start      equ      word ptr [esp+NbStack-48]
+        wmask           equ     dword ptr [esp+NbStack-52]
+        match_start_ptr equ     dword ptr [esp+NbStack-56]
+        nice_match      equ     dword ptr [esp+NbStack-60]
+        scan            equ     dword ptr [esp+NbStack-64]
+
+        windowlen       equ     dword ptr [esp+NbStack-68]
+        match_start     equ     dword ptr [esp+NbStack-72]
+        strend          equ     dword ptr [esp+NbStack-76]
+        NbStackAdd      equ     (NbStack-24)
+
+    .386p
+
+    name    gvmatch
+    .MODEL  FLAT
+
+
+
+;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
+;  in the deflate_state structure since the asm code was first written
+;  (if you compile with zlib 1.0.4 or older, remove the +4).
+;  Note : these value are good with a 8 bytes boundary pack structure
+    dep_chain_length    equ     70h+4
+    dep_window          equ     2ch+4
+    dep_strstart        equ     60h+4
+    dep_prev_length     equ     6ch+4
+    dep_nice_match      equ     84h+4
+    dep_w_size          equ     20h+4
+    dep_prev            equ     34h+4
+    dep_w_mask          equ     28h+4
+    dep_good_match      equ     80h+4
+    dep_match_start     equ     64h+4
+    dep_lookahead       equ     68h+4
+
+
+_TEXT                   segment
+
+IFDEF NOUNDERLINE
+                        public  longest_match_7fff
+                        public  longest_match_686
+;                        public  match_init
+ELSE
+                        public  _longest_match_7fff
+                        public  _longest_match_686
+;                        public  _match_init
+ENDIF
+
+    MAX_MATCH           equ     258
+    MIN_MATCH           equ     3
+    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
+
+
+
+IFDEF NOUNDERLINE
+;match_init      proc near
+;                ret
+;match_init      endp
+ELSE
+;_match_init     proc near
+;                ret
+;_match_init     endp
+ENDIF
+
+
+IFDEF NOUNDERLINE
+longest_match_7fff   proc near
+ELSE
+_longest_match_7fff  proc near
+ENDIF
+
+        mov     edx,[esp+4]
+
+
+
+        push    ebp
+        push    edi
+        push    esi
+        push    ebx
+
+        sub     esp,NbStackAdd
+
+; initialize or check the variables used in match.asm.
+        mov     ebp,edx
+
+; chain_length = s->max_chain_length
+; if (prev_length>=good_match) chain_length >>= 2
+        mov     edx,[ebp+dep_chain_length]
+        mov     ebx,[ebp+dep_prev_length]
+        cmp     [ebp+dep_good_match],ebx
+        ja      noshr
+        shr     edx,2
+noshr:
+; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
+        inc     edx
+        mov     edi,[ebp+dep_nice_match]
+        mov     chain_length,edx
+        mov     eax,[ebp+dep_lookahead]
+        cmp     eax,edi
+; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+        jae     nolookaheadnicematch
+        mov     edi,eax
+nolookaheadnicematch:
+; best_len = s->prev_length
+        mov     best_len,ebx
+
+; window = s->window
+        mov     esi,[ebp+dep_window]
+        mov     ecx,[ebp+dep_strstart]
+        mov     window,esi
+
+        mov     nice_match,edi
+; scan = window + strstart
+        add     esi,ecx
+        mov     scan,esi
+; dx = *window
+        mov     dx,word ptr [esi]
+; bx = *(window+best_len-1)
+        mov     bx,word ptr [esi+ebx-1]
+        add     esi,MAX_MATCH-1
+; scan_start = *scan
+        mov     scan_start,dx
+; strend = scan + MAX_MATCH-1
+        mov     strend,esi
+; bx = scan_end = *(window+best_len-1)
+
+;    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+;        s->strstart - (IPos)MAX_DIST(s) : NIL;
+
+        mov     esi,[ebp+dep_w_size]
+        sub     esi,MIN_LOOKAHEAD
+; here esi = MAX_DIST(s)
+        sub     ecx,esi
+        ja      nodist
+        xor     ecx,ecx
+nodist:
+        mov     limit,ecx
+
+; prev = s->prev
+        mov     edx,[ebp+dep_prev]
+        mov     prev,edx
+
+;
+        mov     edx,dword ptr [ebp+dep_match_start]
+        mov     bp,scan_start
+        mov     eax,cur_match
+        mov     match_start,edx
+
+        mov     edx,window
+        mov     edi,edx
+        add     edi,best_len
+        mov     esi,prev
+        dec     edi
+; windowlen = window + best_len -1
+        mov     windowlen,edi
+
+        jmp     beginloop2
+        align   4
+
+; here, in the loop
+;       eax = ax = cur_match
+;       ecx = limit
+;        bx = scan_end
+;        bp = scan_start
+;       edi = windowlen (window + best_len -1)
+;       esi = prev
+
+
+;// here; chain_length <=16
+normalbeg0add16:
+        add     chain_length,16
+        jz      exitloop
+normalbeg0:
+        cmp     word ptr[edi+eax],bx
+        je      normalbeg2noroll
+rcontlabnoroll:
+; cur_match = prev[cur_match & wmask]
+        and     eax,7fffh
+        mov     ax,word ptr[esi+eax*2]
+; if cur_match > limit, go to exitloop
+        cmp     ecx,eax
+        jnb     exitloop
+; if --chain_length != 0, go to exitloop
+        dec     chain_length
+        jnz     normalbeg0
+        jmp     exitloop
+
+normalbeg2noroll:
+; if (scan_start==*(cur_match+window)) goto normalbeg2
+        cmp     bp,word ptr[edx+eax]
+        jne     rcontlabnoroll
+        jmp     normalbeg2
+
+contloop3:
+        mov     edi,windowlen
+
+; cur_match = prev[cur_match & wmask]
+        and     eax,7fffh
+        mov     ax,word ptr[esi+eax*2]
+; if cur_match > limit, go to exitloop
+        cmp     ecx,eax
+jnbexitloopshort1:
+        jnb     exitloop
+; if --chain_length != 0, go to exitloop
+
+
+; begin the main loop
+beginloop2:
+        sub     chain_length,16+1
+; if chain_length <=16, don't use the unrolled loop
+        jna     normalbeg0add16
+
+do16:
+        cmp     word ptr[edi+eax],bx
+        je      normalbeg2dc0
+
+maccn   MACRO   lab
+        and     eax,7fffh
+        mov     ax,word ptr[esi+eax*2]
+        cmp     ecx,eax
+        jnb     exitloop
+        cmp     word ptr[edi+eax],bx
+        je      lab
+        ENDM
+
+rcontloop0:
+        maccn   normalbeg2dc1
+
+rcontloop1:
+        maccn   normalbeg2dc2
+
+rcontloop2:
+        maccn   normalbeg2dc3
+
+rcontloop3:
+        maccn   normalbeg2dc4
+
+rcontloop4:
+        maccn   normalbeg2dc5
+
+rcontloop5:
+        maccn   normalbeg2dc6
+
+rcontloop6:
+        maccn   normalbeg2dc7
+
+rcontloop7:
+        maccn   normalbeg2dc8
+
+rcontloop8:
+        maccn   normalbeg2dc9
+
+rcontloop9:
+        maccn   normalbeg2dc10
+
+rcontloop10:
+        maccn   short normalbeg2dc11
+
+rcontloop11:
+        maccn   short normalbeg2dc12
+
+rcontloop12:
+        maccn   short normalbeg2dc13
+
+rcontloop13:
+        maccn   short normalbeg2dc14
+
+rcontloop14:
+        maccn   short normalbeg2dc15
+
+rcontloop15:
+        and     eax,7fffh
+        mov     ax,word ptr[esi+eax*2]
+        cmp     ecx,eax
+        jnb     exitloop
+
+        sub     chain_length,16
+        ja      do16
+        jmp     normalbeg0add16
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+normbeg MACRO   rcontlab,valsub
+; if we are here, we know that *(match+best_len-1) == scan_end
+        cmp     bp,word ptr[edx+eax]
+; if (match != scan_start) goto rcontlab
+        jne     rcontlab
+; calculate the good chain_length, and we'll compare scan and match string
+        add     chain_length,16-valsub
+        jmp     iseq
+        ENDM
+
+
+normalbeg2dc11:
+        normbeg rcontloop11,11
+
+normalbeg2dc12:
+        normbeg short rcontloop12,12
+
+normalbeg2dc13:
+        normbeg short rcontloop13,13
+
+normalbeg2dc14:
+        normbeg short rcontloop14,14
+
+normalbeg2dc15:
+        normbeg short rcontloop15,15
+
+normalbeg2dc10:
+        normbeg rcontloop10,10
+
+normalbeg2dc9:
+        normbeg rcontloop9,9
+
+normalbeg2dc8:
+        normbeg rcontloop8,8
+
+normalbeg2dc7:
+        normbeg rcontloop7,7
+
+normalbeg2dc6:
+        normbeg rcontloop6,6
+
+normalbeg2dc5:
+        normbeg rcontloop5,5
+
+normalbeg2dc4:
+        normbeg rcontloop4,4
+
+normalbeg2dc3:
+        normbeg rcontloop3,3
+
+normalbeg2dc2:
+        normbeg rcontloop2,2
+
+normalbeg2dc1:
+        normbeg rcontloop1,1
+
+normalbeg2dc0:
+        normbeg rcontloop0,0
+
+
+; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
+
+normalbeg2:
+        mov     edi,window
+
+        cmp     bp,word ptr[edi+eax]
+        jne     contloop3                   ; if *(ushf*)match != scan_start, continue
+
+iseq:
+; if we are here, we know that *(match+best_len-1) == scan_end
+; and (match == scan_start)
+
+        mov     edi,edx
+        mov     esi,scan                    ; esi = scan
+        add     edi,eax                     ; edi = window + cur_match = match
+
+        mov     edx,[esi+3]                 ; compare manually dword at match+3
+        xor     edx,[edi+3]                 ; and scan +3
+
+        jz      begincompare                ; if equal, go to long compare
+
+; we will determine the unmatch byte and calculate len (in esi)
+        or      dl,dl
+        je      eq1rr
+        mov     esi,3
+        jmp     trfinval
+eq1rr:
+        or      dx,dx
+        je      eq1
+
+        mov     esi,4
+        jmp     trfinval
+eq1:
+        and     edx,0ffffffh
+        jz      eq11
+        mov     esi,5
+        jmp     trfinval
+eq11:
+        mov     esi,6
+        jmp     trfinval
+
+begincompare:
+        ; here we now scan and match begin same
+        add     edi,6
+        add     esi,6
+        mov     ecx,(MAX_MATCH-(2+4))/4     ; scan for at most MAX_MATCH bytes
+        repe    cmpsd                       ; loop until mismatch
+
+        je      trfin                       ; go to trfin if not unmatch
+; we determine the unmatch byte
+        sub     esi,4
+        mov     edx,[edi-4]
+        xor     edx,[esi]
+
+        or      dl,dl
+        jnz     trfin
+        inc     esi
+
+        or      dx,dx
+        jnz     trfin
+        inc     esi
+
+        and     edx,0ffffffh
+        jnz     trfin
+        inc     esi
+
+trfin:
+        sub     esi,scan          ; esi = len
+trfinval:
+; here we have finised compare, and esi contain len of equal string
+        cmp     esi,best_len        ; if len > best_len, go newbestlen
+        ja      short newbestlen
+; now we restore edx, ecx and esi, for the big loop
+        mov     esi,prev
+        mov     ecx,limit
+        mov     edx,window
+        jmp     contloop3
+
+newbestlen:
+        mov     best_len,esi        ; len become best_len
+
+        mov     match_start,eax     ; save new position as match_start
+        cmp     esi,nice_match      ; if best_len >= nice_match, exit
+        jae     exitloop
+        mov     ecx,scan
+        mov     edx,window          ; restore edx=window
+        add     ecx,esi
+        add     esi,edx
+
+        dec     esi
+        mov     windowlen,esi       ; windowlen = window + best_len-1
+        mov     bx,[ecx-1]          ; bx = *(scan+best_len-1) = scan_end
+
+; now we restore ecx and esi, for the big loop :
+        mov     esi,prev
+        mov     ecx,limit
+        jmp     contloop3
+
+exitloop:
+; exit : s->match_start=match_start
+        mov     ebx,match_start
+        mov     ebp,str_s
+        mov     ecx,best_len
+        mov     dword ptr [ebp+dep_match_start],ebx
+        mov     eax,dword ptr [ebp+dep_lookahead]
+        cmp     ecx,eax
+        ja      minexlo
+        mov     eax,ecx
+minexlo:
+; return min(best_len,s->lookahead)
+
+; restore stack and register ebx,esi,edi,ebp
+        add     esp,NbStackAdd
+
+        pop     ebx
+        pop     esi
+        pop     edi
+        pop     ebp
+        ret
+InfoAuthor:
+; please don't remove this string !
+; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
+        db     0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
+
+
+
+IFDEF NOUNDERLINE
+longest_match_7fff   endp
+ELSE
+_longest_match_7fff  endp
+ENDIF
+
+
+IFDEF NOUNDERLINE
+cpudetect32     proc near
+ELSE
+_cpudetect32    proc near
+ENDIF
+
+        push    ebx
+
+        pushfd                  ; push original EFLAGS
+        pop     eax             ; get original EFLAGS
+        mov     ecx, eax        ; save original EFLAGS
+        xor     eax, 40000h     ; flip AC bit in EFLAGS
+        push    eax             ; save new EFLAGS value on stack
+        popfd                   ; replace current EFLAGS value
+        pushfd                  ; get new EFLAGS
+        pop     eax             ; store new EFLAGS in EAX
+        xor     eax, ecx        ; can’t toggle AC bit, processor=80386
+        jz      end_cpu_is_386  ; jump if 80386 processor
+        push    ecx
+        popfd                   ; restore AC bit in EFLAGS first
+
+        pushfd
+        pushfd
+        pop     ecx
+
+        mov     eax, ecx        ; get original EFLAGS
+        xor     eax, 200000h    ; flip ID bit in EFLAGS
+        push    eax             ; save new EFLAGS value on stack
+        popfd                   ; replace current EFLAGS value
+        pushfd                  ; get new EFLAGS
+        pop             eax                 ; store new EFLAGS in EAX
+        popfd                   ; restore original EFLAGS
+        xor             eax, ecx        ; can’t toggle ID bit,
+        je              is_old_486              ; processor=old
+
+        mov     eax,1
+        db      0fh,0a2h        ;CPUID
+
+exitcpudetect:
+        pop     ebx
+        ret
+
+end_cpu_is_386:
+        mov     eax,0300h
+        jmp     exitcpudetect
+
+is_old_486:
+        mov     eax,0400h
+        jmp     exitcpudetect
+
+IFDEF NOUNDERLINE
+cpudetect32     endp
+ELSE
+_cpudetect32    endp
+ENDIF
+
+
+
+
+MAX_MATCH       equ     258
+MIN_MATCH       equ     3
+MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)
+MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)
+
+
+;;; stack frame offsets
+
+chainlenwmask   equ  esp + 0    ; high word: current chain len
+                                        ; low word: s->wmask
+window          equ  esp + 4    ; local copy of s->window
+windowbestlen   equ  esp + 8    ; s->window + bestlen
+scanstart       equ  esp + 16   ; first two bytes of string
+scanend         equ  esp + 12   ; last two bytes of string
+scanalign       equ  esp + 20   ; dword-misalignment of string
+nicematch       equ  esp + 24   ; a good enough match size
+bestlen         equ  esp + 28   ; size of best match so far
+scan            equ  esp + 32   ; ptr to string wanting match
+
+LocalVarsSize   equ 36
+;       saved ebx       byte esp + 36
+;       saved edi       byte esp + 40
+;       saved esi       byte esp + 44
+;       saved ebp       byte esp + 48
+;       return address  byte esp + 52
+deflatestate    equ  esp + 56   ; the function arguments
+curmatch        equ  esp + 60
+
+;;; Offsets for fields in the deflate_state structure. These numbers
+;;; are calculated from the definition of deflate_state, with the
+;;; assumption that the compiler will dword-align the fields. (Thus,
+;;; changing the definition of deflate_state could easily cause this
+;;; program to crash horribly, without so much as a warning at
+;;; compile time. Sigh.)
+
+dsWSize         equ 36
+dsWMask         equ 44
+dsWindow        equ 48
+dsPrev          equ 56
+dsMatchLen      equ 88
+dsPrevMatch     equ 92
+dsStrStart      equ 100
+dsMatchStart    equ 104
+dsLookahead     equ 108
+dsPrevLen       equ 112
+dsMaxChainLen   equ 116
+dsGoodMatch     equ 132
+dsNiceMatch     equ 136
+
+
+;;; match.asm -- Pentium-Pro-optimized version of longest_match()
+;;; Written for zlib 1.1.2
+;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
+;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
+;;;
+;;; This is free software; you can redistribute it and/or modify it
+;;; under the terms of the GNU General Public License.
+
+;GLOBAL _longest_match, _match_init
+
+
+;SECTION        .text
+
+;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
+
+;_longest_match:
+IFDEF NOUNDERLINE
+longest_match_686   proc near
+ELSE
+_longest_match_686  proc near
+ENDIF
+
+
+;;; Save registers that the compiler may be using, and adjust esp to
+;;; make room for our stack frame.
+
+                push    ebp
+                push    edi
+                push    esi
+                push    ebx
+                sub     esp, LocalVarsSize
+
+;;; Retrieve the function arguments. ecx will hold cur_match
+;;; throughout the entire function. edx will hold the pointer to the
+;;; deflate_state structure during the function's setup (before
+;;; entering the main loop.
+
+                mov     edx, [deflatestate]
+                mov     ecx, [curmatch]
+
+;;; uInt wmask = s->w_mask;
+;;; unsigned chain_length = s->max_chain_length;
+;;; if (s->prev_length >= s->good_match) {
+;;;     chain_length >>= 2;
+;;; }
+
+                mov     eax, [edx + dsPrevLen]
+                mov     ebx, [edx + dsGoodMatch]
+                cmp     eax, ebx
+                mov     eax, [edx + dsWMask]
+                mov     ebx, [edx + dsMaxChainLen]
+                jl      LastMatchGood
+                shr     ebx, 2
+LastMatchGood:
+
+;;; chainlen is decremented once beforehand so that the function can
+;;; use the sign flag instead of the zero flag for the exit test.
+;;; It is then shifted into the high word, to make room for the wmask
+;;; value, which it will always accompany.
+
+                dec     ebx
+                shl     ebx, 16
+                or      ebx, eax
+                mov     [chainlenwmask], ebx
+
+;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+
+                mov     eax, [edx + dsNiceMatch]
+                mov     ebx, [edx + dsLookahead]
+                cmp     ebx, eax
+                jl      LookaheadLess
+                mov     ebx, eax
+LookaheadLess:  mov     [nicematch], ebx
+
+;;; register Bytef *scan = s->window + s->strstart;
+
+                mov     esi, [edx + dsWindow]
+                mov     [window], esi
+                mov     ebp, [edx + dsStrStart]
+                lea     edi, [esi + ebp]
+                mov     [scan], edi
+
+;;; Determine how many bytes the scan ptr is off from being
+;;; dword-aligned.
+
+                mov     eax, edi
+                neg     eax
+                and     eax, 3
+                mov     [scanalign], eax
+
+;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
+
+                mov     eax, [edx + dsWSize]
+                sub     eax, MIN_LOOKAHEAD
+                sub     ebp, eax
+                jg      LimitPositive
+                xor     ebp, ebp
+LimitPositive:
+
+;;; int best_len = s->prev_length;
+
+                mov     eax, [edx + dsPrevLen]
+                mov     [bestlen], eax
+
+;;; Store the sum of s->window + best_len in esi locally, and in esi.
+
+                add     esi, eax
+                mov     [windowbestlen], esi
+
+;;; register ush scan_start = *(ushf*)scan;
+;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
+;;; Posf *prev = s->prev;
+
+                movzx   ebx, word ptr [edi]
+                mov     [scanstart], ebx
+                movzx   ebx, word ptr [edi + eax - 1]
+                mov     [scanend], ebx
+                mov     edi, [edx + dsPrev]
+
+;;; Jump into the main loop.
+
+                mov     edx, [chainlenwmask]
+                jmp     short LoopEntry
+
+align 4
+
+;;; do {
+;;;     match = s->window + cur_match;
+;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
+;;;         *(ushf*)match != scan_start) continue;
+;;;     [...]
+;;; } while ((cur_match = prev[cur_match & wmask]) > limit
+;;;          && --chain_length != 0);
+;;;
+;;; Here is the inner loop of the function. The function will spend the
+;;; majority of its time in this loop, and majority of that time will
+;;; be spent in the first ten instructions.
+;;;
+;;; Within this loop:
+;;; ebx = scanend
+;;; ecx = curmatch
+;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+;;; esi = windowbestlen - i.e., (window + bestlen)
+;;; edi = prev
+;;; ebp = limit
+
+LookupLoop:
+                and     ecx, edx
+                movzx   ecx, word ptr [edi + ecx*2]
+                cmp     ecx, ebp
+                jbe     LeaveNow
+                sub     edx, 00010000h
+                js      LeaveNow
+LoopEntry:      movzx   eax, word ptr [esi + ecx - 1]
+                cmp     eax, ebx
+                jnz     LookupLoop
+                mov     eax, [window]
+                movzx   eax, word ptr [eax + ecx]
+                cmp     eax, [scanstart]
+                jnz     LookupLoop
+
+;;; Store the current value of chainlen.
+
+                mov     [chainlenwmask], edx
+
+;;; Point edi to the string under scrutiny, and esi to the string we
+;;; are hoping to match it up with. In actuality, esi and edi are
+;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
+;;; initialized to -(MAX_MATCH_8 - scanalign).
+
+                mov     esi, [window]
+                mov     edi, [scan]
+                add     esi, ecx
+                mov     eax, [scanalign]
+                mov     edx, 0fffffef8h; -(MAX_MATCH_8)
+                lea     edi, [edi + eax + 0108h] ;MAX_MATCH_8]
+                lea     esi, [esi + eax + 0108h] ;MAX_MATCH_8]
+
+;;; Test the strings for equality, 8 bytes at a time. At the end,
+;;; adjust edx so that it is offset to the exact byte that mismatched.
+;;;
+;;; We already know at this point that the first three bytes of the
+;;; strings match each other, and they can be safely passed over before
+;;; starting the compare loop. So what this code does is skip over 0-3
+;;; bytes, as much as necessary in order to dword-align the edi
+;;; pointer. (esi will still be misaligned three times out of four.)
+;;;
+;;; It should be confessed that this loop usually does not represent
+;;; much of the total running time. Replacing it with a more
+;;; straightforward "rep cmpsb" would not drastically degrade
+;;; performance.
+
+LoopCmps:
+                mov     eax, [esi + edx]
+                xor     eax, [edi + edx]
+                jnz     LeaveLoopCmps
+                mov     eax, [esi + edx + 4]
+                xor     eax, [edi + edx + 4]
+                jnz     LeaveLoopCmps4
+                add     edx, 8
+                jnz     LoopCmps
+                jmp     short LenMaximum
+LeaveLoopCmps4: add     edx, 4
+LeaveLoopCmps:  test    eax, 0000FFFFh
+                jnz     LenLower
+                add     edx,  2
+                shr     eax, 16
+LenLower:       sub     al, 1
+                adc     edx, 0
+
+;;; Calculate the length of the match. If it is longer than MAX_MATCH,
+;;; then automatically accept it as the best possible match and leave.
+
+                lea     eax, [edi + edx]
+                mov     edi, [scan]
+                sub     eax, edi
+                cmp     eax, MAX_MATCH
+                jge     LenMaximum
+
+;;; If the length of the match is not longer than the best match we
+;;; have so far, then forget it and return to the lookup loop.
+
+                mov     edx, [deflatestate]
+                mov     ebx, [bestlen]
+                cmp     eax, ebx
+                jg      LongerMatch
+                mov     esi, [windowbestlen]
+                mov     edi, [edx + dsPrev]
+                mov     ebx, [scanend]
+                mov     edx, [chainlenwmask]
+                jmp     LookupLoop
+
+;;;         s->match_start = cur_match;
+;;;         best_len = len;
+;;;         if (len >= nice_match) break;
+;;;         scan_end = *(ushf*)(scan+best_len-1);
+
+LongerMatch:    mov     ebx, [nicematch]
+                mov     [bestlen], eax
+                mov     [edx + dsMatchStart], ecx
+                cmp     eax, ebx
+                jge     LeaveNow
+                mov     esi, [window]
+                add     esi, eax
+                mov     [windowbestlen], esi
+                movzx   ebx, word ptr [edi + eax - 1]
+                mov     edi, [edx + dsPrev]
+                mov     [scanend], ebx
+                mov     edx, [chainlenwmask]
+                jmp     LookupLoop
+
+;;; Accept the current string, with the maximum possible length.
+
+LenMaximum:     mov     edx, [deflatestate]
+                mov     dword ptr [bestlen], MAX_MATCH
+                mov     [edx + dsMatchStart], ecx
+
+;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+;;; return s->lookahead;
+
+LeaveNow:
+                mov     edx, [deflatestate]
+                mov     ebx, [bestlen]
+                mov     eax, [edx + dsLookahead]
+                cmp     ebx, eax
+                jg      LookaheadRet
+                mov     eax, ebx
+LookaheadRet:
+
+;;; Restore the stack and return from whence we came.
+
+                add     esp, LocalVarsSize
+                pop     ebx
+                pop     esi
+                pop     edi
+                pop     ebp
+
+                ret
+; please don't remove this string !
+; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
+        db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
+
+IFDEF NOUNDERLINE
+longest_match_686   endp
+ELSE
+_longest_match_686  endp
+ENDIF
+
+_TEXT   ends
+end
diff --git a/contrib/vstudio/vc70_32/gvmat32c.c b/contrib/masmx86/gvmat32c.c
index 38be10b..9ed25f3 100644
--- a/contrib/vstudio/vc70_32/gvmat32c.c
+++ b/contrib/masmx86/gvmat32c.c
@@ -1,209 +1,206 @@
-/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86

- * Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.

- * File written by Gilles Vollant, by modifiying the longest_match

- *  from Jean-loup Gailly in deflate.c

- *  it prepare all parameters and call the assembly longest_match_gvasm

- *  longest_match execute standard C code is wmask != 0x7fff

- *     (assembly code is faster with a fixed wmask)

- *

- */

-

-#include "deflate.h"

-

-#undef FAR

-//#include <windows.h>

-

-#ifdef ASMV

-#define NIL 0

-

-#define UNALIGNED_OK

-

-

-/* if your C compiler don't add underline before function name,

-        define ADD_UNDERLINE_ASMFUNC */

-#ifdef ADD_UNDERLINE_ASMFUNC

-#define longest_match_7fff _longest_match_7fff

-#define longest_match_686  _longest_match_686

-#define cpudetect32        _cpudetect32

-#endif

-

-

-

-void match_init()

-{

-}

-

-unsigned long cpudetect32();

-

-uInt longest_match_c(

-    deflate_state *s,

-    IPos cur_match);                             /* current match */

-

-

-uInt longest_match_7fff(

-    deflate_state *s,

-    IPos cur_match);                             /* current match */

-

-uInt longest_match_686(

-    deflate_state *s,

-    IPos cur_match);                             /* current match */

-

-uInt longest_match(

-    deflate_state *s,

-    IPos cur_match)                             /* current match */

-{

-    static uInt iIsPPro=2;

-

-    if ((s->w_mask == 0x7fff) && (iIsPPro==0))

-        return longest_match_7fff(s,cur_match);

-

-    if (iIsPPro==1)

-        return longest_match_686(s,cur_match);

-

-    if (iIsPPro==2)

-        iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;

-

-    return longest_match_c(s,cur_match);

-}

-

-

-

-uInt longest_match_c(s, cur_match)

-    deflate_state *s;

-    IPos cur_match;                             /* current match */

-{

-    unsigned chain_length = s->max_chain_length;/* max hash 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 (uInt)best_len;

-    return s->lookahead;

-}

-

-#endif /* ASMV */

+/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
+ * Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
+ * File written by Gilles Vollant, by modifiying the longest_match
+ *  from Jean-loup Gailly in deflate.c
+ *  it prepare all parameters and call the assembly longest_match_gvasm
+ *  longest_match execute standard C code is wmask != 0x7fff
+ *     (assembly code is faster with a fixed wmask)
+ *
+ */
+
+#include "deflate.h"
+
+#ifdef ASMV
+#define NIL 0
+
+#define UNALIGNED_OK
+
+
+/* if your C compiler don't add underline before function name,
+        define ADD_UNDERLINE_ASMFUNC */
+#ifdef ADD_UNDERLINE_ASMFUNC
+#define longest_match_7fff _longest_match_7fff
+#define longest_match_686  _longest_match_686
+#define cpudetect32        _cpudetect32
+#endif
+
+
+
+void match_init()
+{
+}
+
+unsigned long cpudetect32();
+
+uInt longest_match_c(
+    deflate_state *s,
+    IPos cur_match);                             /* current match */
+
+
+uInt longest_match_7fff(
+    deflate_state *s,
+    IPos cur_match);                             /* current match */
+
+uInt longest_match_686(
+    deflate_state *s,
+    IPos cur_match);                             /* current match */
+
+uInt longest_match(
+    deflate_state *s,
+    IPos cur_match)                             /* current match */
+{
+    static uInt iIsPPro=2;
+
+    if ((s->w_mask == 0x7fff) && (iIsPPro==0))
+        return longest_match_7fff(s,cur_match);
+
+    if (iIsPPro==1)
+        return longest_match_686(s,cur_match);
+
+    if (iIsPPro==2)
+        iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
+
+    return longest_match_c(s,cur_match);
+}
+
+
+
+uInt longest_match_c(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    unsigned chain_length = s->max_chain_length;/* max hash 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 (uInt)best_len;
+    return s->lookahead;
+}
+
+#endif /* ASMV */
diff --git a/contrib/vstudio/vc70_32/gvmat32.obj b/contrib/vstudio/vc7/gvmat32.obj
index 5b2f856..5b2f856 100644
--- a/contrib/vstudio/vc70_32/gvmat32.obj
+++ b/contrib/vstudio/vc7/gvmat32.obj
diff --git a/contrib/vstudio/vc7/inffas32.obj b/contrib/vstudio/vc7/inffas32.obj
new file mode 100644
index 0000000..a541a5a
--- /dev/null
+++ b/contrib/vstudio/vc7/inffas32.obj
diff --git a/contrib/vstudio/vc70_32/miniunz.vcproj b/contrib/vstudio/vc7/miniunz.vcproj
index 1c6967f..935c250 100644
--- a/contrib/vstudio/vc70_32/miniunz.vcproj
+++ b/contrib/vstudio/vc7/miniunz.vcproj
@@ -19,7 +19,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 Optimization="0"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL;_DEBUG;_CONSOLE"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"

                                 MinimalRebuild="TRUE"

                                 BasicRuntimeChecks="3"

                                 RuntimeLibrary="5"

@@ -63,7 +63,7 @@
                                 Optimization="2"

                                 InlineFunctionExpansion="1"

                                 OmitFramePointers="TRUE"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL;NDEBUG;_CONSOLE"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"

                                 StringPooling="TRUE"

                                 RuntimeLibrary="4"

                                 EnableFunctionLevelLinking="TRUE"

@@ -116,7 +116,7 @@
                         Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">

                 </Filter>

                 <File

-                        RelativePath="zlib.lib">

+                        RelativePath="zlibwapi.lib">

                 </File>

         </Files>

         <Globals>

diff --git a/contrib/vstudio/vc70_32/minizip.vcproj b/contrib/vstudio/vc7/minizip.vcproj
index 93e2a41..e6f9107 100644
--- a/contrib/vstudio/vc70_32/minizip.vcproj
+++ b/contrib/vstudio/vc7/minizip.vcproj
@@ -19,7 +19,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 Optimization="0"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL;_DEBUG;_CONSOLE"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"

                                 MinimalRebuild="TRUE"

                                 BasicRuntimeChecks="3"

                                 RuntimeLibrary="5"

@@ -63,7 +63,7 @@
                                 Optimization="2"

                                 InlineFunctionExpansion="1"

                                 OmitFramePointers="TRUE"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL;NDEBUG;_CONSOLE"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"

                                 StringPooling="TRUE"

                                 RuntimeLibrary="4"

                                 EnableFunctionLevelLinking="TRUE"

@@ -116,7 +116,7 @@
                         Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">

                 </Filter>

                 <File

-                        RelativePath="zlib.lib">

+                        RelativePath="zlibwapi.lib">

                 </File>

         </Files>

         <Globals>

diff --git a/contrib/vstudio/vc70_32/zlib.rc b/contrib/vstudio/vc7/zlib.rc
index 6c51679..6c51679 100644
--- a/contrib/vstudio/vc70_32/zlib.rc
+++ b/contrib/vstudio/vc7/zlib.rc
diff --git a/contrib/vstudio/vc70_32/zlibstat.vcproj b/contrib/vstudio/vc7/zlibstat.vcproj
index 7470b58..eb182f7 100644
--- a/contrib/vstudio/vc70_32/zlibstat.vcproj
+++ b/contrib/vstudio/vc7/zlibstat.vcproj
@@ -20,7 +20,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 Optimization="0"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="5"

                                 PrecompiledHeaderFile=".\zlibstatDebug/zlibstat.pch"

@@ -61,7 +61,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="4"

@@ -102,7 +102,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL,ASMV"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI;ASMV;ASMINF"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="4"

@@ -117,7 +117,7 @@
                                 Name="VCCustomBuildTool"/>

                         <Tool

                                 Name="VCLibrarianTool"

-                                AdditionalOptions="gvmat32.obj  inffastAsm.obj /NODEFAULTLIB "

+                                AdditionalOptions="gvmat32.obj inffas32.obj /NODEFAULTLIB "

                                 OutputFile=".\zlibstat\zlibstat.lib"

                                 SuppressStartupBanner="TRUE"/>

                         <Tool

@@ -144,7 +144,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32;ZLIB_DLL"

+                                PreprocessorDefinitions="WIN32;ZLIB_WINAPI"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="4"

@@ -204,17 +204,6 @@
                         </File>

                         <File

                                 RelativePath=".\inffast.c">

-                                <FileConfiguration

-                                        Name="Release|Win32"

-                                        ExcludedFromBuild="TRUE">

-                                        <Tool

-                                                Name="VCCLCompilerTool"/>

-                                </FileConfiguration>

-                                <FileConfiguration

-                                        Name="ReleaseWithoutAsm|Win32">

-                                        <Tool

-                                                Name="VCCLCompilerTool"/>

-                                </FileConfiguration>

                         </File>

                         <File

                                 RelativePath=".\inflate.c">

diff --git a/contrib/vstudio/vc70_32/zlibvc.def b/contrib/vstudio/vc7/zlibvc.def
index c2804a8..63b3e6d 100644
--- a/contrib/vstudio/vc70_32/zlibvc.def
+++ b/contrib/vstudio/vc7/zlibvc.def
@@ -1,4 +1,3 @@
-LIBRARY         "zlib"

 

 VERSION         1.21

 

@@ -51,6 +50,10 @@ EXPORTS
         inflateBack                              @44

         inflateBackEnd                           @45

         compressBound                            @46

+        deflateBound                             @47

+        gzclearerr                               @48

+        gzungetc                                 @49

+        zlibCompileFlags                         @50

 

         unzOpen                                  @61

         unzClose                                 @62

diff --git a/contrib/vstudio/vc70_32/zlibvc.sln b/contrib/vstudio/vc7/zlibvc.sln
index 5a007ff..5a007ff 100644
--- a/contrib/vstudio/vc70_32/zlibvc.sln
+++ b/contrib/vstudio/vc7/zlibvc.sln
diff --git a/contrib/vstudio/vc70_32/zlibvc.vcproj b/contrib/vstudio/vc7/zlibvc.vcproj
index 7a9e83a..4e57bcd 100644
--- a/contrib/vstudio/vc70_32/zlibvc.vcproj
+++ b/contrib/vstudio/vc7/zlibvc.vcproj
@@ -20,7 +20,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 Optimization="0"

-                                PreprocessorDefinitions="WIN32,ZLIB_DLL,ASMV"

+                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="1"

                                 PrecompiledHeaderFile=".\DebugDll/zlibvc.pch"

@@ -35,15 +35,15 @@
                         <Tool

                                 Name="VCLinkerTool"

                                 AdditionalOptions="/MACHINE:I386"

-                                AdditionalDependencies="gvmat32.obj "

-                                OutputFile=".\DebugDll\zlib.dll"

+                                AdditionalDependencies="gvmat32.obj inffas32.obj"

+                                OutputFile=".\DebugDll\zlibwapi.dll"

                                 LinkIncremental="2"

                                 SuppressStartupBanner="TRUE"

                                 ModuleDefinitionFile=".\zlibvc.def"

                                 GenerateDebugInformation="TRUE"

-                                ProgramDatabaseFile=".\DebugDll/zlib.pdb"

+                                ProgramDatabaseFile=".\DebugDll/zlibwapi.pdb"

                                 SubSystem="2"

-                                ImportLibrary=".\DebugDll/zlib.lib"/>

+                                ImportLibrary=".\DebugDll/zlibwapi.lib"/>

                         <Tool

                                 Name="VCMIDLTool"

                                 PreprocessorDefinitions="_DEBUG"

@@ -76,7 +76,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32,ZLIB_DLL"

+                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="0"

@@ -95,17 +95,17 @@
                                 Name="VCLinkerTool"

                                 AdditionalOptions="/MACHINE:I386"

                                 AdditionalDependencies="crtdll.lib"

-                                OutputFile=".\zlibDllWithoutAsm\zlib.dll"

+                                OutputFile=".\zlibDllWithoutAsm\zlibwapi.dll"

                                 LinkIncremental="1"

                                 SuppressStartupBanner="TRUE"

                                 IgnoreAllDefaultLibraries="TRUE"

                                 ModuleDefinitionFile=".\zlibvc.def"

-                                ProgramDatabaseFile=".\zlibDllWithoutAsm/zlib.pdb"

+                                ProgramDatabaseFile=".\zlibDllWithoutAsm/zlibwapi.pdb"

                                 GenerateMapFile="TRUE"

-                                MapFileName=".\zlibDllWithoutAsm/zlib.map"

+                                MapFileName=".\zlibDllWithoutAsm/zlibwapi.map"

                                 SubSystem="2"

                                 OptimizeForWindows98="1"

-                                ImportLibrary=".\zlibDllWithoutAsm/zlib.lib"/>

+                                ImportLibrary=".\zlibDllWithoutAsm/zlibwapi.lib"/>

                         <Tool

                                 Name="VCMIDLTool"

                                 PreprocessorDefinitions="NDEBUG"

@@ -138,7 +138,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32,ZLIB_DLL,ASMV"

+                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="0"

@@ -156,18 +156,18 @@
                         <Tool

                                 Name="VCLinkerTool"

                                 AdditionalOptions="/MACHINE:I386"

-                                AdditionalDependencies="gvmat32.obj inffastAsm.obj "

-                                OutputFile=".\zlibDllWithoutCrtDll\zlib.dll"

+                                AdditionalDependencies="gvmat32.obj inffas32.obj "

+                                OutputFile=".\zlibDllWithoutCrtDll\zlibwapi.dll"

                                 LinkIncremental="1"

                                 SuppressStartupBanner="TRUE"

                                 IgnoreAllDefaultLibraries="FALSE"

                                 ModuleDefinitionFile=".\zlibvc.def"

-                                ProgramDatabaseFile=".\zlibDllWithoutCrtDll/zlib.pdb"

+                                ProgramDatabaseFile=".\zlibDllWithoutCrtDll/zlibwapi.pdb"

                                 GenerateMapFile="TRUE"

-                                MapFileName=".\zlibDllWithoutCrtDll/zlib.map"

+                                MapFileName=".\zlibDllWithoutCrtDll/zlibwapi.map"

                                 SubSystem="2"

                                 OptimizeForWindows98="1"

-                                ImportLibrary=".\zlibDllWithoutCrtDll/zlib.lib"/>

+                                ImportLibrary=".\zlibDllWithoutCrtDll/zlibwapi.lib"/>

                         <Tool

                                 Name="VCMIDLTool"

                                 PreprocessorDefinitions="NDEBUG"

@@ -200,7 +200,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32,ZLIB_DLL"

+                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="0"

@@ -218,16 +218,16 @@
                         <Tool

                                 Name="VCLinkerTool"

                                 AdditionalDependencies="crtdll.lib"

-                                OutputFile="zlibvc__\zlib.dll"

+                                OutputFile="zlibvc__\zlibwapi.dll"

                                 LinkIncremental="1"

                                 SuppressStartupBanner="TRUE"

                                 IgnoreAllDefaultLibraries="TRUE"

                                 ModuleDefinitionFile=".\zlibvc.def"

-                                ProgramDatabaseFile=".\zlibvc__/zlib.pdb"

+                                ProgramDatabaseFile=".\zlibvc__/zlibwapi.pdb"

                                 GenerateMapFile="TRUE"

-                                MapFileName=".\zlibvc__/zlib.map"

+                                MapFileName=".\zlibvc__/zlibwapi.map"

                                 SubSystem="2"

-                                ImportLibrary=".\zlibvc__/zlib.lib"/>

+                                ImportLibrary=".\zlibvc__/zlibwapi.lib"/>

                         <Tool

                                 Name="VCMIDLTool"

                                 PreprocessorDefinitions="NDEBUG"

@@ -260,7 +260,7 @@
                         <Tool

                                 Name="VCCLCompilerTool"

                                 InlineFunctionExpansion="1"

-                                PreprocessorDefinitions="WIN32,ZLIB_DLL,ASMV"

+                                PreprocessorDefinitions="WIN32,ZLIB_WINAPI,ASMV,ASMINF"

                                 StringPooling="TRUE"

                                 ExceptionHandling="FALSE"

                                 RuntimeLibrary="0"

@@ -278,18 +278,18 @@
                         <Tool

                                 Name="VCLinkerTool"

                                 AdditionalOptions="/MACHINE:I386"

-                                AdditionalDependencies="gvmat32.obj inffastAsm.obj crtdll.lib"

-                                OutputFile=".\ReleaseDll\zlib.dll"

+                                AdditionalDependencies="gvmat32.obj inffas32.obj crtdll.lib"

+                                OutputFile=".\ReleaseDll\zlibwapi.dll"

                                 LinkIncremental="1"

                                 SuppressStartupBanner="TRUE"

                                 IgnoreAllDefaultLibraries="TRUE"

                                 ModuleDefinitionFile=".\zlibvc.def"

-                                ProgramDatabaseFile=".\ReleaseDll/zlib.pdb"

+                                ProgramDatabaseFile=".\ReleaseDll/zlibwapi.pdb"

                                 GenerateMapFile="TRUE"

-                                MapFileName=".\ReleaseDll/zlib.map"

+                                MapFileName=".\ReleaseDll/zlibwapi.map"

                                 SubSystem="2"

                                 OptimizeForWindows98="1"

-                                ImportLibrary=".\ReleaseDll/zlib.lib"/>

+                                ImportLibrary=".\ReleaseDll/zlibwapi.lib"/>

                         <Tool

                                 Name="VCMIDLTool"

                                 PreprocessorDefinitions="NDEBUG"

@@ -346,18 +346,6 @@
                         </File>

                         <File

                                 RelativePath=".\inffast.c">

-                                <FileConfiguration

-                                        Name="ReleaseWithoutCrtdll|Win32"

-                                        ExcludedFromBuild="TRUE">

-                                        <Tool

-                                                Name="VCCLCompilerTool"/>

-                                </FileConfiguration>

-                                <FileConfiguration

-                                        Name="Release|Win32"

-                                        ExcludedFromBuild="TRUE">

-                                        <Tool

-                                                Name="VCCLCompilerTool"/>

-                                </FileConfiguration>

                         </File>

                         <File

                                 RelativePath=".\inflate.c">

diff --git a/contrib/vstudio/vc70_32/inffastAsm.asm b/contrib/vstudio/vc70_32/inffastAsm.asm
deleted file mode 100644
index f4b6a56..0000000
--- a/contrib/vstudio/vc70_32/inffastAsm.asm
+++ /dev/null
@@ -1,1020 +0,0 @@
-; 75 "inffast.S"

-;FILE "inffast.S"

-

-;;;GLOBAL _inflate_fast

-

-;;;SECTION .text

-

-

-

-    .586p

-    .mmx

-

-    name    inflate_fast_x86

-    .MODEL  FLAT

-

-_DATA                   segment

-inflate_fast_use_mmx: 

-dd    1

-

-

-_TEXT                   segment

-PUBLIC _inflate_fast

-

-ALIGN 4

-_inflate_fast: 

-        jmp inflate_fast_entry

-

-

-

-ALIGN 4

-        db     'Fast decoding Code from Chris Anderson'

-        db      0

-

-ALIGN 4

-invalid_literal_length_code_msg: 

-        db      'invalid literal/length code'

-        db      0

-

-ALIGN 4

-invalid_distance_code_msg: 

-        db      'invalid distance code'

-        db      0

-

-ALIGN 4

-invalid_distance_too_far_msg: 

-        db      'invalid distance too far back'

-        db      0

-

-

-ALIGN 4

-inflate_fast_mask: 

-dd    0

-dd    1

-dd    3

-dd    7

-dd    15

-dd    31

-dd    63

-dd    127

-dd    255

-dd    511

-dd    1023

-dd    2047

-dd    4095

-dd    8191

-dd    16383

-dd    32767

-dd    65535

-dd    131071

-dd    262143

-dd    524287

-dd    1048575

-dd    2097151

-dd    4194303

-dd    8388607

-dd    16777215

-dd    33554431

-dd    67108863

-dd    134217727

-dd    268435455

-dd    536870911

-dd    1073741823

-dd    2147483647

-dd    4294967295

-

-

-;;SECTION .text

-; 205 "inffast.S"

-;GLOBAL inflate_fast_use_mmx

-

-;SECTION .data

-

-

-; GLOBAL inflate_fast_use_mmx:object

-;.size inflate_fast_use_mmx, 4

-; 226 "inffast.S"

-;SECTION .text

-

-ALIGN 4 

-inflate_fast_entry: 

-        push  edi

-        push  esi

-        push  ebp

-        push  ebx

-        pushfd

-        sub  esp,64

-        cld

-

-

-

-

-        mov  esi, [esp+88]

-        mov  edi, [esi+28]

-

-

-

-

-

-

-

-        mov  edx, [esi+4]

-        mov  eax, [esi+0]

-

-        add  edx,eax

-        sub  edx,11

-

-        mov  [esp+44],eax

-        mov  [esp+20],edx

-

-        mov  ebp, [esp+92]

-        mov  ecx, [esi+16]

-        mov  ebx, [esi+12]

-

-        sub  ebp,ecx

-        neg  ebp

-        add  ebp,ebx

-

-        sub  ecx,257

-        add  ecx,ebx

-

-        mov  [esp+60],ebx

-        mov  [esp+40],ebp

-        mov  [esp+16],ecx

-; 285 "inffast.S"

-        mov  eax, [edi+64]

-        mov  ecx, [edi+68]

-

-        mov  [esp+8],eax

-        mov  [esp+12],ecx

-

-        mov  eax,1

-        mov  ecx, [edi+72]

-        shl  eax,cl

-        dec  eax

-        mov  [esp+0],eax

-

-        mov  eax,1

-        mov  ecx, [edi+76]

-        shl  eax,cl

-        dec  eax

-        mov  [esp+4],eax

-

-        mov  eax, [edi+32]

-        mov  ecx, [edi+36]

-        mov  edx, [edi+40]

-

-        mov  [esp+52],eax

-        mov  [esp+48],ecx

-        mov  [esp+56],edx

-

-        mov  ebp, [edi+44]

-        mov  ebx, [edi+48]

-; 321 "inffast.S"

-        mov  esi, [esp+44]

-        mov  ecx, [esp+20]

-        cmp  ecx,esi

-        ja   L_align_long

-

-        add  ecx,11

-        sub  ecx,esi

-        mov  eax,12

-        sub  eax,ecx

-        lea  edi, [esp+28]

-        rep movsb

-        mov  ecx,eax

-        xor  eax,eax

-        rep stosb

-        lea  esi, [esp+28]

-        mov  [esp+20],esi

-        jmp  L_is_aligned

-

-

-L_align_long: 

-        test  esi,3

-        jz   L_is_aligned

-        xor  eax,eax

-        mov  al, [esi]

-        inc  esi

-        mov  ecx,ebx

-        add  ebx,8

-        shl  eax,cl

-        or  ebp,eax

-        jmp L_align_long

-

-L_is_aligned: 

-        mov  edi, [esp+60]

-; 366 "inffast.S"

-L_check_mmx: 

-        cmp  dword ptr [inflate_fast_use_mmx],2

-        je   L_init_mmx

-        ja   L_do_loop

-

-        push  eax

-        push  ebx

-        push  ecx

-        push  edx

-        pushfd

-        mov  eax, [esp]

-        xor  dword ptr [esp],0200000h

-

-

-

-

-        popfd

-        pushfd

-        pop  edx

-        xor  edx,eax

-        jz   L_dont_use_mmx

-        xor  eax,eax

-        cpuid

-        cmp  ebx,0756e6547h

-        jne  L_dont_use_mmx

-        cmp  ecx,06c65746eh

-        jne  L_dont_use_mmx

-        cmp  edx,049656e69h

-        jne  L_dont_use_mmx

-        mov  eax,1

-        cpuid

-        shr  eax,8

-        and  eax,15

-        cmp  eax,6

-        jne  L_dont_use_mmx

-        test  edx,0800000h

-        jnz  L_use_mmx

-        jmp  L_dont_use_mmx

-L_use_mmx: 

-        mov  dword ptr [inflate_fast_use_mmx],2

-        jmp  L_check_mmx_pop

-L_dont_use_mmx: 

-        mov  dword ptr [inflate_fast_use_mmx],3

-L_check_mmx_pop: 

-        pop  edx

-        pop  ecx

-        pop  ebx

-        pop  eax

-        jmp  L_check_mmx

-; 426 "inffast.S"

-ALIGN 4

-L_do_loop: 

-; 437 "inffast.S"

-        cmp  bl,15

-        ja   L_get_length_code

-

-        xor  eax,eax

-        lodsw

-        mov  cl,bl

-        add  bl,16

-        shl  eax,cl

-        or  ebp,eax

-

-L_get_length_code: 

-        mov  edx, [esp+0]

-        mov  ecx, [esp+8]

-        and  edx,ebp

-        mov  eax, [ecx+edx*4]

-

-L_dolen: 

-

-

-

-

-

-

-        mov  cl,ah

-        sub  bl,ah

-        shr  ebp,cl

-

-

-

-

-

-

-        test  al,al

-        jnz   L_test_for_length_base

-

-        shr  eax,16

-        stosb

-

-L_while_test: 

-

-

-        cmp  [esp+16],edi

-        jbe  L_break_loop

-

-        cmp  [esp+20],esi

-        ja   L_do_loop

-        jmp  L_break_loop

-

-L_test_for_length_base: 

-; 502 "inffast.S"

-        mov  edx,eax

-        shr  edx,16

-        mov  cl,al

-

-        test  al,16

-        jz   L_test_for_second_level_length

-        and  cl,15

-        jz   L_save_len

-        cmp  bl,cl

-        jae  L_add_bits_to_len

-

-        mov  ch,cl

-        xor  eax,eax

-        lodsw

-        mov  cl,bl

-        add  bl,16

-        shl  eax,cl

-        or  ebp,eax

-        mov  cl,ch

-

-L_add_bits_to_len: 

-        mov  eax,1

-        shl  eax,cl

-        dec  eax

-        sub  bl,cl

-        and  eax,ebp

-        shr  ebp,cl

-        add  edx,eax

-

-L_save_len: 

-        mov  [esp+24],edx

-

-

-L_decode_distance: 

-; 549 "inffast.S"

-        cmp  bl,15

-        ja   L_get_distance_code

-

-        xor  eax,eax

-        lodsw

-        mov  cl,bl

-        add  bl,16

-        shl  eax,cl

-        or  ebp,eax

-

-L_get_distance_code: 

-        mov  edx, [esp+4]

-        mov  ecx, [esp+12]

-        and  edx,ebp

-        mov  eax, [ecx+edx*4]

-

-

-L_dodist: 

-        mov  edx,eax

-        shr  edx,16

-        mov  cl,ah

-        sub  bl,ah

-        shr  ebp,cl

-; 584 "inffast.S"

-        mov  cl,al

-

-        test  al,16

-        jz  L_test_for_second_level_dist

-        and  cl,15

-        jz  L_check_dist_one

-        cmp  bl,cl

-        jae  L_add_bits_to_dist

-

-        mov  ch,cl

-        xor  eax,eax

-        lodsw

-        mov  cl,bl

-        add  bl,16

-        shl  eax,cl

-        or  ebp,eax

-        mov  cl,ch

-

-L_add_bits_to_dist: 

-        mov  eax,1

-        shl  eax,cl

-        dec  eax

-        sub  bl,cl

-        and  eax,ebp

-        shr  ebp,cl

-        add  edx,eax

-        jmp  L_check_window

-

-L_check_window: 

-; 625 "inffast.S"

-        mov  [esp+44],esi

-        mov  eax,edi

-        sub  eax, [esp+40]

-

-        cmp  eax,edx

-        jb   L_clip_window

-

-        mov  ecx, [esp+24]

-        mov  esi,edi

-        sub  esi,edx

-

-        sub  ecx,3

-        mov  al, [esi]

-        mov  [edi],al

-        mov  al, [esi+1]

-        mov  dl, [esi+2]

-        add  esi,3

-        mov  [edi+1],al

-        mov  [edi+2],dl

-        add  edi,3

-        rep movsb

-

-        mov  esi, [esp+44]

-        jmp  L_while_test

-

-ALIGN 4

-L_check_dist_one: 

-        cmp  edx,1

-        jne  L_check_window

-        cmp  [esp+40],edi

-        je  L_check_window

-

-        dec  edi

-        mov  ecx, [esp+24]

-        mov  al, [edi]

-        sub  ecx,3

-

-        mov  [edi+1],al

-        mov  [edi+2],al

-        mov  [edi+3],al

-        add  edi,4

-        rep stosb

-

-        jmp  L_while_test

-

-ALIGN 4

-L_test_for_second_level_length: 

-

-

-

-

-        test  al,64

-        jnz   L_test_for_end_of_block

-

-        mov  eax,1

-        shl  eax,cl

-        dec  eax

-        and  eax,ebp

-        add  eax,edx

-        mov  edx, [esp+8]

-        mov  eax, [edx+eax*4]

-        jmp  L_dolen

-

-ALIGN 4

-L_test_for_second_level_dist: 

-

-

-

-

-        test  al,64

-        jnz   L_invalid_distance_code

-

-        mov  eax,1

-        shl  eax,cl

-        dec  eax

-        and  eax,ebp

-        add  eax,edx

-        mov  edx, [esp+12]

-        mov  eax, [edx+eax*4]

-        jmp  L_dodist

-

-ALIGN 4 

-L_clip_window: 

-; 721 "inffast.S"

-        mov  ecx,eax

-        mov  eax, [esp+52]

-        neg  ecx

-        mov  esi, [esp+56]

-

-        cmp  eax,edx

-        jb   L_invalid_distance_too_far

-

-        add  ecx,edx

-        cmp  dword ptr [esp+48],0

-        jne  L_wrap_around_window

-

-        sub  eax,ecx

-        add  esi,eax

-; 749 "inffast.S"

-        mov  eax, [esp+24]

-        cmp  eax,ecx

-        jbe  L_do_copy1

-

-        sub  eax,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,edx

-        jmp  L_do_copy1

-

-        cmp  eax,ecx

-        jbe  L_do_copy1

-

-        sub  eax,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,edx

-        jmp  L_do_copy1

-

-L_wrap_around_window: 

-; 793 "inffast.S"

-        mov  eax, [esp+48]

-        cmp  ecx,eax

-        jbe  L_contiguous_in_window

-

-        add  esi, [esp+52]

-        add  esi,eax

-        sub  esi,ecx

-        sub  ecx,eax

-

-

-        mov  eax, [esp+24]

-        cmp  eax,ecx

-        jbe  L_do_copy1

-

-        sub  eax,ecx

-        rep movsb

-        mov  esi, [esp+56]

-        mov  ecx, [esp+48]

-        cmp  eax,ecx

-        jbe  L_do_copy1

-

-        sub  eax,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,edx

-        jmp  L_do_copy1

-

-L_contiguous_in_window: 

-; 836 "inffast.S"

-        add  esi,eax

-        sub  esi,ecx

-

-

-        mov  eax, [esp+24]

-        cmp  eax,ecx

-        jbe  L_do_copy1

-

-        sub  eax,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,edx

-

-L_do_copy1: 

-; 862 "inffast.S"

-        mov  ecx,eax

-        rep movsb

-

-        mov  esi, [esp+44]

-        jmp  L_while_test

-; 878 "inffast.S"

-ALIGN 4

-L_init_mmx: 

-        emms

-

-

-

-

-

-        movd mm0,ebp

-        mov  ebp,ebx

-; 896 "inffast.S"

-        movd mm4,[esp+0]

-        movq mm3,mm4

-        movd mm5,[esp+4]

-        movq mm2,mm5

-        pxor mm1,mm1

-        mov  ebx, [esp+8]

-        jmp  L_do_loop_mmx

-

-ALIGN 4

-L_do_loop_mmx: 

-        psrlq mm0,mm1

-

-        cmp  ebp,32

-        ja  L_get_length_code_mmx

-

-        movd mm6,ebp

-        movd mm7,[esi]

-        add  esi,4

-        psllq mm7,mm6

-        add  ebp,32

-        por mm0,mm7

-

-L_get_length_code_mmx: 

-        pand mm4,mm0

-        movd eax,mm4

-        movq mm4,mm3

-        mov  eax, [ebx+eax*4]

-

-L_dolen_mmx: 

-        movzx  ecx,ah

-        movd mm1,ecx

-        sub  ebp,ecx

-

-        test  al,al

-        jnz L_test_for_length_base_mmx

-

-        shr  eax,16

-        stosb

-

-L_while_test_mmx: 

-

-

-        cmp  [esp+16],edi

-        jbe L_break_loop

-

-        cmp  [esp+20],esi

-        ja L_do_loop_mmx

-        jmp L_break_loop

-

-L_test_for_length_base_mmx: 

-

-        mov  edx,eax

-        shr  edx,16

-

-        test  al,16

-        jz  L_test_for_second_level_length_mmx

-        and  eax,15

-        jz L_decode_distance_mmx

-

-        psrlq mm0,mm1

-        movd mm1,eax

-        movd ecx,mm0

-        sub  ebp,eax

-        and  ecx, [inflate_fast_mask+eax*4]

-        add  edx,ecx

-

-L_decode_distance_mmx: 

-        psrlq mm0,mm1

-

-        cmp  ebp,32

-        ja L_get_dist_code_mmx

-

-        movd mm6,ebp

-        movd mm7,[esi]

-        add  esi,4

-        psllq mm7,mm6

-        add  ebp,32

-        por mm0,mm7

-

-L_get_dist_code_mmx: 

-        mov  ebx, [esp+12]

-        pand mm5,mm0

-        movd eax,mm5

-        movq mm5,mm2

-        mov  eax, [ebx+eax*4]

-

-L_dodist_mmx: 

-

-        movzx  ecx,ah

-        mov  ebx,eax

-        shr  ebx,16

-        sub  ebp,ecx

-        movd mm1,ecx

-

-        test  al,16

-        jz L_test_for_second_level_dist_mmx

-        and  eax,15

-        jz L_check_dist_one_mmx

-

-L_add_bits_to_dist_mmx: 

-        psrlq mm0,mm1

-        movd mm1,eax

-        movd ecx,mm0

-        sub  ebp,eax

-        and  ecx, [inflate_fast_mask+eax*4]

-        add  ebx,ecx

-

-L_check_window_mmx: 

-        mov  [esp+44],esi

-        mov  eax,edi

-        sub  eax, [esp+40]

-

-        cmp  eax,ebx

-        jb L_clip_window_mmx

-

-        mov  ecx,edx

-        mov  esi,edi

-        sub  esi,ebx

-

-        sub  ecx,3

-        mov  al, [esi]

-        mov  [edi],al

-        mov  al, [esi+1]

-        mov  dl, [esi+2]

-        add  esi,3

-        mov  [edi+1],al

-        mov  [edi+2],dl

-        add  edi,3

-        rep movsb

-

-        mov  esi, [esp+44]

-        mov  ebx, [esp+8]

-        jmp  L_while_test_mmx

-

-ALIGN 4

-L_check_dist_one_mmx: 

-        cmp  ebx,1

-        jne  L_check_window_mmx

-        cmp  [esp+40],edi

-        je   L_check_window_mmx

-

-        dec  edi

-        mov  ecx,edx

-        mov  al, [edi]

-        sub  ecx,3

-

-        mov  [edi+1],al

-        mov  [edi+2],al

-        mov  [edi+3],al

-        add  edi,4

-        rep stosb

-

-        mov  ebx, [esp+8]

-        jmp  L_while_test_mmx

-

-ALIGN 4

-L_test_for_second_level_length_mmx: 

-        test  al,64

-        jnz L_test_for_end_of_block

-

-        and  eax,15

-        psrlq mm0,mm1

-        movd ecx,mm0

-        and  ecx, [inflate_fast_mask+eax*4]

-        add  ecx,edx

-        mov  eax, [ebx+ecx*4]

-        jmp L_dolen_mmx

-

-ALIGN 4

-L_test_for_second_level_dist_mmx: 

-        test  al,64

-        jnz L_invalid_distance_code

-

-        and  eax,15

-        psrlq mm0,mm1

-        movd ecx,mm0

-        and  ecx, [inflate_fast_mask+eax*4]

-        mov  eax, [esp+12]

-        add  ecx,ebx

-        mov  eax, [eax+ecx*4]

-        jmp  L_dodist_mmx

-

-ALIGN 4

-L_clip_window_mmx: 

-

-        mov  ecx,eax

-        mov  eax, [esp+52]

-        neg  ecx

-        mov  esi, [esp+56]

-

-        cmp  eax,ebx

-        jb  L_invalid_distance_too_far

-

-        add  ecx,ebx

-        cmp  dword ptr [esp+48],0

-        jne  L_wrap_around_window_mmx

-

-        sub  eax,ecx

-        add  esi,eax

-

-        cmp  edx,ecx

-        jbe  L_do_copy1_mmx

-

-        sub  edx,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,ebx

-        jmp  L_do_copy1_mmx

-

-        cmp  edx,ecx

-        jbe  L_do_copy1_mmx

-

-        sub  edx,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,ebx

-        jmp  L_do_copy1_mmx

-

-L_wrap_around_window_mmx: 

-

-        mov  eax, [esp+48]

-        cmp  ecx,eax

-        jbe  L_contiguous_in_window_mmx

-

-        add  esi, [esp+52]

-        add  esi,eax

-        sub  esi,ecx

-        sub  ecx,eax

-

-

-        cmp  edx,ecx

-        jbe  L_do_copy1_mmx

-

-        sub  edx,ecx

-        rep movsb

-        mov  esi, [esp+56]

-        mov  ecx, [esp+48]

-        cmp  edx,ecx

-        jbe  L_do_copy1_mmx

-

-        sub  edx,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,ebx

-        jmp  L_do_copy1_mmx

-

-L_contiguous_in_window_mmx: 

-

-        add  esi,eax

-        sub  esi,ecx

-

-

-        cmp  edx,ecx

-        jbe  L_do_copy1_mmx

-

-        sub  edx,ecx

-        rep movsb

-        mov  esi,edi

-        sub  esi,ebx

-

-L_do_copy1_mmx: 

-

-

-        mov  ecx,edx

-        rep movsb

-

-        mov  esi, [esp+44]

-        mov  ebx, [esp+8]

-        jmp  L_while_test_mmx

-; 1174 "inffast.S"

-L_invalid_distance_code: 

-

-

-

-

-

-        mov  ecx, invalid_distance_code_msg

-        mov  edx,26

-        jmp  L_update_stream_state

-

-L_test_for_end_of_block: 

-

-

-

-

-

-        test  al,32

-        jz  L_invalid_literal_length_code

-

-        mov  ecx,0

-        mov  edx,11

-        jmp  L_update_stream_state

-

-L_invalid_literal_length_code: 

-

-

-

-

-

-        mov  ecx, invalid_literal_length_code_msg

-        mov  edx,26

-        jmp  L_update_stream_state

-

-L_invalid_distance_too_far: 

-

-

-

-        mov  esi, [esp+44]

-        mov  ecx, invalid_distance_too_far_msg

-        mov  edx,26

-        jmp  L_update_stream_state

-

-L_update_stream_state: 

-

-        mov  eax, [esp+88]

-        test  ecx,ecx

-        jz  L_skip_msg

-        mov  [eax+24],ecx

-L_skip_msg: 

-        mov  eax, [eax+28]

-        mov  [eax+0],edx

-        jmp  L_break_loop

-

-ALIGN 4

-L_break_loop: 

-; 1243 "inffast.S"

-        cmp  dword ptr [inflate_fast_use_mmx],2

-        jne  L_update_next_in

-

-

-

-        mov  ebx,ebp

-

-L_update_next_in: 

-; 1266 "inffast.S"

-        mov  eax, [esp+88]

-        mov  ecx,ebx

-        mov  edx, [eax+28]

-        shr  ecx,3

-        sub  esi,ecx

-        shl  ecx,3

-        sub  ebx,ecx

-        mov  [eax+12],edi

-        mov  [edx+48],ebx

-        mov  ecx,ebx

-

-        lea  ebx, [esp+28]

-        cmp  [esp+20],ebx

-        jne  L_buf_not_used

-

-        sub  esi,ebx

-        mov  ebx, [eax+0]

-        mov  [esp+20],ebx

-        add  esi,ebx

-        mov  ebx, [eax+4]

-        sub  ebx,11

-        add  [esp+20],ebx

-

-L_buf_not_used: 

-        mov  [eax+0],esi

-

-        mov  ebx,1

-        shl  ebx,cl

-        dec  ebx

-

-

-

-

-

-        cmp  dword ptr [inflate_fast_use_mmx],2

-        jne  L_update_hold

-

-

-

-        psrlq mm0,mm1

-        movd ebp,mm0

-

-        emms

-

-L_update_hold: 

-

-

-

-        and  ebp,ebx

-        mov  [edx+44],ebp

-

-

-

-

-        mov  ebx, [esp+20]

-        cmp  ebx,esi

-        jbe  L_last_is_smaller

-

-        sub  ebx,esi

-        add  ebx,11

-        mov  [eax+4],ebx

-        jmp  L_fixup_out

-L_last_is_smaller: 

-        sub  esi,ebx

-        neg  esi

-        add  esi,11

-        mov  [eax+4],esi

-

-

-

-

-L_fixup_out: 

-

-        mov  ebx, [esp+16]

-        cmp  ebx,edi

-        jbe  L_end_is_smaller

-

-        sub  ebx,edi

-        add  ebx,257

-        mov  [eax+16],ebx

-        jmp  L_done

-L_end_is_smaller: 

-        sub  edi,ebx

-        neg  edi

-        add  edi,257

-        mov  [eax+16],edi

-

-

-

-

-

-L_done: 

-        add  esp,64

-        popfd

-        pop  ebx

-        pop  ebp

-        pop  esi

-        pop  edi

-        ret

-

-

-

-

-_TEXT   ends

-end

diff --git a/contrib/vstudio/vc70_32/inffastAsm.obj b/contrib/vstudio/vc70_32/inffastAsm.obj
deleted file mode 100644
index 3855400..0000000
--- a/contrib/vstudio/vc70_32/inffastAsm.obj
+++ /dev/null
diff --git a/contrib/vstudio/vc70_32/mkgvmt32.bat b/contrib/vstudio/vc70_32/mkgvmt32.bat
deleted file mode 100644
index 9c54db7..0000000
--- a/contrib/vstudio/vc70_32/mkgvmt32.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-c:\masm611\bin\ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm

-c:\masm611\bin\ml /coff /Zi /c /FlinffastAsm.lst inffastAsm.asm