; deflate.asm -- compress data using the deflation algorithm
; Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
; For conditions of distribution and use, see copyright notice in zlib.inc

;  ALGORITHM

;      The "deflation" process depends on being able to identify portions
;      of the input text which are identical to earlier input (within a
;      sliding window trailing behind the input currently being processed).

;      The most straightforward technique turns out to be the fastest for
;      most input files: try all possible matches and select the longest.
;      The key feature of this algorithm is that insertions into the string
;      dictionary are very simple and thus fast, and deletions are avoided
;      completely. Insertions are performed at each input character, whereas
;      string matches are performed only when the previous match ends. So it
;      is preferable to spend more time in matches to allow very fast string
;      insertions and avoid deletions. The matching algorithm for small
;      strings is inspired from that of Rabin & Karp. A brute force approach
;      is used to find longer strings when a small match has been found.
;      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
;      (by Leonid Broukhis).
;         A previous version of this file used a more sophisticated algorithm
;      (by Fiala and Greene) which is guaranteed to run in linear amortized
;      time, but has a larger average cost, uses more memory and is patented.
;      However the F&G algorithm may be faster for some highly redundant
;      files if the parameter max_chain_length (described below) is too large.

;  ACKNOWLEDGEMENTS

;      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
;      I found it in 'freeze' written by Leonid Broukhis.
;      Thanks to many people for bug reports and testing.

;  REFERENCES

;      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
;      Available in http://tools.ietf.org/html/rfc1951

;      A description of the Rabin and Karp algorithm is given in the book
;         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.

;      Fiala,E.R., and Greene,D.H.
;         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595


deflate_copyright db ' deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler ',0

;  If you use the zlib library in a product, an acknowledgment is welcome
;  in the documentation of your product. If for some reason you cannot
;  include such an acknowledgment, I would appreciate that you keep this
;  copyright string in the executable of your product.

; ===========================================================================
;  Function prototypes.

;enum block_state
need_more   equ 1 ;block not completed, need more input or more output
block_done  equ 2 ;block flush performed
finish_started equ 3 ;finish started, need only more output at next deflate
finish_done equ 4 ;finish done, accept no more input or output

; ===========================================================================
; Local data

NIL equ 0
; Tail of hash chains

TOO_FAR equ 4096
; Matches of length 3 are discarded if their distance exceeds TOO_FAR

; Values for max_lazy_match, good_match and max_chain_length, depending on
; the desired pack level (0..9). The values given below have been tuned to
; exclude worst case performance for pathological files. Better values may be
; found for specific files.

struct config_s ;config
	good_length dw ? ;uint_16 ;reduce lazy search above this match length
	max_lazy    dw ? ;uint_16 ;do not perform lazy search above this match length
	nice_length dw ? ;uint_16 ;quit search above this match length
	max_chain   dw ? ;uint_16
	co_func     dd ? ;compress_func
ends

align 16
configuration_table:
	config_s  0,   0,   0,    0, deflate_stored  ;store only
	config_s  4,   4,   8,    4, deflate_fast ;max speed, no lazy matches
if FASTEST eq 0
	config_s  4,   5,  16,    8, deflate_fast
	config_s  4,   6,  32,   32, deflate_fast
	config_s  4,   4,  16,   16, deflate_slow ;lazy matches
	config_s  8,  16,  32,   32, deflate_slow
	config_s  8,  16, 128,  128, deflate_slow
	config_s  8,  32, 128,  256, deflate_slow
	config_s 32, 128, 258, 1024, deflate_slow
	config_s 32, 258, 258, 4096, deflate_slow ;max compression
end if

; Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
; For deflate_fast() (levels <= 3) good is ignored and lazy has a different
; meaning.


EQUAL equ 0
; result of memcmp for equal strings

; rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH
macro RANK f, reg
{
local .end0
	xor reg,reg
	cmp f,4
	jle .end0
		sub reg,9
	.end0:
	add reg,f
	add reg,f
}

; ===========================================================================
; Update a hash value with the given input byte
; IN  assertion: all calls to to UPDATE_HASH are made with consecutive
;    input characters, so that a running hash key can be computed from the
;    previous key instead of complete recalculation each time.

macro UPDATE_HASH s,h,c
{
push ebx ecx
	mov ebx,h
	mov ecx,[s+deflate_state.hash_shift]
	shl ebx,cl
	xor ebx,c
	and ebx,[s+deflate_state.hash_mask]
	mov h,ebx
pop ecx ebx
}

; ===========================================================================
; Insert string str in the dictionary and set match_head to the previous head
; of the hash chain (the most recent string with same hash key). Return
; the previous length of the hash chain.
; If this file is compiled with -DFASTEST, the compression level is forced
; to 1, and no hash chains are maintained.
; IN  assertion: all calls to to INSERT_STRING are made with consecutive
;    input characters and the first MIN_MATCH bytes of str are valid
;    (except for the last MIN_MATCH-1 bytes of the input file).

macro INSERT_STRING s, str, match_head
{
	mov eax,[s+deflate_state.window]
	add eax,str
	add eax,MIN_MATCH-1
	movzx eax,byte[eax]
	UPDATE_HASH s, [s+deflate_state.ins_h], eax
	mov eax,[s+deflate_state.ins_h]
	shl eax,2
	add eax,[s+deflate_state.head]
	mov eax,[eax]
	mov match_head,eax
if FASTEST eq 0
push ebx
	mov ebx,[s+deflate_state.w_mask]
	and ebx,str
	add ebx,[s+deflate_state.prev]
	mov byte[ebx],al
pop ebx
end if
	mov eax,[s+deflate_state.ins_h]
	shl eax,2
	add eax,[s+deflate_state.head]
	push str
	pop dword[eax]
}

; ===========================================================================
; Initialize the hash table (avoiding 64K overflow for 16 bit systems).
; prev[] will be initialized on the fly.

macro CLEAR_HASH s
{
	mov eax,[s+deflate_state.hash_size]
	dec eax
	shl eax,2
	add eax,[s+deflate_state.head]
	mov dword[eax],NIL
	mov eax,[s+deflate_state.hash_size]
	dec eax
	shl eax,2 ;sizeof(*s.head)
	stdcall zmemzero, [s+deflate_state.head], eax
}

align 4
proc deflateInit, strm:dword, level:dword
	stdcall deflateInit_, [strm], [level], ZLIB_VERSION, sizeof.z_stream
	ret
endp

; =========================================================================
;int (strm, level, version, stream_size)
;    z_streamp strm;
;    int level;
;    const char *version;
;    int stream_size;
align 4
proc deflateInit_, strm:dword, level:dword, version:dword, stream_size:dword
	stdcall deflateInit2_, [strm], [level], Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,\
			Z_DEFAULT_STRATEGY, [version], [stream_size]
	; To do: ignore strm->next_in if we use it as window
	ret
endp

align 4
proc deflateInit2, strm:dword, level:dword, method:dword, windowBits:dword, memLevel:dword, strategy:dword
	stdcall deflateInit2_, [strm],[level],[method],[windowBits],[memLevel],\
		[strategy], ZLIB_VERSION, sizeof.z_stream
	ret
endp

; =========================================================================
;int (strm, level, method, windowBits, memLevel, strategy,
;                  version, stream_size)
;    z_streamp strm;
;    int  level;
;    int  method;
;    int  windowBits;
;    int  memLevel;
;    int  strategy;
;    const char *version;
;    int stream_size;
align 4
proc deflateInit2_ uses ebx ecx edx edi, strm:dword, level:dword, method:dword,\
	windowBits:dword, memLevel:dword, strategy:dword, version:dword, stream_size:dword
locals
	wrap dd 1 ;int
	overlay dd ? ;uint_16p
endl
	; We overlay pending_buf and d_buf+l_buf. This works since the average
	; output size for (length,distance) codes is <= 24 bits.

	mov eax,[version]
	cmp eax,Z_NULL
	je @f
	mov ebx,dword[ZLIB_VERSION]
	cmp dword[eax],ebx
	jne @f
	cmp dword[stream_size],sizeof.z_stream
	je .end0
	@@: ;if (..==0 || ..[0]!=..[0] || ..!=..)
		mov eax,Z_VERSION_ERROR
		jmp .end_f
	.end0:
	mov ebx,[strm]
	cmp ebx,Z_NULL
	jne @f ;if (..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:

	mov dword[ebx+z_stream.msg],Z_NULL
	cmp dword[ebx+z_stream.zalloc],0
	jne @f ;if (..==0)
if Z_SOLO eq 1
		mov eax,Z_STREAM_ERROR
		jmp .end_f
else
		mov dword[ebx+z_stream.zalloc],zcalloc
		mov dword[ebx+z_stream.opaque],0
end if
	@@:
	cmp dword[ebx+z_stream.zfree],0
	jne @f ;if (..==0)
if Z_SOLO eq 1
		mov eax,Z_STREAM_ERROR
		jmp .end_f
else
		mov dword[ebx+z_stream.zfree],zcfree
end if
	@@:

if FASTEST eq 1
	cmp dword[level],0
	je @f ;if (..!=0)
		mov dword[level],1
	@@:
else
	cmp dword[level],Z_DEFAULT_COMPRESSION
	jne @f ;if (..==0)
		mov dword[level],6
	@@:
end if

	cmp dword[windowBits],0
	jge @f ;if (..<0) ;suppress zlib wrapper
		mov dword[wrap],0
		neg dword[windowBits]
		inc dword[windowBits]
		jmp .end1
	@@:
if GZIP eq 1
	cmp dword[windowBits],15
	jle .end1 ;else if (..>15)
		mov dword[wrap],2 ;write gzip wrapper instead
		sub dword[windowBits],16
end if
	.end1:
	cmp dword[memLevel],1
	jl .end2
	cmp dword[memLevel],MAX_MEM_LEVEL
	jg .end2
	cmp dword[method],Z_DEFLATED
	jne .end2
	cmp dword[windowBits],8
	jl .end2
	cmp dword[windowBits],15
	jg .end2
	cmp dword[level],0
	jl .end2
	cmp dword[level],9
	jg .end2
	cmp dword[strategy],0
	jl .end2
	cmp dword[strategy],Z_FIXED
	jle @f
	.end2: ;if (..<.. || ..>.. || ..!=.. || ..<.. || ..>.. || ..<0 || ..>.. || ..<0 || ..>..)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
	cmp dword[windowBits],8
	jne @f ;if (..==..)
		inc dword[windowBits] ;until 256-byte window bug fixed
	@@:
	ZALLOC ebx, 1, sizeof.deflate_state
	;eax = s
	cmp eax,Z_NULL
	jne @f ;if (..==0)
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov edi,eax ;edi = s
	mov [ebx+z_stream.state],edi
	mov [edi+deflate_state.strm],ebx

	mov eax,[wrap]
	mov [edi+deflate_state.wrap],eax
	mov [edi+deflate_state.gzhead],Z_NULL
	mov ecx,[windowBits]
	mov [edi+deflate_state.w_bits],ecx
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.w_size],eax
	dec eax
	mov [edi+deflate_state.w_mask],eax

	mov ecx,[memLevel]
	add ecx,7
	mov [edi+deflate_state.hash_bits],ecx
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.hash_size],eax
	dec eax
	mov [edi+deflate_state.hash_mask],eax
	add ecx,MIN_MATCH-1
	xor edx,edx
	mov eax,ecx
	mov ecx,MIN_MATCH
	div ecx
	mov [edi+deflate_state.hash_shift],eax

	ZALLOC ebx, [edi+deflate_state.w_size], 2 ;2*sizeof(Byte)
	mov [edi+deflate_state.window],eax
	ZALLOC ebx, [edi+deflate_state.w_size], 4 ;sizeof(Pos)
	mov [edi+deflate_state.prev],eax
	ZALLOC ebx, [edi+deflate_state.hash_size], 4 ;sizeof(Pos)
	mov [edi+deflate_state.head],eax

	mov dword[edi+deflate_state.high_water],0 ;nothing written to s->window yet

	mov ecx,[memLevel]
	add ecx,6
	xor eax,eax
	inc eax
	shl eax,cl
	mov [edi+deflate_state.lit_bufsize],eax ;16K elements by default

	ZALLOC ebx, eax, 4 ;sizeof(uint_16)+2
	mov [overlay],eax
	mov [edi+deflate_state.pending_buf],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	imul eax,4 ;sizeof(uint_16)+2
	mov [edi+deflate_state.pending_buf_size],eax

	cmp dword[edi+deflate_state.window],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.prev],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.head],Z_NULL
	je .end3
	cmp dword[edi+deflate_state.pending_buf],Z_NULL
	je .end3
		jmp @f
	.end3: ;if (..==0 || ..==0 || ..==0 || ..==0)
		mov dword[edi+deflate_state.status],FINISH_STATE
		ERR_MSG Z_MEM_ERROR
		mov [ebx+z_stream.msg],eax
		stdcall deflateEnd, ebx
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov eax,[edi+deflate_state.lit_bufsize]
	shr eax,1 ;/=sizeof(uint_16)
	add eax,[overlay]
	mov [edi+deflate_state.d_buf],eax
	mov eax,[edi+deflate_state.lit_bufsize]
	imul eax,3 ;1+sizeof(uint_16)
	add eax,[edi+deflate_state.pending_buf]
	mov [edi+deflate_state.l_buf],eax

	mov eax,[level]
	mov [edi+deflate_state.level],ax
	mov eax,[strategy]
	mov [edi+deflate_state.strategy],ax
	mov eax,[method]
	mov [edi+deflate_state.method],al

	stdcall deflateReset, ebx
