Removed zlib

1 files changed, 0 insertions, 624 deletions

diff --git a/zlib/contrib/masmx86/match686.lst b/zlib/contrib/masmx86/match686.lst
deleted file mode 100644
index 315ad87..0000000
--- a/zlib/contrib/masmx86/match686.lst
+++ /dev/null
@@ -1,624 +0,0 @@
-Microsoft (R) Macro Assembler Version 14.16.27031.1	    09/14/19 11:35:23
-match686.asm						     Page 1 - 1
-
-
-				; match686.asm -- Asm portion of the optimized longest_match for 32 bits x86
-				; Copyright (C) 1995-1996 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
-				; File written by Gilles Vollant, by converting match686.S from Brian Raiter
-				; for MASM. This is as assembly version of longest_match
-				;  from Jean-loup Gailly in deflate.c
-				;
-				;         http://www.zlib.net
-				;         http://www.winimage.com/zLibDll
-				;         http://www.muppetlabs.com/~breadbox/software/assembly.html
-				;
-				; For Visual C++ 4.x and higher and ML 6.x and higher
-				;   ml.exe is distributed in
-				;  http://www.microsoft.com/downloads/details.aspx?FamilyID=7a1c9da0-0510-44a2-b042-7ef370530c64
-				;
-				; this file contain two implementation of longest_match
-				;
-				;  this longest_match was written by Brian raiter (1998), optimized for Pentium Pro
-				;   (and the faster known version of match_init on modern Core 2 Duo and AMD Phenom)
-				;
-				;  for using an assembly version of longest_match, you need define ASMV in project
-				;
-				;    compile the asm file running
-				;           ml /coff /Zi /c /Flmatch686.lst match686.asm
-				;    and do not include match686.obj in your project
-				;
-				; note: contrib of zLib 1.2.3 and earlier contained both a deprecated version for
-				;  Pentium (prior Pentium Pro) and this version for Pentium Pro and modern processor
-				;  with autoselect (with cpu detection code)
-				;  if you want support the old pentium optimization, you can still use these version
-				;
-				; this file is not optimized for old pentium, but it compatible with all x86 32 bits
-				; processor (starting 80386)
-				;
-				;
-				; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2
-
-				;uInt longest_match(s, cur_match)
-				;    deflate_state *s;
-				;    IPos cur_match;                             /* current match */
-
- = 0000004C			    NbStack         equ     76
- = dword ptr[esp+NbStack-0]	    cur_match       equ     dword ptr[esp+NbStack-0]
- = dword ptr[esp+NbStack-4]	    str_s           equ     dword ptr[esp+NbStack-4]
-				; 5 dword on top (ret,ebp,esi,edi,ebx)
- = dword ptr[esp+NbStack-8]	    adrret          equ     dword ptr[esp+NbStack-8]
- = dword ptr[esp+NbStack-12	    pushebp         equ     dword ptr[esp+NbStack-12]
-   ]
- = dword ptr[esp+NbStack-16	    pushedi         equ     dword ptr[esp+NbStack-16]
-   ]
- = dword ptr[esp+NbStack-20	    pushesi         equ     dword ptr[esp+NbStack-20]
-   ]
- = dword ptr[esp+NbStack-24	    pushebx         equ     dword ptr[esp+NbStack-24]
-   ]
-
- = dword ptr [esp+NbStack-2	    chain_length    equ     dword ptr [esp+NbStack-28]
-   8]
- = dword ptr [esp+NbStack-3	    limit           equ     dword ptr [esp+NbStack-32]
-   2]
- = dword ptr [esp+NbStack-3	    best_len        equ     dword ptr [esp+NbStack-36]
-   6]
- = dword ptr [esp+NbStack-4	    window          equ     dword ptr [esp+NbStack-40]
-   0]
- = dword ptr [esp+NbStack-4	    prev            equ     dword ptr [esp+NbStack-44]
-   4]
- = word ptr [esp+NbStack-48	    scan_start      equ      word ptr [esp+NbStack-48]
-   ]
- = dword ptr [esp+NbStack-5	    wmask           equ     dword ptr [esp+NbStack-52]
-   2]
- = dword ptr [esp+NbStack-5	    match_start_ptr equ     dword ptr [esp+NbStack-56]
-   6]
- = dword ptr [esp+NbStack-6	    nice_match      equ     dword ptr [esp+NbStack-60]
-   0]
- = dword ptr [esp+NbStack-6	    scan            equ     dword ptr [esp+NbStack-64]
-   4]
-
- = dword ptr [esp+NbStack-6	    windowlen       equ     dword ptr [esp+NbStack-68]
-   8]
- = dword ptr [esp+NbStack-7	    match_start     equ     dword ptr [esp+NbStack-72]
-   2]
- = dword ptr [esp+NbStack-7	    strend          equ     dword ptr [esp+NbStack-76]
-   6]
- = 00000034			    NbStackAdd      equ     (NbStack-24)
-
-				    .386p
-
-				    name    gvmatch
-				    .MODEL  FLAT
-
-
-
-				;  all the +zlib1222add offsets are due to the addition of fields
-				;  in zlib in the deflate_state structure since the asm code was first written
-				;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
-				;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
-				;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
-
- = 00000008			    zlib1222add         equ     8
-
-				;  Note : these value are good with a 8 bytes boundary pack structure
- = 0000007C			    dep_chain_length    equ     74h+zlib1222add
- = 00000038			    dep_window          equ     30h+zlib1222add
- = 0000006C			    dep_strstart        equ     64h+zlib1222add
- = 00000078			    dep_prev_length     equ     70h+zlib1222add
- = 00000090			    dep_nice_match      equ     88h+zlib1222add
- = 0000002C			    dep_w_size          equ     24h+zlib1222add
- = 00000040			    dep_prev            equ     38h+zlib1222add
- = 00000034			    dep_w_mask          equ     2ch+zlib1222add
- = 0000008C			    dep_good_match      equ     84h+zlib1222add
- = 00000070			    dep_match_start     equ     68h+zlib1222add
- = 00000074			    dep_lookahead       equ     6ch+zlib1222add
-
-
- 00000000			_TEXT                   segment
-
-				IFDEF NOUNDERLINE
-				ELSE
-				            public  _longest_match
-				            public  _match_init
-				ENDIF
-
- = 00000102			    MAX_MATCH           equ     258
- = 00000003			    MIN_MATCH           equ     3
- = 00000106			    MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
-
-
-
- = 00000102			MAX_MATCH       equ     258
- = 00000003			MIN_MATCH       equ     3
- = 00000106			MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)
- = 00000100			MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)
-
-
-				;;; stack frame offsets
-
- = esp + 0			chainlenwmask   equ  esp + 0    ; high word: current chain len
-				                    ; low word: s->wmask
- = esp + 4			window      equ  esp + 4    ; local copy of s->window
- = esp + 8			windowbestlen   equ  esp + 8    ; s->window + bestlen
- = esp + 16			scanstart   equ  esp + 16   ; first two bytes of string
- = esp + 12			scanend     equ  esp + 12   ; last two bytes of string
- = esp + 20			scanalign   equ  esp + 20   ; dword-misalignment of string
- = esp + 24			nicematch   equ  esp + 24   ; a good enough match size
- = esp + 28			bestlen     equ  esp + 28   ; size of best match so far
- = esp + 32			scan        equ  esp + 32   ; ptr to string wanting match
-
- = 00000024			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
- = esp + 56			deflatestate    equ  esp + 56   ; the function arguments
- = esp + 60			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.)
-
- = 0000002C			dsWSize     equ 36+zlib1222add
- = 00000034			dsWMask     equ 44+zlib1222add
- = 00000038			dsWindow    equ 48+zlib1222add
- = 00000040			dsPrev      equ 56+zlib1222add
- = 00000060			dsMatchLen  equ 88+zlib1222add
- = 00000064			dsPrevMatch equ 92+zlib1222add
- = 0000006C			dsStrStart  equ 100+zlib1222add
- = 00000070			dsMatchStart    equ 104+zlib1222add
- = 00000074			dsLookahead equ 108+zlib1222add
- = 00000078			dsPrevLen   equ 112+zlib1222add
- = 0000007C			dsMaxChainLen   equ 116+zlib1222add
- = 0000008C			dsGoodMatch equ 132+zlib1222add
- = 00000090			dsNiceMatch equ 136+zlib1222add
-
-
-				;;; match686.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 software is provided 'as-is', without any express or implied
-				;;  warranty.  In no event will the authors be held liable for any damages
-				;;  arising from the use of this software.
-				;;
-				;;  Permission is granted to anyone to use this software for any purpose,
-				;;  including commercial applications, and to alter it and redistribute it
-				;;  freely, subject to the following restrictions:
-				;;
-				;;  1. The origin of this software must not be misrepresented; you must not
-				;;     claim that you wrote the original software. If you use this software
-				;;     in a product, an acknowledgment in the product documentation would be
-				;;     appreciated but is not required.
-				;;  2. Altered source versions must be plainly marked as such, and must not be
-				;;     misrepresented as being the original software
-				;;  3. This notice may not be removed or altered from any source distribution.
-				;;
-
-				;GLOBAL _longest_match, _match_init
-
-
-				;SECTION    .text
-
-				;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
-
-				;_longest_match:
-				    IFDEF NOUNDERLINE
-				    ELSE
- 00000000			    _longest_match      proc near
-				    ENDIF
- 00000000			.FPO (9, 4, 0, 0, 1, 0)
-
-				;;; Save registers that the compiler may be using, and adjust esp to
-				;;; make room for our stack frame.
-
- 00000000  55			        push    ebp
- 00000001  57			        push    edi
- 00000002  56			        push    esi
- 00000003  53			        push    ebx
- 00000004  83 EC 24		        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.
-
- 00000007  8B 54 24 38		        mov edx, [deflatestate]
- 0000000B  8B 4C 24 3C		        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;
-				;;; }
-
- 0000000F  8B 42 78		        mov eax, [edx + dsPrevLen]
- 00000012  8B 9A 0000008C	        mov ebx, [edx + dsGoodMatch]
- 00000018  3B C3		        cmp eax, ebx
- 0000001A  8B 42 34		        mov eax, [edx + dsWMask]
- 0000001D  8B 5A 7C		        mov ebx, [edx + dsMaxChainLen]
- 00000020  7C 03		        jl  LastMatchGood
- 00000022  C1 EB 02		        shr ebx, 2
- 00000025			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.
-
- 00000025  4B			        dec ebx
- 00000026  C1 E3 10		        shl ebx, 16
- 00000029  0B D8		        or  ebx, eax
- 0000002B  89 1C 24		        mov [chainlenwmask], ebx
-
-				;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
-
- 0000002E  8B 82 00000090	        mov eax, [edx + dsNiceMatch]
- 00000034  8B 5A 74		        mov ebx, [edx + dsLookahead]
- 00000037  3B D8		        cmp ebx, eax
- 00000039  7C 02		        jl  LookaheadLess
- 0000003B  8B D8		        mov ebx, eax
- 0000003D  89 5C 24 18		LookaheadLess:  mov [nicematch], ebx
-
-				;;; register Bytef *scan = s->window + s->strstart;
-
- 00000041  8B 72 38		        mov esi, [edx + dsWindow]
- 00000044  89 74 24 04		        mov [window], esi
- 00000048  8B 6A 6C		        mov ebp, [edx + dsStrStart]
- 0000004B  8D 3C 2E		        lea edi, [esi + ebp]
- 0000004E  89 7C 24 20		        mov [scan], edi
-
-				;;; Determine how many bytes the scan ptr is off from being
-				;;; dword-aligned.
-
- 00000052  8B C7		        mov eax, edi
- 00000054  F7 D8		        neg eax
- 00000056  83 E0 03		        and eax, 3
- 00000059  89 44 24 14		        mov [scanalign], eax
-
-				;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-				;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
-
- 0000005D  8B 42 2C		        mov eax, [edx + dsWSize]
- 00000060  2D 00000106		        sub eax, MIN_LOOKAHEAD
- 00000065  2B E8		        sub ebp, eax
- 00000067  7F 02		        jg  LimitPositive
- 00000069  33 ED		        xor ebp, ebp
- 0000006B			LimitPositive:
-
-				;;; int best_len = s->prev_length;
-
- 0000006B  8B 42 78		        mov eax, [edx + dsPrevLen]
- 0000006E  89 44 24 1C		        mov [bestlen], eax
-
-				;;; Store the sum of s->window + best_len in esi locally, and in esi.
-
- 00000072  03 F0		        add esi, eax
- 00000074  89 74 24 08		        mov [windowbestlen], esi
-
-				;;; register ush scan_start = *(ushf*)scan;
-				;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
-				;;; Posf *prev = s->prev;
-
- 00000078  0F B7 1F		        movzx   ebx, word ptr [edi]
- 0000007B  89 5C 24 10		        mov [scanstart], ebx
- 0000007F  0F B7 5C 07 FF	        movzx   ebx, word ptr [edi + eax - 1]
- 00000084  89 5C 24 0C		        mov [scanend], ebx
- 00000088  8B 7A 40		        mov edi, [edx + dsPrev]
-
-				;;; Jump into the main loop.
-
- 0000008B  8B 14 24		        mov edx, [chainlenwmask]
- 0000008E  EB 1A		        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
-
- 00000090			LookupLoop:
- 00000090  23 CA		        and ecx, edx
- 00000092  0F B7 0C 4F		        movzx   ecx, word ptr [edi + ecx*2]
- 00000096  3B CD		        cmp ecx, ebp
- 00000098  0F 86 000000E0	        jbe LeaveNow
- 0000009E  81 EA 00010000	        sub edx, 00010000h
- 000000A4  0F 88 000000D4	        js  LeaveNow
- 000000AA  0F B7 44 0E FF	LoopEntry:  movzx   eax, word ptr [esi + ecx - 1]
- 000000AF  3B C3		        cmp eax, ebx
- 000000B1  75 DD		        jnz LookupLoop
- 000000B3  8B 44 24 04		        mov eax, [window]
- 000000B7  0F B7 04 08		        movzx   eax, word ptr [eax + ecx]
- 000000BB  3B 44 24 10		        cmp eax, [scanstart]
- 000000BF  75 CF		        jnz LookupLoop
-
-				;;; Store the current value of chainlen.
-
- 000000C1  89 14 24		        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).
-
- 000000C4  8B 74 24 04		        mov esi, [window]
- 000000C8  8B 7C 24 20		        mov edi, [scan]
- 000000CC  03 F1		        add esi, ecx
- 000000CE  8B 44 24 14		        mov eax, [scanalign]
- 000000D2  BA FFFFFEF8		        mov edx, 0fffffef8h; -(MAX_MATCH_8)
- 000000D7  8D BC 07		        lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
-	   00000108
- 000000DE  8D B4 06		        lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
-	   00000108
-
-				;;; 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.
-
- 000000E5			LoopCmps:
- 000000E5  8B 04 16		        mov eax, [esi + edx]
- 000000E8  33 04 17		        xor eax, [edi + edx]
- 000000EB  75 14		        jnz LeaveLoopCmps
- 000000ED  8B 44 16 04		        mov eax, [esi + edx + 4]
- 000000F1  33 44 17 04		        xor eax, [edi + edx + 4]
- 000000F5  75 07		        jnz LeaveLoopCmps4
- 000000F7  83 C2 08		        add edx, 8
- 000000FA  75 E9		        jnz LoopCmps
- 000000FC  EB 71		        jmp short LenMaximum
- 000000FE  83 C2 04		LeaveLoopCmps4: add edx, 4
- 00000101  A9 0000FFFF		LeaveLoopCmps:  test    eax, 0000FFFFh
- 00000106  75 06		        jnz LenLower
- 00000108  83 C2 02		        add edx,  2
- 0000010B  C1 E8 10		        shr eax, 16
- 0000010E  2C 01		LenLower:   sub al, 1
- 00000110  83 D2 00		        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.
-
- 00000113  8D 04 17		        lea eax, [edi + edx]
- 00000116  8B 7C 24 20		        mov edi, [scan]
- 0000011A  2B C7		        sub eax, edi
- 0000011C  3D 00000102		        cmp eax, MAX_MATCH
- 00000121  7D 4C		        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.
-
- 00000123  8B 54 24 38		        mov edx, [deflatestate]
- 00000127  8B 5C 24 1C		        mov ebx, [bestlen]
- 0000012B  3B C3		        cmp eax, ebx
- 0000012D  7F 13		        jg  LongerMatch
- 0000012F  8B 74 24 08		        mov esi, [windowbestlen]
- 00000133  8B 7A 40		        mov edi, [edx + dsPrev]
- 00000136  8B 5C 24 0C		        mov ebx, [scanend]
- 0000013A  8B 14 24		        mov edx, [chainlenwmask]
- 0000013D  E9 FFFFFF4E		        jmp LookupLoop
-
-				;;;         s->match_start = cur_match;
-				;;;         best_len = len;
-				;;;         if (len >= nice_match) break;
-				;;;         scan_end = *(ushf*)(scan+best_len-1);
-
- 00000142  8B 5C 24 18		LongerMatch:    mov ebx, [nicematch]
- 00000146  89 44 24 1C		        mov [bestlen], eax
- 0000014A  89 4A 70		        mov [edx + dsMatchStart], ecx
- 0000014D  3B C3		        cmp eax, ebx
- 0000014F  7D 2D		        jge LeaveNow
- 00000151  8B 74 24 04		        mov esi, [window]
- 00000155  03 F0		        add esi, eax
- 00000157  89 74 24 08		        mov [windowbestlen], esi
- 0000015B  0F B7 5C 07 FF	        movzx   ebx, word ptr [edi + eax - 1]
- 00000160  8B 7A 40		        mov edi, [edx + dsPrev]
- 00000163  89 5C 24 0C		        mov [scanend], ebx
- 00000167  8B 14 24		        mov edx, [chainlenwmask]
- 0000016A  E9 FFFFFF21		        jmp LookupLoop
-
-				;;; Accept the current string, with the maximum possible length.
-
- 0000016F  8B 54 24 38		LenMaximum: mov edx, [deflatestate]
- 00000173  C7 44 24 1C		        mov dword ptr [bestlen], MAX_MATCH
-	   00000102
- 0000017B  89 4A 70		        mov [edx + dsMatchStart], ecx
-
-				;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
-				;;; return s->lookahead;
-
- 0000017E			LeaveNow:
- 0000017E  8B 54 24 38		        mov edx, [deflatestate]
- 00000182  8B 5C 24 1C		        mov ebx, [bestlen]
- 00000186  8B 42 74		        mov eax, [edx + dsLookahead]
- 00000189  3B D8		        cmp ebx, eax
- 0000018B  7F 02		        jg  LookaheadRet
- 0000018D  8B C3		        mov eax, ebx
- 0000018F			LookaheadRet:
-
-				;;; Restore the stack and return from whence we came.
-
- 0000018F  83 C4 24		        add esp, LocalVarsSize
- 00000192  5B			        pop ebx
- 00000193  5E			        pop esi
- 00000194  5F			        pop edi
- 00000195  5D			        pop ebp
-
- 00000196  C3			        ret
-				; please don't remove this string !
-				; Your can freely use match686 in any free or commercial app if you don't remove the string in the binary!
- 00000197  0D 0A 61 73 6D	    db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
-	   36 38 36 20 77
-	   69 74 68 20 6D
-	   61 73 6D 2C 20
-	   6F 70 74 69 6D
-	   69 73 65 64 20
-	   61 73 73 65 6D
-	   62 6C 79 20 63
-	   6F 64 65 20 66
-	   72 6F 6D 20 42
-	   72 69 61 6E 20
-	   52 61 69 74 65
-	   72 2C 20 77 72
-	   69 74 74 65 6E
-	   20 31 39 39 38
-	   0D 0A
-
-
-				    IFDEF NOUNDERLINE
-				    ELSE
- 000001E4			    _longest_match      endp
-				    ENDIF
-
-				    IFDEF NOUNDERLINE
-				    ELSE
- 000001E4			    _match_init     proc near
- 000001E4  C3			                    ret
- 000001E5			    _match_init     endp
-				    ENDIF
-
-
- 000001E5			_TEXT   ends
-				end
-Microsoft (R) Macro Assembler Version 14.16.27031.1	    09/14/19 11:35:23
-match686.asm						     Symbols 2 - 1
-
-
-
-
-Segments and Groups:
-
-                N a m e                 Size     Length   Align   Combine Class
-
-FLAT . . . . . . . . . . . . . .	GROUP
-_DATA  . . . . . . . . . . . . .	32 Bit	 00000000 Para	  Public  'DATA'	
-_TEXT  . . . . . . . . . . . . .	32 Bit	 000001E5 Para	  Public  'CODE'	
-
-
-Procedures, parameters, and locals:
-
-                N a m e                 Type     Value    Attr
-
-_longest_match . . . . . . . . .	P Near	 00000000 _TEXT	Length= 000001E4 Public
-  LastMatchGood  . . . . . . . .	L Near	 00000025 _TEXT	
-  LookaheadLess  . . . . . . . .	L Near	 0000003D _TEXT	
-  LimitPositive  . . . . . . . .	L Near	 0000006B _TEXT	
-  LookupLoop . . . . . . . . . .	L Near	 00000090 _TEXT	
-  LoopEntry  . . . . . . . . . .	L Near	 000000AA _TEXT	
-  LoopCmps . . . . . . . . . . .	L Near	 000000E5 _TEXT	
-  LeaveLoopCmps4 . . . . . . . .	L Near	 000000FE _TEXT	
-  LeaveLoopCmps  . . . . . . . .	L Near	 00000101 _TEXT	
-  LenLower . . . . . . . . . . .	L Near	 0000010E _TEXT	
-  LongerMatch  . . . . . . . . .	L Near	 00000142 _TEXT	
-  LenMaximum . . . . . . . . . .	L Near	 0000016F _TEXT	
-  LeaveNow . . . . . . . . . . .	L Near	 0000017E _TEXT	
-  LookaheadRet . . . . . . . . .	L Near	 0000018F _TEXT	
-_match_init  . . . . . . . . . .	P Near	 000001E4 _TEXT	Length= 00000001 Public
-
-
-Symbols:
-
-                N a m e                 Type     Value    Attr
-
-@CodeSize  . . . . . . . . . . .	Number	 00000000h   
-@DataSize  . . . . . . . . . . .	Number	 00000000h   
-@Interface . . . . . . . . . . .	Number	 00000000h   
-@Model . . . . . . . . . . . . .	Number	 00000007h   
-@code  . . . . . . . . . . . . .	Text   	 _TEXT
-@data  . . . . . . . . . . . . .	Text   	 FLAT
-@fardata?  . . . . . . . . . . .	Text   	 FLAT
-@fardata . . . . . . . . . . . .	Text   	 FLAT
-@stack . . . . . . . . . . . . .	Text   	 FLAT
-LocalVarsSize  . . . . . . . . .	Number	 00000024h   
-MAX_MATCH_8_ . . . . . . . . . .	Number	 00000100h   
-MAX_MATCH  . . . . . . . . . . .	Number	 00000102h   
-MIN_LOOKAHEAD  . . . . . . . . .	Number	 00000106h   
-MIN_MATCH  . . . . . . . . . . .	Number	 00000003h   
-NbStackAdd . . . . . . . . . . .	Number	 00000034h   
-NbStack  . . . . . . . . . . . .	Number	 0000004Ch   
-adrret . . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-8]
-best_len . . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-36]
-bestlen  . . . . . . . . . . . .	Text   	 esp + 28
-chain_length . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-28]
-chainlenwmask  . . . . . . . . .	Text   	 esp + 0
-cur_match  . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-0]
-curmatch . . . . . . . . . . . .	Text   	 esp + 60
-deflatestate . . . . . . . . . .	Text   	 esp + 56
-dep_chain_length . . . . . . . .	Number	 0000007Ch   
-dep_good_match . . . . . . . . .	Number	 0000008Ch   
-dep_lookahead  . . . . . . . . .	Number	 00000074h   
-dep_match_start  . . . . . . . .	Number	 00000070h   
-dep_nice_match . . . . . . . . .	Number	 00000090h   
-dep_prev_length  . . . . . . . .	Number	 00000078h   
-dep_prev . . . . . . . . . . . .	Number	 00000040h   
-dep_strstart . . . . . . . . . .	Number	 0000006Ch   
-dep_w_mask . . . . . . . . . . .	Number	 00000034h   
-dep_w_size . . . . . . . . . . .	Number	 0000002Ch   
-dep_window . . . . . . . . . . .	Number	 00000038h   
-dsGoodMatch  . . . . . . . . . .	Number	 0000008Ch   
-dsLookahead  . . . . . . . . . .	Number	 00000074h   
-dsMatchLen . . . . . . . . . . .	Number	 00000060h   
-dsMatchStart . . . . . . . . . .	Number	 00000070h   
-dsMaxChainLen  . . . . . . . . .	Number	 0000007Ch   
-dsNiceMatch  . . . . . . . . . .	Number	 00000090h   
-dsPrevLen  . . . . . . . . . . .	Number	 00000078h   
-dsPrevMatch  . . . . . . . . . .	Number	 00000064h   
-dsPrev . . . . . . . . . . . . .	Number	 00000040h   
-dsStrStart . . . . . . . . . . .	Number	 0000006Ch   
-dsWMask  . . . . . . . . . . . .	Number	 00000034h   
-dsWSize  . . . . . . . . . . . .	Number	 0000002Ch   
-dsWindow . . . . . . . . . . . .	Number	 00000038h   
-limit  . . . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-32]
-match_start_ptr  . . . . . . . .	Text   	 dword ptr [esp+NbStack-56]
-match_start  . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-72]
-nice_match . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-60]
-nicematch  . . . . . . . . . . .	Text   	 esp + 24
-prev . . . . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-44]
-pushebp  . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-12]
-pushebx  . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-24]
-pushedi  . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-16]
-pushesi  . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-20]
-scan_start . . . . . . . . . . .	Text   	 word ptr [esp+NbStack-48]
-scanalign  . . . . . . . . . . .	Text   	 esp + 20
-scanend  . . . . . . . . . . . .	Text   	 esp + 12
-scanstart  . . . . . . . . . . .	Text   	 esp + 16
-scan . . . . . . . . . . . . . .	Text   	 esp + 32
-str_s  . . . . . . . . . . . . .	Text   	 dword ptr[esp+NbStack-4]
-strend . . . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-76]
-windowbestlen  . . . . . . . . .	Text   	 esp + 8
-windowlen  . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-68]
-window . . . . . . . . . . . . .	Text   	 esp + 4
-wmask  . . . . . . . . . . . . .	Text   	 dword ptr [esp+NbStack-52]
-zlib1222add  . . . . . . . . . .	Number	 00000008h   
-
-	   0 Warnings
-	   0 Errors