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