.end_f:
zlib_debug 'deflateInit2_ strategy = %d',[strategy]
	ret
endp

; =========================================================================
;int (strm, dictionary, dictLength)
;    z_streamp strm;
;    const Bytef *dictionary;
;    uInt  dictLength;
align 4
proc deflateSetDictionary uses ebx edi, strm:dword, dictionary:dword, dictLength:dword
locals
;    deflate_state *s;
;    uInt str, n;
	wrap dd ? ;int
	avail dd ? ;unsigned
;    z_const unsigned char *next;
endl
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	je @f
	cmp dword[dictionary],Z_NULL
	je @f ;if (..==0 || ..==0 || ..==0)
		jmp .end0
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	
	mov eax,[edi+deflate_state.wrap]
	mov [wrap],eax
;    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
;        return Z_STREAM_ERROR;

	; when using zlib wrappers, compute Adler-32 for provided dictionary
;    if (wrap == 1)
;        strm->adler = adler32(strm->adler, dictionary, dictLength);
;    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */

	; if dictionary would fill window, just replace the history
;    if (dictLength >= s->w_size) {
;        if (wrap == 0) {            /* already empty otherwise */
;            CLEAR_HASH(s);
;            s->strstart = 0;
;            s->block_start = 0L;
;            s->insert = 0;
;        }
;        dictionary += dictLength - s->w_size;  /* use the tail */
;        dictLength = s->w_size;
;    }

	; insert dictionary into window and hash
;    avail = strm->avail_in;
;    next = strm->next_in;
;    strm->avail_in = dictLength;
;    strm->next_in = (z_const Bytef *)dictionary;
;    fill_window(s);
;    while (s->lookahead >= MIN_MATCH) {
;        str = s->strstart;
;        n = s->lookahead - (MIN_MATCH-1);
;        do {
;            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
if FASTEST eq 0
;            s->prev[str & s->w_mask] = s->head[s->ins_h];
end if
;            s->head[s->ins_h] = (Pos)str;
;            str++;
;        } while (--n);
;        s->strstart = str;
;        s->lookahead = MIN_MATCH-1;
;        fill_window(s);
;    }
;    s->strstart += s->lookahead;
;    s->block_start = (long)s->strstart;
;    s->insert = s->lookahead;
;    s->lookahead = 0;
;    s->match_length = s->prev_length = MIN_MATCH-1;
;    s->match_available = 0;
;    strm->next_in = next;
;    strm->avail_in = avail;
;    s->wrap = wrap;
	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
;int (strm)
;    z_streamp strm;
align 4
proc deflateResetKeep uses ebx edi, strm:dword
;    deflate_state *s;

	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	je @f
	cmp dword[ebx+z_stream.zalloc],0
	je @f
	cmp dword[ebx+z_stream.zfree],0
	je @f ;if (..==0 || ..==0 || ..==0 || ..==0)
		jmp .end0
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:

	mov dword[ebx+z_stream.total_out],0
	mov dword[ebx+z_stream.total_in],0
	mov dword[ebx+z_stream.msg],Z_NULL ;use zfree if we ever allocate msg dynamically
	mov word[ebx+z_stream.data_type],Z_UNKNOWN

	mov word[edi+deflate_state.pending],0
	mov eax,[edi+deflate_state.pending_buf]
	mov [edi+deflate_state.pending_out],eax

	cmp dword[edi+deflate_state.wrap],0
	jge @f ;if (..<0)
		neg dword[edi+deflate_state.wrap]
		inc dword[edi+deflate_state.wrap] ;was made negative by deflate(..., Z_FINISH)
	@@:
	mov eax,BUSY_STATE
	cmp dword[edi+deflate_state.wrap],0
	je @f
		mov eax,INIT_STATE
	@@:
	mov dword[edi+deflate_state.status],eax
	stdcall adler32, 0, Z_NULL, 0
if GZIP eq 1
	cmp dword[edi+deflate_state.wrap],2
	jne @f
		stdcall calc_crc32, 0, Z_NULL, 0
	@@:
end if
	mov dword[ebx+z_stream.adler],eax
	mov dword[edi+deflate_state.last_flush],Z_NO_FLUSH

	stdcall _tr_init, edi

	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
;int (strm)
;    z_streamp strm;
align 4
proc deflateReset uses ebx, strm:dword
	mov ebx,[strm]
;zlib_debug 'deflateReset'
	stdcall deflateResetKeep, ebx
	cmp eax,0
	jne @f ;if (..==Z_OK)
		stdcall lm_init, [ebx+z_stream.state]
	@@:
	ret
endp

; =========================================================================
;int (strm, head)
;    z_streamp strm;
;    gz_headerp head;
align 4
proc deflateSetHeader uses ebx, strm:dword, head:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov ebx,[ebx+z_stream.state]
	cmp ebx,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp dword[ebx+deflate_state.wrap],2
	je @f ;if (..!=..) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:
	mov eax,[head]
	mov [ebx+deflate_state.gzhead],eax
	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
;int (strm, pending, bits)
;    unsigned *pending;
;    int *bits;
;    z_streamp strm;
align 4
proc deflatePending uses ebx edi, strm:dword, pending:dword, bits:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state]
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp dword[pending],Z_NULL
	je @f ;if (..!=..)
		mov eax,[pending]
		movzx ebx,word[edi+deflate_state.pending]
		mov [eax],ebx
	@@:
	cmp dword[bits],Z_NULL
	je @f ;if (..!=..)
		mov eax,[bits]
		mov ebx,[edi+deflate_state.bi_valid]
		mov [eax],ebx
	@@:
	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
;int (strm, bits, value)
;    z_streamp strm;
;    int bits;
;    int value;
align 4
proc deflatePrime uses ebx edi, strm:dword, bits:dword, value:dword
;    int put;

	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
;    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
;        return Z_BUF_ERROR;
;    do {
;        put = Buf_size - s->bi_valid;
;        if (put > bits)
;            put = bits;
;        s->bi_buf |= (uint_16)((value & ((1 << put) - 1)) << s->bi_valid);
;        s->bi_valid += put;
;        _tr_flush_bits(s);
;        value >>= put;
;        bits -= put;
;    } while (bits);
	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
;int (strm, level, strategy)
;    z_streamp strm;
;    int level;
;    int strategy;
align 4
proc deflateParams uses ebx edi, strm:dword, level:dword, strategy:dword
;    compress_func func;
;    int err = Z_OK;

	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:

if FASTEST eq 1
	cmp dword[level],0
	je @f ;if (..!=0)
		mov dword[level],1
	@@:
else
	cmp dword[level],Z_DEFAULT_COMPRESSION
	jne @f ;if (..==0)
		mov dword[level],6
	@@:
end if
;    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
;        return Z_STREAM_ERROR;
;    }
;    func = configuration_table[s->level].func;

;    if ((strategy != s->strategy || func != configuration_table[level].func) &&
;        strm->total_in != 0) {
	; Flush the last buffer:
;        err = deflate(strm, Z_BLOCK);
;        if (err == Z_BUF_ERROR && s->pending == 0)
;            err = Z_OK;
;    }
;    if (s->level != level) {
;        s->level = level;
;        s->max_lazy_match   = configuration_table[level].max_lazy;
;        s->good_match       = configuration_table[level].good_length;
;        s->nice_match       = configuration_table[level].nice_length;
;        s->max_chain_length = configuration_table[level].max_chain;
;    }
;    s->strategy = strategy;
;    return err;
.end_f:
	ret
endp

; =========================================================================
;int (strm, good_length, max_lazy, nice_length, max_chain)
;    z_streamp strm;
;    int good_length;
;    int max_lazy;
;    int nice_length;
;    int max_chain;
align 4
proc deflateTune uses ebx, strm:dword, good_length:dword, max_lazy:dword,\
			nice_length:dword, max_chain:dword
	mov ebx,[strm]
	cmp ebx,Z_NULL
	je @f
	cmp dword[ebx+z_stream.state],Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:
	mov ebx,[ebx+z_stream.state] ;s = strm.state
	mov eax,[good_length]
	mov [ebx+deflate_state.good_match],eax
	mov eax,[max_lazy]
	mov [ebx+deflate_state.max_lazy_match],eax
	mov eax,[nice_length]
	mov [ebx+deflate_state.nice_match],eax
	mov eax,[max_chain]
	mov [ebx+deflate_state.max_chain_length],eax
	mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
; For the default windowBits of 15 and memLevel of 8, this function returns
; a close to exact, as well as small, upper bound on the compressed size.
; They are coded as constants here for a reason--if the #define's are
; changed, then this function needs to be changed as well.  The return
; value for 15 and 8 only works for those exact settings.

; For any setting other than those defaults for windowBits and memLevel,
; the value returned is a conservative worst case for the maximum expansion
; resulting from using fixed blocks instead of stored blocks, which deflate
; can emit on compressed data for some combinations of the parameters.

; This function could be more sophisticated to provide closer upper bounds for
; every combination of windowBits and memLevel.  But even the conservative
; upper bound of about 14% expansion does not seem onerous for output buffer
; allocation.

;uLong (strm, sourceLen)
;    z_streamp strm;
;    uLong sourceLen;
align 4
proc deflateBound, strm:dword, sourceLen:dword
;    deflate_state *s;
;    uLong complen, wraplen;
;    Bytef *str;
;zlib_debug 'deflateBound'

	; conservative upper bound for compressed data
;    complen = sourceLen +
;              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;

	; if can't get parameters, return conservative bound plus zlib wrapper
;    if (strm == Z_NULL || strm->state == Z_NULL)
;        return complen + 6;

	; compute wrapper length
;    s = strm->state;
;    switch (s->wrap) {
;    case 0:                                 /* raw deflate */
;        wraplen = 0;
;        break;
;    case 1:                                 /* zlib wrapper */
;        wraplen = 6 + (s->strstart ? 4 : 0);
;        break;
;    case 2:                                 /* gzip wrapper */
;        wraplen = 18;
;        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
;            if (s->gzhead->extra != Z_NULL)
;                wraplen += 2 + s->gzhead->extra_len;
;            str = s->gzhead->name;
;            if (str != Z_NULL)
;                do {
;                    wraplen++;
;                } while (*str++);
;            str = s->gzhead->comment;
;            if (str != Z_NULL)
;                do {
;                    wraplen++;
;                } while (*str++);
;            if (s->gzhead->hcrc)
;                wraplen += 2;
;        }
;        break;
;    default:                                /* for compiler happiness */
;        wraplen = 6;
;    }

	; if not default parameters, return conservative bound
;    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
;        return complen + wraplen;

	; default settings: return tight bound for that case
;    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
;           (sourceLen >> 25) + 13 - 6 + wraplen;
.end_f:
	ret
endp

; =========================================================================
; Put a short in the pending buffer. The 16-bit value is put in MSB order.
; IN assertion: the stream state is correct and there is enough room in
; pending_buf.

;void (s, b)
;    deflate_state *s;
;    uInt b;
align 4
proc putShortMSB uses ebx ecx, s:dword, b:dword
	mov ebx,[s]
	mov ecx,[b]
	put_byte ebx, ch
	put_byte ebx, cl
	ret
endp

; =========================================================================
; Flush as much pending output as possible. All deflate() output goes
; through this function so some applications may wish to modify it
; to avoid allocating a large strm->next_out buffer and copying into it.
; (See also read_buf()).

;void (strm)
;    z_streamp strm;
align 4
proc flush_pending uses eax ebx ecx edx, strm:dword
;ecx - len
;edx - deflate_state *s
;ebx - strm
;zlib_debug 'flush_pending'
	mov ebx,[strm]
	mov edx,[ebx+z_stream.state]

	stdcall _tr_flush_bits, edx
	movzx ecx,word[edx+deflate_state.pending]
	cmp cx,[ebx+z_stream.avail_out]
	jle @f ;if (..>..)
		movzx ecx,word[ebx+z_stream.avail_out]
	@@:
	cmp ecx,0
	je @f

	stdcall zmemcpy, [ebx+z_stream.next_out], [edx+deflate_state.pending_out], ecx
	add [ebx+z_stream.next_out],ecx
	add [edx+deflate_state.pending_out],ecx
	add [ebx+z_stream.total_out],ecx
	sub [ebx+z_stream.avail_out],cx
	sub [edx+deflate_state.pending],cx
	cmp word[edx+deflate_state.pending],0
	jne @f ;if (..==0)
		mov eax,[edx+deflate_state.pending_buf]
		mov [edx+deflate_state.pending_out],eax
	@@:
	ret
endp

; =========================================================================
;int (strm, flush)
;    z_streamp strm;
;    int flush;
align 4
proc deflate uses ebx ecx edx edi esi, strm:dword, flush:dword
locals
	old_flush dd ? ;int ;value of flush param for previous deflate call
	val dd ?
endl
	mov ebx,[strm]
zlib_debug 'deflate strm = %d',ebx
	cmp ebx,Z_NULL
	je @f
	mov edi,[ebx+z_stream.state] ;s = strm.state
	cmp edi,Z_NULL
	je @f
	cmp dword[flush],Z_BLOCK
	jg @f
	cmp dword[flush],0
	jl @f ;if (..==0 || ..==0 || ..>.. || ..<0)
		jmp .end10
	@@:
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end10:
	cmp dword[ebx+z_stream.next_out],Z_NULL
	je .beg0
	cmp dword[ebx+z_stream.next_in],Z_NULL
	jne @f
	cmp word[ebx+z_stream.avail_in],0
	jne .beg0
	@@:
	cmp dword[edi+deflate_state.status],FINISH_STATE
	jne .end0
	cmp dword[flush],Z_FINISH
	je .end0
	.beg0: ;if (..==0 || (..==0 && ..!=0) || (..=.. && ..!=..))
		ERR_RETURN ebx, Z_STREAM_ERROR
		jmp .end_f
	.end0:
	cmp word[ebx+z_stream.avail_out],0
	jne @f ;if (..==0)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:

	mov dword[edi+deflate_state.strm],ebx ;just in case
	mov eax,[edi+deflate_state.last_flush]
	mov [old_flush],eax
	mov eax,[flush]
	mov [edi+deflate_state.last_flush],eax

	; Write the header
	cmp dword[edi+deflate_state.status],INIT_STATE
	jne .end2 ;if (..==..)
if GZIP eq 1
		cmp dword[edi+deflate_state.wrap],2
		jne .end1 ;if (..==..)
			stdcall calc_crc32, 0, Z_NULL, 0
			mov [ebx+z_stream.adler],eax
			put_byte edi, 31
			put_byte edi, 139
			put_byte edi, 8
			cmp dword[edi+deflate_state.gzhead],Z_NULL
			jne .end3 ;if (..==0)
				put_byte edi, 0
				put_dword edi, 0
				xor cl,cl
				cmp word[edi+deflate_state.level],2
				jge @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
				jl @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.level],9
				jne @f
					mov cl,2
				@@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
				put_byte edi, cl
				put_byte edi, OS_CODE
				mov dword[edi+deflate_state.status],BUSY_STATE
				jmp .end2
			.end3: ;else
				mov edx,[edi+deflate_state.gzhead]
				xor cl,cl
				cmp [edx+gz_header.text],0
				je @f
					inc cl
				@@:
				cmp [edx+gz_header.hcrc],0
				je @f
					add cl,2
				@@:
				cmp [edx+gz_header.extra],Z_NULL
				je @f
					add cl,4
				@@:
				cmp [edx+gz_header.name],Z_NULL
				je @f
					add cl,8
				@@:
				cmp [edx+gz_header.comment],Z_NULL
				je @f
					add cl,16
				@@:
				put_byte edi, cl
				mov ecx,[edx+gz_header.time]
				put_dword edi, ecx
				xor cl,cl
				cmp word[edi+deflate_state.level],2
				jge @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
				jl @f
					mov cl,4
				@@:
				cmp word[edi+deflate_state.level],9
				jne @f
					mov cl,2
				@@: ;..==.. ? 2 : (..>=.. || ..<.. ? 4 : 0)
				put_byte edi, cl
				mov ecx,[edx+gz_header.os]
				put_byte edi, cl
				cmp dword[edx+gz_header.extra],Z_NULL
				je @f ;if (..!=0)
					mov ecx,[edx+gz_header.extra_len]
					put_byte edi, cl
					put_byte edi, ch
				@@:
				cmp dword[edx+gz_header.hcrc],0
				je @f ;if (..)
					movzx eax,word[edi+deflate_state.pending]
					stdcall calc_crc32, [ebx+z_stream.adler],\
						[edi+deflate_state.pending_buf], eax
					mov [ebx+z_stream.adler],eax
				@@:
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],EXTRA_STATE
			jmp .end2
		.end1: ;else
end if
			mov edx,[edi+deflate_state.w_bits]
			sub edx,8
			shl edx,4
			add edx,Z_DEFLATED
			shl edx,8 ;edx = header
			;esi = level_flags

			mov esi,3
			cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
			jl @f
			cmp word[edi+deflate_state.level],2
			jge @f ;if (..>=.. || ..<..)
				xor esi,esi
				jmp .end4
			@@:
			cmp word[edi+deflate_state.level],6
			jge @f ;else if (..<..)
				mov esi,1
				jmp .end4
			@@:
			;;cmp word[edi+deflate_state.level],6
			jne .end4 ;else if (..==..)
				mov esi,2
			.end4:
			shl esi,6
			or edx,esi
			cmp dword[edi+deflate_state.strstart],0
			je @f ;if (..!=0)
				or edx,PRESET_DICT
			@@:
			mov esi,edx
			mov eax,edx
			xor edx,edx
			mov ecx,31
			div ecx
			add esi,31
			sub esi,edx ;esi = header

			mov dword[edi+deflate_state.status],BUSY_STATE
			stdcall putShortMSB, edi, esi

			; Save the adler32 of the preset dictionary:
			cmp dword[edi+deflate_state.strstart],0
			je @f ;if (..!=0)
				mov ecx,[ebx+z_stream.adler]
				bswap ecx
				put_dword edi, ecx
			@@:
			stdcall calc_crc32, 0, Z_NULL, 0
			mov [ebx+z_stream.adler],eax
	.end2:
if GZIP eq 1
	mov edx,[edi+deflate_state.gzhead]
	cmp dword[edi+deflate_state.status],EXTRA_STATE
	jne .end5 ;if (..==..)
		cmp dword[edx+gz_header.extra],Z_NULL
		je .end21 ;if (..!=..)
			movzx esi,word[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc

			movzx ecx,word[edx+gz_header.extra_len]
			.cycle0: ;while (..<..)
			cmp dword[edi+deflate_state.gzindex],ecx
			jge .cycle0end
				movzx eax,word[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end24 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],si
					jle @f ;if (.. && ..>..)
						movzx ecx,word[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					movzx esi,word[edi+deflate_state.pending]
					cmp esi,[edi+deflate_state.pending_buf_size]
					je .cycle0end ;if (..==..) break
				.end24:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.extra]
					mov bl,[ebx]
					put_byte edi, bl
				pop ebx
				inc dword[edi+deflate_state.gzindex]
				jmp .cycle0
			.cycle0end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],si
			jle @f ;if (.. && ..>..)
				movzx ecx,word[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			mov eax,[edx+gz_header.extra_len]
			cmp dword[edi+deflate_state.gzindex],eax
			jne .end5 ;if (..==..)
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],NAME_STATE
			jmp .end5
		.end21: ;else
			mov dword[edi+deflate_state.status],NAME_STATE
	.end5:
	cmp dword[edi+deflate_state.status],NAME_STATE
	jne .end6 ;if (..==..)
		cmp dword[edx+gz_header.name],Z_NULL
		je .end22 ;if (..!=..)
			movzx esi,word[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc

			.cycle1: ;do
				movzx eax,word[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end25 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],si
					jle @f ;if (.. && ..>..)
						movzx ecx,word[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					movzx esi,word[edi+deflate_state.pending]
					movzx eax,word[edi+deflate_state.pending]
					cmp eax,[edi+deflate_state.pending_buf_size]
					jne .end25 ;if (..==..)
						mov dword[val],1
						jmp .cycle1end
				.end25:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.name]
					movzx ebx,byte[ebx]
					mov [val],ebx
					inc dword[edi+deflate_state.gzindex]
					put_byte edi, bl
				pop ebx
				cmp dword[val],0
				jne .cycle1 ;while (val != 0)
			.cycle1end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],si
			jle @f ;if (.. && ..>..)
				movzx ecx,word[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			cmp dword[val],0
			jne .end6 ;if (val == 0)
				mov dword[edi+deflate_state.gzindex],0
				mov dword[edi+deflate_state.status],COMMENT_STATE
			jmp .end6
		.end22: ;else
			mov dword[edi+deflate_state.status],COMMENT_STATE;
	.end6:
	cmp dword[edi+deflate_state.status],COMMENT_STATE
	jne .end7 ;if (..==..)
		cmp dword[edx+gz_header.comment],Z_NULL
		je .end23 ;if (..!=..)
			movzx esi,word[edi+deflate_state.pending]
			;esi = beg ;start of bytes to update crc

			.cycle2: ;do
				movzx eax,word[edi+deflate_state.pending]
				cmp eax,[edi+deflate_state.pending_buf_size]
				jne .end26 ;if (..==..)
					mov dword[edx+gz_header.hcrc],0
					je @f
					cmp [edi+deflate_state.pending],si
					jle @f ;if (.. && ..>..)
						movzx ecx,word[edi+deflate_state.pending]
						sub ecx,esi
						mov eax,[edi+deflate_state.pending_buf]
						add eax,esi
						stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
						mov [ebx+z_stream.adler],eax
					@@:
					stdcall flush_pending, ebx
					movzx esi,word[edi+deflate_state.pending]
					movzx eax,word[edi+deflate_state.pending]
					cmp eax,[edi+deflate_state.pending_buf_size]
					jne .end26 ;if (..==..)
						mov dword[val],1
						jmp .cycle2end
				.end26:
				push ebx
					mov ebx,[edi+deflate_state.gzindex]
					add ebx,[edx+gz_header.comment]
					movzx ebx,byte[ebx]
					mov [val],ebx
					inc dword[edi+deflate_state.gzindex]
					put_byte edi, bl
				pop ebx
				cmp dword[val],0
				jne .cycle2 ;while (val != 0)
			.cycle2end:
			mov dword[edx+gz_header.hcrc],0
			je @f
			cmp [edi+deflate_state.pending],si
			jle @f ;if (.. && ..>..)
				movzx ecx,word[edi+deflate_state.pending]
				sub ecx,esi
				mov eax,[edi+deflate_state.pending_buf]
				add eax,esi
				stdcall calc_crc32, [ebx+z_stream.adler], eax, ecx
				mov [ebx+z_stream.adler],eax
			@@:
			cmp dword[val],0
			jne .end7 ;if (val == 0)
				mov dword[edi+deflate_state.status],HCRC_STATE
			jmp .end7
		.end23: ;else
			mov dword[edi+deflate_state.status],HCRC_STATE
	.end7:
	cmp dword[edi+deflate_state.status],HCRC_STATE
	jne .end8 ;if (..==..)
		cmp dword[edx+gz_header.hcrc],0
		je .end9 ;if (..)
			movzx ecx,word[edi+deflate_state.pending]
			add ecx,2
			cmp ecx,[edi+deflate_state.pending_buf_size]
			jle @f ;if (..>..)
				stdcall flush_pending, ebx
			@@:
			movzx ecx,word[edi+deflate_state.pending]
			add ecx,2
			cmp ecx,[edi+deflate_state.pending_buf_size]
			jg @f ;if (..<=..)
				mov ecx,[ebx+z_stream.adler]
				put_byte edi, cl
				put_byte edi, ch
				stdcall calc_crc32, 0, Z_NULL, 0
				mov [ebx+z_stream.adler],eax
				mov dword[edi+deflate_state.status],BUSY_STATE
			@@:
			jmp .end8
		.end9: ;else
			mov dword[edi+deflate_state.status],BUSY_STATE
	.end8:
end if

	; Flush as much pending output as possible
	cmp word[edi+deflate_state.pending],0
	je .end13 ;if (..!=0)
		stdcall flush_pending, ebx
		cmp word[ebx+z_stream.avail_out],0
		jne @f ;if (..==0)
			; Since avail_out is 0, deflate will be called again with
			; more output space, but possibly with both pending and
			; avail_in equal to zero. There won't be anything to do,
			; but this is not an error situation so make sure we
			; return OK instead of BUF_ERROR at next call of deflate:

			mov dword[edi+deflate_state.last_flush],-1
			mov eax,Z_OK
			jmp .end_f
		@@:
		; Make sure there is something to do and avoid duplicate consecutive
		; flushes. For repeated and useless calls with Z_FINISH, we keep
		; returning Z_STREAM_END instead of Z_BUF_ERROR.
		jmp @f
	.end13:
	cmp word[ebx+z_stream.avail_in],0
	jne @f
	RANK dword[old_flush],esi
	RANK dword[flush],eax
	cmp eax,esi
	jg @f
	cmp dword[flush],Z_FINISH
	je @f ;else if (..==0 && ..<=.. && ..!=..)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:

	; User must not provide more input after the first FINISH:
	cmp dword[edi+deflate_state.status],FINISH_STATE
	jne @f
	cmp word[ebx+z_stream.avail_in],0
	je @f ;if (..==.. && ..!=0)
		ERR_RETURN ebx, Z_BUF_ERROR
		jmp .end_f
	@@:

	; Start a new block or continue the current one.

	cmp word[ebx+z_stream.avail_in],0
	jne @f
	cmp dword[edi+deflate_state.lookahead],0
	jne @f
	cmp dword[flush],Z_NO_FLUSH
	je .end11
	cmp dword[edi+deflate_state.status],FINISH_STATE
	je .end11
	@@: ;if (..!=0 || ..!=0 || (..!=.. && ..!=..))
		;edx = bstate
		cmp word[edi+deflate_state.strategy],Z_HUFFMAN_ONLY
		jne @f
			stdcall deflate_huff, edi, [flush]
			jmp .end20
		@@:
		cmp word[edi+deflate_state.strategy],Z_RLE
		jne @f
			stdcall deflate_rle, edi, [flush]
			jmp .end20
		@@:
		movzx eax,word[edi+deflate_state.level]
		imul eax,sizeof.config_s
		add eax,configuration_table+config_s.co_func
		stdcall dword[eax], edi, [flush]
		.end20:
		mov edx,eax

		cmp edx,finish_started
		je @f
		cmp edx,finish_done
		je @f
			jmp .end18
		@@: ;if (..==.. || ..==..)
			mov dword[edi+deflate_state.status],FINISH_STATE
		.end18:
		cmp edx,need_more
		je @f
		cmp edx,finish_started
		je @f
			jmp .end19
		@@: ;if (..==.. || ..==..)
			cmp word[ebx+z_stream.avail_out],0
			jne @f ;if (..==0)
				mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR next call, see above
			@@:
			mov eax,Z_OK
			jmp .end_f
			; If flush != Z_NO_FLUSH && avail_out == 0, the next call
			; of deflate should use the same flush parameter to make sure
			; that the flush is complete. So we don't have to output an
			; empty block here, this will be done at next call. This also
			; ensures that for a very small output buffer, we emit at most
			; one empty block.

		.end19:
		cmp edx,block_done
		jne .end11 ;if (..==..)
			cmp dword[flush],Z_PARTIAL_FLUSH
			jne @f ;if (..==..)
				stdcall _tr_align, edi
				jmp .end16
			@@:
			cmp dword[flush],Z_BLOCK
			je .end16 ;else if (..!=..) ;FULL_FLUSH or SYNC_FLUSH
				stdcall _tr_stored_block, edi, 0, 0, 0
				; For a full flush, this empty block will be recognized
				; as a special marker by inflate_sync().

			cmp dword[flush],Z_FULL_FLUSH
			jne .end16 ;if (..==..)
				CLEAR_HASH edi ;forget history
				cmp dword[edi+deflate_state.lookahead],0
				jne .end16 ;if (..==0)
					mov dword[edi+deflate_state.strstart],0
					mov dword[edi+deflate_state.block_start],0
					mov dword[edi+deflate_state.insert],0
		.end16:
		stdcall flush_pending, ebx
		cmp word[ebx+z_stream.avail_out],0
		jne .end11 ;if (..==0)
			mov dword[edi+deflate_state.last_flush],-1 ;avoid BUF_ERROR at next call, see above
			mov eax,Z_OK
			jmp .end_f
	.end11:
	cmp word[ebx+z_stream.avail_out],0
	jg @f
		zlib_debug 'bug2' ;Assert(..>0)
	@@:

	cmp dword[flush],Z_FINISH
	je @f ;if (..!=0)
		mov eax,Z_OK
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.wrap],0
	jg @f ;if (..<=0)
		mov eax,Z_STREAM_END
		jmp .end_f
	@@:

	; Write the trailer
if GZIP eq 1
	cmp dword[edi+deflate_state.wrap],2
	jne @f ;if (..==..)
		mov ecx,[ebx+z_stream.adler]
		put_dword edi, ecx
		mov ecx,[ebx+z_stream.total_in]
		put_dword edi, ecx
		jmp .end17
	@@: ;else
end if
		mov ecx,[ebx+z_stream.adler]
		bswap ecx
		put_dword edi, ecx
	.end17:
	stdcall flush_pending, ebx
	; If avail_out is zero, the application will call deflate again
	; to flush the rest.

	cmp word[edi+deflate_state.pending],0
	jle @f ;if (..>0) ;write the trailer only once!
		neg word[edi+deflate_state.pending]
		inc word[edi+deflate_state.pending]
	@@:
	mov eax,Z_OK
	cmp word[edi+deflate_state.pending],0
	je .end_f
		mov eax,Z_STREAM_END
.end_f:
zlib_debug '  deflate.ret = %d',eax
	ret
endp

; =========================================================================
;int (strm)
;    z_streamp strm;
align 4
proc deflateEnd uses ebx ecx edx, strm:dword
	mov ebx,[strm]
zlib_debug 'deflateEnd'
	cmp ebx,Z_NULL
	je @f
	mov edx,[ebx+z_stream.state]
	cmp edx,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0) return ..
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:

	mov ecx,[edx+deflate_state.status]
	cmp ecx,INIT_STATE
	je @f
	cmp ecx,EXTRA_STATE
	je @f
	cmp ecx,NAME_STATE
	je @f
	cmp ecx,COMMENT_STATE
	je @f
	cmp ecx,HCRC_STATE
	je @f
	cmp ecx,BUSY_STATE
	je @f
	cmp ecx,FINISH_STATE
	je @f ;if (..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=.. && ..!=..)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	@@:

	; Deallocate in reverse order of allocations:
	TRY_FREE ebx, dword[edx+deflate_state.pending_buf]
	TRY_FREE ebx, dword[edx+deflate_state.head]
	TRY_FREE ebx, dword[edx+deflate_state.prev]
	TRY_FREE ebx, dword[edx+deflate_state.window]

	ZFREE ebx, dword[ebx+z_stream.state]
	mov dword[ebx+z_stream.state],Z_NULL

	mov eax,Z_DATA_ERROR
	cmp ecx,BUSY_STATE
	je .end_f
		mov eax,Z_OK
.end_f:
	ret
endp

; =========================================================================
; Copy the source state to the destination state.
; To simplify the source, this is not supported for 16-bit MSDOS (which
; doesn't have enough memory anyway to duplicate compression states).

;int (dest, source)
;    z_streamp dest;
;    z_streamp source;
align 4
proc deflateCopy uses edx edi esi, dest:dword, source:dword
locals
	overlay dd ? ;uint_16p
endl
;edi = ds; deflate_state*
;esi = ss; deflate_state*

	mov esi,[source]
	cmp esi,Z_NULL
	je @f
	mov edx,[dest]
	cmp edx,Z_NULL
	je @f
	mov esi,[esi+z_stream.state]
	cmp esi,Z_NULL
	jne .end0
	@@: ;if (..==0 || ..==0 || ..==0)
		mov eax,Z_STREAM_ERROR
		jmp .end_f
	.end0:

	stdcall zmemcpy, edx, [source], sizeof.z_stream

	ZALLOC edx, 1, sizeof.deflate_state
	cmp eax,0
	jne @f ;if (..==0) return ..
		mov eax,Z_MEM_ERROR
		jmp .end_f
	@@:
	mov edi,eax
	mov [edx+z_stream.state],eax
	stdcall zmemcpy, edi, esi, sizeof.deflate_state
	mov dword[edi+deflate_state.strm],edx

	ZALLOC edx, [edi+deflate_state.w_size], 2 ;2*sizeof.db
	mov dword[edi+deflate_state.window],eax
	ZALLOC edx, [edi+deflate_state.w_size], 4 ;sizeof.dd
	mov dword[edi+deflate_state.prev],eax
	ZALLOC edx, [edi+deflate_state.hash_size], 4 ;sizeof.dd
	mov dword[edi+deflate_state.head],eax
	ZALLOC edx, [edi+deflate_state.lit_bufsize], 4 ;sizeof.dw+2
	mov [overlay],eax
	mov dword[edi+deflate_state.pending_buf],eax

	cmp dword[edi+deflate_state.window],Z_NULL
	je @f
	cmp dword[edi+deflate_state.prev],Z_NULL
	je @f
	cmp dword[edi+deflate_state.head],Z_NULL
	je @f
	cmp dword[edi+deflate_state.pending_buf],Z_NULL
	jne .end1
	@@: ;if (..==0 || ..==0 || ..==0 || ..==0)
		stdcall deflateEnd, edx
		mov eax,Z_MEM_ERROR
		jmp .end_f
	.end1:

	; following zmemcpy do not work for 16-bit MSDOS
	mov eax,[edi+deflate_state.w_size]
	shl eax,1 ;*= 2*sizeof.db
	stdcall zmemcpy, [edi+deflate_state.window], [esi+deflate_state.window], eax
;    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
;    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
;    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);

;    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
;    ds->d_buf = overlay + ds->lit_bufsize/sizeof(uint_16);
;    ds->l_buf = ds->pending_buf + (1+sizeof(uint_16))*ds->lit_bufsize;

	mov eax,edi
	add eax,deflate_state.dyn_ltree
	mov [edi+deflate_state.l_desc.dyn_tree],eax
	add eax,deflate_state.dyn_dtree-deflate_state.dyn_ltree
	mov [edi+deflate_state.d_desc.dyn_tree],eax
	add eax,deflate_state.bl_tree-deflate_state.dyn_dtree
	mov [edi+deflate_state.bl_desc.dyn_tree],eax

	mov eax,Z_OK
.end_f:
	ret
endp

; ===========================================================================
; Read a new buffer from the current input stream, update the adler32
; and total number of bytes read.  All deflate() input goes through
; this function so some applications may wish to modify it to avoid
; allocating a large strm->next_in buffer and copying from it.
; (See also flush_pending()).

;int (strm, buf, size)
;    z_streamp strm;
;    Bytef *buf;
;    unsigned size;
align 4
proc read_buf uses ebx ecx, strm:dword, buf:dword, size:dword
	mov ebx,[strm]
	movzx eax,word[ebx+z_stream.avail_in]

	cmp eax,[size]
	jle @f ;if (..>..)
		mov eax,[size]
	@@:
	cmp eax,0
	jg @f
		xor eax,eax
		jmp .end_f ;if (..==0) return 0
	@@:

	sub [ebx+z_stream.avail_in],ax

	stdcall zmemcpy, [buf],[ebx+z_stream.next_in],eax
	mov ecx,[ebx+z_stream.state]
	cmp [ecx+deflate_state.wrap],1
	jne @f ;if (..==..)
		push eax
		stdcall adler32, [ebx+z_stream.adler], [buf], eax
		mov [ebx+z_stream.adler],eax
		pop eax
		jmp .end0
	@@:
if GZIP eq 1
	cmp [ecx+deflate_state.wrap],2
	jne .end0 ;else if (..==..)
		push eax
		stdcall calc_crc32, [ebx+z_stream.adler], [buf], eax
		mov [ebx+z_stream.adler],eax
		pop eax
end if
	.end0:
	add [ebx+z_stream.next_in],eax
	add [ebx+z_stream.total_in],eax

.end_f:
;zlib_debug '  read_buf.ret = %d',eax
	ret
endp

; ===========================================================================
; Initialize the "longest match" routines for a new zlib stream

;void (s)
;    deflate_state *s
align 4
proc lm_init uses eax ebx edi, s:dword
	mov edi,[s]
	mov eax,[edi+deflate_state.w_size]
	shl eax,1
	mov [edi+deflate_state.window_size],eax

	CLEAR_HASH edi

	; Set the default configuration parameters:

	movzx eax,word[edi+deflate_state.level]
	imul eax,sizeof.config_s
	add eax,configuration_table
	movzx ebx,word[eax+config_s.max_lazy]
	mov [edi+deflate_state.max_lazy_match],ebx
	movzx ebx,word[eax+config_s.good_length]
	mov [edi+deflate_state.good_match],ebx
	movzx ebx,word[eax+config_s.nice_length]
	mov [edi+deflate_state.nice_match],ebx
	movzx ebx,word[eax+config_s.max_chain]
	mov [edi+deflate_state.max_chain_length],ebx

	mov dword[edi+deflate_state.strstart],0
	mov dword[edi+deflate_state.block_start],0
	mov dword[edi+deflate_state.lookahead],0
	mov dword[edi+deflate_state.insert],0
	mov dword[edi+deflate_state.prev_length],MIN_MATCH-1
	mov dword[edi+deflate_state.match_length],MIN_MATCH-1
	mov dword[edi+deflate_state.match_available],0
	mov dword[edi+deflate_state.ins_h],0
if FASTEST eq 0
;if ASMV
;    call match_init ;initialize the asm code
;end if
end if
	ret
endp

;uInt (s, cur_match)
;    deflate_state *s;
;    IPos cur_match;                             /* current match */
align 4
proc longest_match uses ebx ecx edx edi esi, s:dword, cur_match:dword
if FASTEST eq 0
; ===========================================================================
; Set match_start to the longest match starting at the given string and
; return its length. Matches shorter or equal to prev_length are discarded,
; in which case the result is equal to prev_length and match_start is
; garbage.
; IN assertions: cur_match is the head of the hash chain for the current
;   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
; OUT assertion: the match length is not greater than s->lookahead.

;#ifndef ASMV
; For 80x86 and 680x0, an optimized version will be provided in match.asm or
; match.S. The code will be functionally equivalent.

;    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;

if UNALIGNED_OK eq 1
	; 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 uint_16 scan_start = *(uint_16p*)scan;
;    register uint_16 scan_end   = *(uint_16p*)(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];
end if

	; 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.  Note that the checks below
	; for insufficient lookahead only occur occasionally for performance
	; reasons.  Therefore uninitialized memory will be accessed, and
	; conditional jumps will be made that depend on those values.
	; However the length of the match is limited to the lookahead, so
	; the output of deflate is not affected by the uninitialized values.

if ((UNALIGNED_OK eq 1) & MAX_MATCH == 258)
	; This code assumes sizeof(unsigned short) == 2. Do not use
	; UNALIGNED_OK if your compiler uses a different size.

;        if (*(uint_16p*)(match+best_len-1) != scan_end ||
;            *(uint_16p*)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 (*(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(match+=2) &&
;                 *(uint_16p*)(scan+=2) == *(uint_16p*)(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;

end if ;UNALIGNED_OK

;        if (len > best_len) {
;            s->match_start = cur_match;
;            best_len = len;
;            if (len >= nice_match) break;
if UNALIGNED_OK eq 1
;            scan_end = *(uint_16p*)(scan+best_len-1);
else
;            scan_end1  = scan[best_len-1];
;            scan_end   = scan[best_len];
end if
;        }
;    } while ((cur_match = prev[cur_match & wmask]) > limit
;             && --chain_length != 0);

;    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
;    return s->lookahead;
;end if /* ASMV */

else ;FASTEST

; ---------------------------------------------------------------------------
; Optimized version for FASTEST only
	mov edx,[s]
;zlib_debug 'longest_match'

	; 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.

if MAX_MATCH <> 258
	cmp dword[edx+deflate_state.hash_bits],8
	jge @f
		zlib_debug 'Code too clever' ;Assert(..>=.. && ..==..)
	@@:
end if
	mov eax,[edx+deflate_state.window_size]
	sub eax,MIN_LOOKAHEAD
	cmp [edx+deflate_state.strstart],eax
	jle @f
		zlib_debug 'need lookahead' ;Assert(..<=..)
	@@:
	mov eax,[edx+deflate_state.strstart]
	cmp [cur_match],eax
	jl @f
		zlib_debug 'no future' ;Assert(..<..)
	@@:

	mov esi,[edx+deflate_state.window]
	mov edi,esi
	add esi,[cur_match]
	add edi,[edx+deflate_state.strstart]
	;edi = scan
	;esi = match

	; Return failure if the match length is less than 2:

	lodsw
	cmp ax,word[edi]
	je @f ;if (word[edi] != word[esi]) return 
		mov eax,MIN_MATCH-1
		jmp .end_f
	@@:

	; 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.

	add edi,2
	mov al,byte[edi]
	cmp al,byte[esi]
	je @f
		zlib_debug 'match[2]?' ;Assert(..==..)
	@@:

	; We check for insufficient lookahead only every 8th comparison;
	; the 256th check will be made at strstart+258.

	mov ebx,edi
	mov ecx,MAX_MATCH
align 4
	@@:
		lodsb
		scasb
		loope @b

	mov eax,[edx+deflate_state.window_size]
	dec eax
	add eax,[edx+deflate_state.window]
	cmp edi,eax
	jle @f
		zlib_debug 'wild scan' ;Assert(..<=..)
	@@:
	sub edi,ebx
	;edi = len

	cmp edi,MIN_MATCH
	jge @f ;if (..<..) 
		mov eax,MIN_MATCH-1
		jmp .end_f
	@@:
	mov eax,[cur_match]
	mov [edx+deflate_state.match_start],eax
	mov eax,[edx+deflate_state.lookahead]
	cmp edi,eax
	jg @f ;if (len <= s.lookahead) ? len : s.lookahead
		mov eax,edi
	@@:
end if ;FASTEST
.end_f:
;zlib_debug '  longest_match.ret = %d',eax
	ret
endp


; ===========================================================================
; Check that the match at match_start is indeed a match.

;void (s, start, match, length)
;    deflate_state *s;
;    IPos start, match;
;    int length;
align 4
proc check_match, s:dword, start:dword, p3match:dword, length:dword
if DEBUG eq 1
	; check that the match is indeed a match
;    if (zmemcmp(s->window + match,
;                s->window + start, length) != EQUAL) {
;        fprintf(stderr, " start %u, match %u, length %d\n",
;                start, match, length);
;        do {
;            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
;        } while (--length != 0);
;        z_error("invalid match");
;    }
;    if (z_verbose > 1) {
;        fprintf(stderr,"\\[%d,%d]", start-match, length);
;        do { putc(s->window[start++], stderr); } while (--length != 0);
;    }
end if ;DEBUG
	ret
endp


; ===========================================================================
; Fill the window when the lookahead becomes insufficient.
; Updates strstart and lookahead.

; IN assertion: lookahead < MIN_LOOKAHEAD
; OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
;    At least one byte has been read, or avail_in == 0; reads are
;    performed for at least two bytes (required for the zip translate_eol
;    option -- not supported here).

;void (s)
;    deflate_state *s
align 4
proc fill_window, s:dword
pushad
;esi = p, str, curr
;ebx = more ;Amount of free space at the end of the window.
	;Объем свободного пространства в конце окна.
;ecx = wsize ;uInt
;edx = s.strm
;zlib_debug 'fill_window'
	mov edi,[s]
	cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
	jl @f
		zlib_debug 'already enough lookahead' ;Assert(..<..)
	@@:

	mov ecx,[edi+deflate_state.w_size]
	mov edx,[edi+deflate_state.strm]
	.cycle0: ;do
;zlib_debug 'do'
		mov ebx,[edi+deflate_state.window_size]
		sub ebx,[edi+deflate_state.lookahead]
		sub ebx,[edi+deflate_state.strstart]

		; If the window is almost full and there is insufficient lookahead,
		; move the upper half to the lower one to make room in the upper half.

		MAX_DIST edi
		add eax,ecx
		cmp [edi+deflate_state.strstart],eax
		jl .end0 ;if (..>=..)
			push ecx
			mov eax,[edi+deflate_state.window]
			add eax,ecx
			stdcall zmemcpy, [edi+deflate_state.window], eax
			sub [edi+deflate_state.match_start],ecx
			sub [edi+deflate_state.strstart],ecx ;we now have strstart >= MAX_DIST
			sub [edi+deflate_state.block_start],ecx

			; Slide the hash table (could be avoided with 32 bit values
			; at the expense of memory usage). We slide even when level == 0
			; to keep the hash table consistent if we switch back to level > 0
			; later. (Using level 0 permanently is not an optimal usage of
			; zlib, so we don't care about this pathological case.)

			push ebx ecx
			;ebx = wsize
			;ecx = n
			mov ebx,ecx
			mov ecx,[edi+deflate_state.hash_size]
			mov esi,ecx
			shl esi,2
			add esi,[edi+deflate_state.head]
			.cycle1: ;do
				sub esi,4
				mov eax,[esi]
				mov dword[esi],NIL
				cmp eax,ebx
				jl @f
					sub eax,ebx
					mov dword[esi],eax
				@@:
			loop .cycle1 ;while (..)

			mov ecx,ebx
if FASTEST eq 0
			mov esi,ecx
			shl esi,2
			add esi,[edi+deflate_state.prev]
			.cycle2: ;do
				sub esi,4
				mov eax,[esi]
				mov dword[esi],NIL
				cmp eax,ebx
				jl @f
					sub eax,ebx
					mov dword[esi],eax
				@@:
				; If n is not on any hash chain, prev[n] is garbage but
				; its value will never be used.

			loop .cycle2 ;while (..)
end if
			pop ecx ebx
			add ebx,ecx
		.end0:
		cmp word[edx+z_stream.avail_in],0
		je .cycle0end ;if (..==0) break

		; If there was no sliding:
		;    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
		;    more == window_size - lookahead - strstart
		; => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
		; => more >= window_size - 2*WSIZE + 2
		; In the BIG_MEM or MMAP case (not yet supported),
		;   window_size == input_size + MIN_LOOKAHEAD  &&
		;   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
		; Otherwise, window_size == 2*WSIZE so more >= 2.
		; If there was sliding, more >= WSIZE. So in all cases, more >= 2.

		cmp ebx,2
		jge @f
			zlib_debug 'more < 2' ;Assert(..>=..)
		@@:
		mov eax,[edi+deflate_state.window]
		add eax,[edi+deflate_state.strstart]
		add eax,[edi+deflate_state.lookahead]
		stdcall read_buf, edx, eax, ebx
		add [edi+deflate_state.lookahead],eax

		; Initialize the hash value now that we have some input:
		mov eax,[edi+deflate_state.lookahead]
		add eax,[edi+deflate_state.insert]
		cmp eax,MIN_MATCH
		jl .end1 ;if (..>=..)
			mov esi,[edi+deflate_state.strstart]
			sub esi,[edi+deflate_state.insert]
			;esi = str
			mov eax,[edi+deflate_state.window]
			add eax,esi
			mov [edi+deflate_state.ins_h],eax
			inc eax
			movzx eax,byte[eax]
            UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if MIN_MATCH <> 3
;            Call UPDATE_HASH() MIN_MATCH-3 more times
end if
			.cycle3: ;while (..)
			cmp dword[edi+deflate_state.insert],0
			je .end1
				mov eax,esi
				add eax,MIN_MATCH-1
				add eax,[edi+deflate_state.window]
				movzx eax,byte[eax]
				UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if FASTEST eq 0
				mov eax,[edi+deflate_state.ins_h]
				shl eax,2
				add eax,[edi+deflate_state.head]
				push ebx
				mov ebx,[edi+deflate_state.w_mask]
				and ebx,esi
				shl ebx,2
				add ebx,[edi+deflate_state.prev]
				mov eax,[eax]
				mov [ebx],eax
				pop ebx
end if
				mov eax,[edi+deflate_state.ins_h]
				shl eax,2
				add eax,[edi+deflate_state.head]
				mov [eax],esi
				inc esi
				dec dword[edi+deflate_state.insert]
				mov eax,[edi+deflate_state.lookahead]
				add eax,[edi+deflate_state.insert]
				cmp eax,MIN_MATCH
				jl .end1 ;if (..<..) break
			jmp .cycle3
		.end1:
		; If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
		; but this is not important since only literal bytes will be emitted.

		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .cycle0end
		cmp word[edx+z_stream.avail_in],0
		jne .cycle0
	.cycle0end: ;while (..<.. && ..!=..)

	; If the WIN_INIT bytes after the end of the current data have never been
	; written, then zero those bytes in order to avoid memory check reports of
	; the use of uninitialized (or uninitialised as Julian writes) bytes by
	; the longest match routines.  Update the high water mark for the next
	; time through here.  WIN_INIT is set to MAX_MATCH since the longest match
	; routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.

	mov eax,[edi+deflate_state.window_size]
	cmp [edi+deflate_state.high_water],eax
	jge .end2 ;if (..<..)
		mov esi,[edi+deflate_state.lookahead]
		add esi,[edi+deflate_state.strstart]
		;esi = curr

		cmp [edi+deflate_state.high_water],esi
		jge .end3 ;if (..<..)
			; Previous high water mark below current data -- zero WIN_INIT
			; bytes or up to end of window, whichever is less.

			mov eax,[edi+deflate_state.window_size]
			sub eax,esi
			cmp eax,WIN_INIT
			jle @f ;if (..>..)
				mov eax,WIN_INIT
			@@:
			mov edx,[edi+deflate_state.window]
			add edx,esi
			stdcall zmemzero, edx, eax
			add eax,esi
			mov [edi+deflate_state.high_water],eax
			jmp .end2
		.end3: ;else if (..<..)
		mov eax,esi
		add eax,WIN_INIT
		cmp [edi+deflate_state.high_water],eax
		jge .end2
			; High water mark at or above current data, but below current data
			; plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
			; to end of window, whichever is less.

			;eax = esi+WIN_INIT
			sub eax,[edi+deflate_state.high_water]
			mov edx,[edi+deflate_state.window_size]
			sub edx,[edi+deflate_state.high_water]
			cmp eax,edx ;if (..>..)
			jle @f
				mov eax,edx
			@@:
			mov edx,[edi+deflate_state.window]
			add edx,[edi+deflate_state.high_water]
			stdcall zmemzero, edx, eax
			add [edi+deflate_state.high_water],eax
	.end2:

	mov eax,[edi+deflate_state.window_size]
	sub eax,MIN_LOOKAHEAD
	cmp [edi+deflate_state.strstart],eax
	jle @f
		zlib_debug 'not enough room for search' ;Assert(..<=..)
	@@:
popad
	ret
endp

; ===========================================================================
; Flush the current block, with given end-of-file flag.
; IN assertion: strstart is set to the end of the current match.

macro FLUSH_BLOCK_ONLY s, last
{
local .end0
	push dword last
	mov eax,[s+deflate_state.strstart]
	sub eax,[s+deflate_state.block_start]
	push eax
	xor eax,eax
	cmp dword[s+deflate_state.block_start],0
	jl .end0
		mov eax,[s+deflate_state.block_start]
		add eax,[s+deflate_state.window]
	.end0:
	stdcall _tr_flush_block, s, eax
	mov eax,[s+deflate_state.strstart]
	mov [s+deflate_state.block_start],eax
	stdcall flush_pending, [s+deflate_state.strm]
;   Tracev((stderr,"[FLUSH]"));
}

; Same but force premature exit if necessary.
macro FLUSH_BLOCK s, last
{
local .end0
	FLUSH_BLOCK_ONLY s, last
	mov eax,[s+deflate_state.strm]
	cmp word[eax+z_stream.avail_out],0
	jne .end0 ;if (..==0)
if last eq 1
		mov eax,finish_started
else
		mov eax,need_more
end if
		jmp .end_f
	.end0:
}

; ===========================================================================
; Copy without compression as much as possible from the input stream, return
; the current block state.
; This function does not insert new strings in the dictionary since
; uncompressible data is probably not useful. This function is used
; only for the level=0 compression option.
; NOTE: this function should be optimized to avoid extra copying from
; window to pending_buf.

;block_state (s, flush)
;    deflate_state *s;
;    int flush;
align 4
proc deflate_stored uses ebx ecx edi, s:dword, flush:dword
; Stored blocks are limited to 0xffff bytes, pending_buf is limited
; to pending_buf_size, and each stored block has a 5 byte header:
	mov edi,[s]
zlib_debug 'deflate_stored'

	mov ecx,0xffff
	mov eax,[edi+deflate_state.pending_buf_size]
	sub eax,5
	cmp ecx,eax
	jle @f ;if (..>..)
		mov ecx,eax
	@@:
	;ecx = max_block_size

	; Copy as much as possible from input to output:
	.cycle0: ;for (;;) {
		; Fill the window as much as possible:
		cmp dword[edi+deflate_state.lookahead],1
		jg .end0 ;if (..<=..)
;            Assert(s->strstart < s->w_size+MAX_DIST(s) ||
;                   s->block_start >= (long)s->w_size, "slide too late");

			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],0
			jne @f
			cmp dword[flush],Z_NO_FLUSH
			jne @f ;if (..==0 && ..==..)
				mov eax,need_more
				jmp .end_f
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
		.end0:
;        Assert(s->block_start >= 0, "block gone");

		mov eax,[edi+deflate_state.lookahead]
		add [edi+deflate_state.strstart],eax
		mov dword[edi+deflate_state.lookahead],0

		; Emit a stored block if pending_buf will be full:
		mov ebx,[edi+deflate_state.block_start]
		add ebx,ecx
		cmp dword[edi+deflate_state.strstart],0
		je @f
		cmp [edi+deflate_state.strstart],ebx
		jl .end1
		@@: ;if (..==0 || ..>=..)
			; strstart == 0 is possible when wraparound on 16-bit machine
			mov eax,[edi+deflate_state.strstart]
			sub eax,ebx
			mov [edi+deflate_state.lookahead],eax
			mov [edi+deflate_state.strstart],ebx
			FLUSH_BLOCK edi, 0
		.end1:
		; Flush if we may have to slide, otherwise block_start may become
		; negative and the data will be gone:

		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,[edi+deflate_state.block_start]
		cmp ebx,eax
		jl .cycle0 ;if (..>=..)
			FLUSH_BLOCK edi, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edi+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	mov eax,[edi+deflate_state.block_start]
	cmp [edi+deflate_state.strstart],eax
	jle @f ;if (..>..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp

; ===========================================================================
; Compress as much as possible from the input stream, return the current
; block state.
; This function does not perform lazy evaluation of matches and inserts
; new strings in the dictionary only for unmatched strings or for short
; matches. It is used only for the fast compression options.

;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_fast uses ebx ecx edi, s:dword, flush:dword
locals
	bflush dd ? ;int  ;set if current block must be flushed
endl
;ecx = hash_head ;IPos ;head of the hash chain
	mov edi,[s]
zlib_debug 'deflate_fast'

	.cycle0: ;for (..)
	; Make sure that we always have enough lookahead, except
	; at the end of the input file. We need MAX_MATCH bytes
	; for the next match, plus MIN_MATCH bytes to insert the
	; string following the next match.

		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .end0 ;if (..<..)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
			jge @f ;if (..<.. && ..==..)
			cmp dword[flush],Z_NO_FLUSH
			jne @f
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
align 4
		.end0:

		; Insert the string window[strstart .. strstart+2] in the
		; dictionary, and set hash_head to the head of the hash chain:

		mov ecx,NIL
		cmp dword[edi+deflate_state.lookahead],MIN_MATCH
		jl @f ;if (..>=..)
			INSERT_STRING edi, [edi+deflate_state.strstart], ecx
		@@:

		; Find the longest match, discarding those <= prev_length.
		; At this point we have always match_length < MIN_MATCH

		cmp ecx,NIL
		je @f
		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,ecx
		cmp ebx,eax
		jg @f ;if (..!=0 && ..<=..)
			; To simplify the code, we prevent matches with the string
			; of window index 0 (in particular we have to avoid a match
			; of the string with itself at the start of the input file).

			stdcall longest_match, edi, ecx
			mov [edi+deflate_state.match_length],eax
			; longest_match() sets match_start
		@@:
		cmp dword[edi+deflate_state.match_length],MIN_MATCH
		jl .end1 ;if (..>=..)
			stdcall check_match, edi, [edi+deflate_state.strstart], [edi+deflate_state.match_start], [edi+deflate_state.match_length]

			mov eax,[edi+deflate_state.strstart]
			sub eax,[edi+deflate_state.match_start]
			mov ebx,[edi+deflate_state.match_length]
			sub ebx,MIN_MATCH
			_tr_tally_dist edi, eax, ebx, [bflush]

			mov eax,[edi+deflate_state.match_length]
			sub [edi+deflate_state.lookahead],eax

			; Insert new strings in the hash table only if the match length
			; is not too large. This saves time but degrades compression.

if FASTEST eq 0
			;;mov eax,[edi+deflate_state.match_length]
			cmp eax,[edi+deflate_state.max_insert_length]
			jg .end3
			cmp dword[edi+deflate_state.lookahead],MIN_MATCH
			jl .end3 ;if (..<=.. && ..>=..)
				dec dword[edi+deflate_state.match_length] ;string at strstart already in table
				.cycle1: ;do {
					inc dword[edi+deflate_state.strstart]
					INSERT_STRING edi, [edi+deflate_state.strstart], ecx
					; strstart never exceeds WSIZE-MAX_MATCH, so there are
					; always MIN_MATCH bytes ahead.

					dec dword[edi+deflate_state.match_length]
					cmp dword[edi+deflate_state.match_length],0
					jne .cycle1 ;while (..!=0)
				inc dword[edi+deflate_state.strstart]
				jmp .end2
			.end3: ;else
end if

				mov eax,[edi+deflate_state.match_length]
				add [edi+deflate_state.strstart],eax
				mov dword[edi+deflate_state.match_length],0
				mov eax,[edi+deflate_state.window]
				add eax,[edi+deflate_state.strstart]
				mov [edi+deflate_state.ins_h],eax
				inc eax
				movzx eax,byte[eax]
				UPDATE_HASH edi, [edi+deflate_state.ins_h], eax
if MIN_MATCH <> 3
;                Call UPDATE_HASH() MIN_MATCH-3 more times
end if
				; If lookahead < MIN_MATCH, ins_h is garbage, but it does not
				; matter since it will be recomputed at next deflate call.
			jmp .end2
		.end1: ;else
			; No match, output a literal byte
			mov eax,[edi+deflate_state.window]
			add eax,[edi+deflate_state.strstart]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edi, eax, [bflush]
			dec dword[edi+deflate_state.lookahead]
			inc dword[edi+deflate_state.strstart]
		.end2:
		cmp dword[bflush],0
		je .cycle0 ;if (..)
			FLUSH_BLOCK edi, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov eax,[edi+deflate_state.strstart]
	cmp eax,MIN_MATCH-1
	jl @f
		mov eax,MIN_MATCH-1
	@@:
	mov [edi+deflate_state.insert],eax
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp

; ===========================================================================
; Same as above, but achieves better compression. We use a lazy
; evaluation for matches: a match is finally adopted only if there is
; no better match at the next window position.

;block_state (s, flush)
;    deflate_state *s
;    int flush
align 4
proc deflate_slow uses ebx ecx edx edi, s:dword, flush:dword
locals
	bflush dd ? ;int  ;set if current block must be flushed
endl
;ecx = hash_head ;IPos ;head of the hash chain
	mov edi,[s]
zlib_debug 'deflate_slow'

	; Process the input block.
	.cycle0: ;for (;;)
	; Make sure that we always have enough lookahead, except
	; at the end of the input file. We need MAX_MATCH bytes
	; for the next match, plus MIN_MATCH bytes to insert the
	; string following the next match.

		cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
		jge .end0 ;if (..<..)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],MIN_LOOKAHEAD
			jge @f ;if (..<.. && ..==..)
			cmp dword[flush],Z_NO_FLUSH
			jne @f
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edi+deflate_state.lookahead],0
			je .cycle0end ;if (..==0) break ;flush the current block
align 4
		.end0:

		; Insert the string window[strstart .. strstart+2] in the
		; dictionary, and set hash_head to the head of the hash chain:

		mov ecx,NIL
		cmp dword[edi+deflate_state.lookahead],MIN_MATCH
		jl @f ;if (..>=..)
			INSERT_STRING edi, [edi+deflate_state.strstart], ecx
		@@:

		; Find the longest match, discarding those <= prev_length.

		mov eax,[edi+deflate_state.match_length]
		mov [edi+deflate_state.prev_length],eax
		mov eax,[edi+deflate_state.match_start]
		mov [edi+deflate_state.prev_match],eax
		mov dword[edi+deflate_state.match_length],MIN_MATCH-1

		cmp ecx,NIL
		je @f
		mov eax,[edi+deflate_state.prev_length]
		cmp eax,[edi+deflate_state.max_lazy_match]
		jge @f
		MAX_DIST edi
		mov ebx,[edi+deflate_state.strstart]
		sub ebx,ecx
		cmp ebx,eax
		jg .end1 ;if (..!=0 && ..<.. && ..<=..)
			; To simplify the code, we prevent matches with the string
			; of window index 0 (in particular we have to avoid a match
			; of the string with itself at the start of the input file).

			stdcall longest_match, edi, ecx
			mov [edi+deflate_state.match_length],eax
			; longest_match() sets match_start

			cmp dword[edi+deflate_state.match_length],5
			jg .end1
			cmp word[edi+deflate_state.strategy],Z_FILTERED
			jne .end1
;            if (..<=.. && (..==..
;#if TOO_FAR <= 32767
;                || (s->match_length == MIN_MATCH &&
;                    s->strstart - s->match_start > TOO_FAR)
;end if
;                ))

				; If prev_match is also MIN_MATCH, match_start is garbage
				; but we will ignore the current match anyway.

				mov dword[edi+deflate_state.match_length],MIN_MATCH-1
		.end1:
		; If there was a match at the previous step and the current
		; match is not better, output the previous match:


		mov eax,[edi+deflate_state.prev_length]
		cmp eax,MIN_MATCH
		jl .end2:
		cmp [edi+deflate_state.match_length],eax
		jg .end2: ;if (..>=.. && ..<=..)
			mov edx,[edi+deflate_state.strstart]
			add edx,[edi+deflate_state.lookahead]
			sub edx,MIN_MATCH
			;edx = max_insert
			; Do not insert strings in hash table beyond this.

			mov eax,[edi+deflate_state.strstart]
			dec eax
			stdcall check_match, edi, eax, [edi+deflate_state.prev_match], [edi+deflate_state.prev_length]

			mov eax,[edi+deflate_state.strstart]
			dec eax
			sub eax,[edi+deflate_state.prev_match]
			mov ebx,[edi+deflate_state.prev_length]
			sub ebx,MIN_MATCH
			_tr_tally_dist edi, eax, ebx, [bflush]

			; Insert in hash table all strings up to the end of the match.
			; strstart-1 and strstart are already inserted. If there is not
			; enough lookahead, the last two strings are not inserted in
			; the hash table.

			mov eax,[edi+deflate_state.prev_length]
			dec eax
			sub [edi+deflate_state.lookahead],eax
			sub dword[edi+deflate_state.prev_length],2
			.cycle1: ;do
				inc dword[edi+deflate_state.strstart]
				cmp [edi+deflate_state.strstart],edx
				jg @f ;if (..<=..)
					INSERT_STRING edi, [edi+deflate_state.strstart], ecx
				@@:
				dec dword[edi+deflate_state.prev_length]
				cmp dword[edi+deflate_state.prev_length],0
				jne .cycle1 ;while (..!=0)
			mov dword[edi+deflate_state.match_available],0
			mov dword[edi+deflate_state.match_length],MIN_MATCH-1
			inc dword[edi+deflate_state.strstart]

			cmp dword[bflush],0
			je .cycle0 ;if (..)
				FLUSH_BLOCK edi, 0
			jmp .cycle0
		.end2: ;else if (..)
		cmp dword[edi+deflate_state.match_available],0
		je .end3
			; If there was no match at the previous position, output a
			; single literal. If there was a match but the current match
			; is longer, truncate the previous match to a single literal.

			mov eax,[edi+deflate_state.strstart]
			dec eax
			add eax,[edi+deflate_state.window]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edi, eax, [bflush]
			cmp dword[bflush],0
			je @f ;if (..)
				FLUSH_BLOCK_ONLY edi, 0
			@@:
			inc dword[edi+deflate_state.strstart]
			dec dword[edi+deflate_state.lookahead]
			mov eax,[edi+deflate_state.strm]
			cmp word[eax+z_stream.avail_out],0
			jne .cycle0 ;if (..==0) return ..
				mov eax,need_more
				jmp .end_f
			jmp .cycle0 ;.end4
		.end3: ;else
			; There is no previous match to compare with, wait for
			; the next step to decide.

			mov dword[edi+deflate_state.match_available],1
			inc dword[edi+deflate_state.strstart]
			dec dword[edi+deflate_state.lookahead]
		;.end4:
		jmp .cycle0
	.cycle0end:
	cmp dword[flush],Z_NO_FLUSH
	jne @f
		zlib_debug 'no flush?' ;Assert (..!=..)
	@@:
	cmp dword[edi+deflate_state.match_available],0
	je @f ;if (..)
		mov eax,[edi+deflate_state.strstart]
		dec eax
		add eax,[edi+deflate_state.window]
		movzx eax,byte[eax]
		Tracevv eax,
		_tr_tally_lit edi, eax, [bflush]
		mov dword[edi+deflate_state.match_available],0
	@@:
	mov eax,[edi+deflate_state.strstart]
	cmp eax,MIN_MATCH-1
	jl @f
		mov eax,MIN_MATCH-1
	@@:
	mov [edi+deflate_state.insert],eax
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp

; ===========================================================================
; For Z_RLE, simply look for runs of bytes, generate matches only of distance
; one.  Do not maintain a hash table.  (It will be regenerated if this run of
; deflate switches away from Z_RLE.)

;block_state (s, flush)
;    deflate_state *s;
;    int flush;
align 4
proc deflate_rle uses ecx edx edi esi, s:dword, flush:dword
locals
	bflush dd ? ;int ;set if current block must be flushed
;    uInt prev;              /* byte at distance one to match */
;    Bytef *scan, *strend;   /* scan goes up to strend for length of run */	
endl
	mov edx,[s]
zlib_debug 'deflate_rle'
	.cycle0: ;for (;;)
		; Make sure that we always have enough lookahead, except
		; at the end of the input file. We need MAX_MATCH bytes
		; for the longest run, plus one for the unrolled loop.
		cmp dword[edx+deflate_state.lookahead],MAX_MATCH
		jg .end0 ;if (..<=..)
			stdcall fill_window, edx
			cmp dword[edx+deflate_state.lookahead],MAX_MATCH
			jg @f
			cmp dword[flush],Z_NO_FLUSH
			jne @f ;if (..<=.. && ..==..)
				mov eax,need_more
				jmp .end_f
align 4
			@@:
			cmp dword[edx+deflate_state.lookahead],0
			je .cycle0end ;flush the current block
align 4
		.end0:

		; See how many times the previous byte repeats
		mov dword[edx+deflate_state.match_length],0
		cmp dword[edx+deflate_state.lookahead],MIN_MATCH
		jl .end1
		cmp dword[edx+deflate_state.strstart],0
		jle .end1 ;if (..>=.. && ..>..)
			mov esi,[edx+deflate_state.window]
			add esi,[edx+deflate_state.strstart]
			dec esi
			lodsb
			mov edi,esi
			scasb
			jnz .end2
			scasb
			jnz .end2
			scasb
			jnz .end2 ;if (..==.. && ..==.. && ..==..)
				;edi = scan
				; al = prev
				;ecx = strend-scan
				mov ecx,MAX_MATCH-2
				repz scasb
				sub edi,[edx+deflate_state.window]
				sub edi,[edx+deflate_state.strstart]
				mov [edx+deflate_state.match_length],edi
				mov eax,[edx+deflate_state.lookahead]
				cmp [edx+deflate_state.match_length],eax
				jle .end2
					mov [edx+deflate_state.match_length],eax
			.end2:
			mov eax,[edx+deflate_state.window_size]
			dec eax
			add eax,[edx+deflate_state.window]
			cmp edi,eax
			jle .end1
				zlib_debug 'wild scan' ;Assert(..<=..)
		.end1:

		; Emit match if have run of MIN_MATCH or longer, else emit literal
		cmp dword[edx+deflate_state.match_length],MIN_MATCH
		jl @f ;if (..>=..)
			push dword[edx+deflate_state.match_length]
			mov eax,[edx+deflate_state.strstart]
			dec eax
			stdcall check_match, edx, [edx+deflate_state.strstart], eax

			mov eax,[edx+deflate_state.match_length]
			sub eax,MIN_MATCH
			_tr_tally_dist edx, 1, eax, [bflush]

			mov eax,[edx+deflate_state.match_length]
			sub [edx+deflate_state.lookahead],eax
			add [edx+deflate_state.strstart],eax
			mov dword[edx+deflate_state.match_length],0
			jmp .end3
		@@: ;else
			; No match, output a literal byte
			mov eax,[edx+deflate_state.strstart]
			add eax,[edx+deflate_state.window]
			movzx eax,byte[eax]
			Tracevv eax,
			_tr_tally_lit edx, eax, [bflush]
			dec dword[edx+deflate_state.lookahead]
			inc dword[edx+deflate_state.strstart]
		.end3:
		cmp dword[bflush],0
		je .cycle0 ;if (..)
			FLUSH_BLOCK edx, 0
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edx+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edx, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edx+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edx, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp

; ===========================================================================
; For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
; (It will be regenerated if this run of deflate switches away from Huffman.)

;block_state (s, flush)
;    deflate_state *s;
;    int flush;
align 4
proc deflate_huff uses ebx edi, s:dword, flush:dword
locals
	bflush dd ? ;int ;set if current block must be flushed
endl
	mov edi,[s]
zlib_debug 'deflate_huff'
	.cycle0: ;for (;;)
		; Make sure that we have a literal to write.
		cmp dword[edi+deflate_state.lookahead],0
		jne .end0 ;if (..==0)
			stdcall fill_window, edi
			cmp dword[edi+deflate_state.lookahead],0
			jne .end0 ;if (..==0)
				cmp dword[flush],Z_NO_FLUSH
				jne @f ;if (..==..)
					mov eax,need_more
					jmp .end_f
align 4
				@@:
			jmp .cycle0end ;flush the current block
align 4
		.end0:

		; Output a literal byte
		mov dword[edi+deflate_state.match_length],0
		mov eax,[edi+deflate_state.strstart]
		add eax,[edi+deflate_state.window]
		movzx eax,byte[eax]
		Tracevv eax,
		_tr_tally_lit edi, eax, [bflush]
		dec dword[edi+deflate_state.lookahead]
		inc dword[edi+deflate_state.strstart]
		cmp dword[bflush],0
		je @f ;if (..)
			FLUSH_BLOCK edi, 0
		@@:
		jmp .cycle0
align 4
	.cycle0end:
	mov dword[edi+deflate_state.insert],0
	cmp dword[flush],Z_FINISH
	jne @f ;if (..==..)
		FLUSH_BLOCK edi, 1
		mov eax,finish_done
		jmp .end_f
	@@:
	cmp dword[edi+deflate_state.last_lit],0
	je @f ;if (..)
		FLUSH_BLOCK edi, 0
	@@:
	mov eax,block_done
.end_f:
	ret
endp