1 ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01
\r
3 TITLE D:\FMU\FMUSolution\zlib-1.2.6\inflate.c
\r
11 PUBLIC ??_C@_0BH@LIBMMIGA@incorrect?5header?5check?$AA@ ; `string'
\r
12 PUBLIC ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@ ; `string'
\r
13 PUBLIC ??_C@_0BE@EMOGCLGO@invalid?5window?5size?$AA@ ; `string'
\r
14 PUBLIC ??_C@_0BJ@BLBBCOMO@unknown?5header?5flags?5set?$AA@ ; `string'
\r
15 PUBLIC ??_C@_0BE@GONKLEPM@header?5crc?5mismatch?$AA@ ; `string'
\r
16 PUBLIC ??_C@_0BF@MEIGEHBE@incorrect?5data?5check?$AA@ ; `string'
\r
17 PUBLIC ??_C@_0BH@FGKKJGOC@incorrect?5length?5check?$AA@ ; `string'
\r
18 ; COMDAT ??_C@_0BH@FGKKJGOC@incorrect?5length?5check?$AA@
\r
20 ??_C@_0BH@FGKKJGOC@incorrect?5length?5check?$AA@ DB 'incorrect length che'
\r
21 DB 'ck', 00H ; `string'
\r
23 ; COMDAT ??_C@_0BF@MEIGEHBE@incorrect?5data?5check?$AA@
\r
25 ??_C@_0BF@MEIGEHBE@incorrect?5data?5check?$AA@ DB 'incorrect data check', 00H ; `string'
\r
27 ; COMDAT ??_C@_0BE@GONKLEPM@header?5crc?5mismatch?$AA@
\r
29 ??_C@_0BE@GONKLEPM@header?5crc?5mismatch?$AA@ DB 'header crc mismatch', 00H ; `string'
\r
31 ; COMDAT ??_C@_0BJ@BLBBCOMO@unknown?5header?5flags?5set?$AA@
\r
33 ??_C@_0BJ@BLBBCOMO@unknown?5header?5flags?5set?$AA@ DB 'unknown header fl'
\r
34 DB 'ags set', 00H ; `string'
\r
36 ; COMDAT ??_C@_0BE@EMOGCLGO@invalid?5window?5size?$AA@
\r
38 ??_C@_0BE@EMOGCLGO@invalid?5window?5size?$AA@ DB 'invalid window size', 00H ; `string'
\r
40 ; COMDAT ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@
\r
42 ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@ DB 'unknown compress'
\r
43 DB 'ion method', 00H ; `string'
\r
45 ; COMDAT ??_C@_0BH@LIBMMIGA@incorrect?5header?5check?$AA@
\r
47 ??_C@_0BH@LIBMMIGA@incorrect?5header?5check?$AA@ DB 'incorrect header che'
\r
48 DB 'ck', 00H ; `string'
\r
49 ?lenfix@?1??fixedtables@@9@9 DB 060H ; `fixedtables'::`2'::lenfix
\r
1585 ?distfix@?1??fixedtables@@9@9 DB 010H ; `fixedtables'::`2'::distfix
\r
1681 ?order@?1??inflate@@9@9 DW 010H ; `inflate'::`2'::order
\r
1700 PUBLIC _inflateMark@4
\r
1701 ; Function compile flags: /Ogtp
\r
1702 ; File d:\fmu\fmusolution\zlib-1.2.6\inflate.c
\r
1703 ; COMDAT _inflateMark@4
\r
1705 _strm$ = 8 ; size = 4
\r
1706 _inflateMark@4 PROC ; COMDAT
\r
1711 00001 8b ec mov ebp, esp
\r
1713 ; 1494 : struct inflate_state FAR *state;
\r
1715 ; 1496 : if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
\r
1717 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
1718 00006 85 c0 test eax, eax
\r
1719 00008 74 4e je SHORT $LN1@inflateMar
\r
1720 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
1721 0000d 85 c0 test eax, eax
\r
1722 0000f 74 47 je SHORT $LN1@inflateMar
\r
1724 ; 1497 : state = (struct inflate_state FAR *)strm->state;
\r
1725 ; 1498 : return ((long)(state->back) << 16) +
\r
1726 ; 1499 : (state->mode == COPY ? state->length :
\r
1727 ; 1500 : (state->mode == MATCH ? state->was - state->length : 0));
\r
1729 00011 8b 08 mov ecx, DWORD PTR [eax]
\r
1730 00013 83 f9 0f cmp ecx, 15 ; 0000000fH
\r
1731 00016 75 12 jne SHORT $LN7@inflateMar
\r
1732 00018 8b 48 40 mov ecx, DWORD PTR [eax+64]
\r
1733 0001b 8b 80 c4 1b 00
\r
1734 00 mov eax, DWORD PTR [eax+7108]
\r
1735 00021 c1 e0 10 shl eax, 16 ; 00000010H
\r
1736 00024 03 c1 add eax, ecx
\r
1741 00027 c2 04 00 ret 4
\r
1744 ; 1497 : state = (struct inflate_state FAR *)strm->state;
\r
1745 ; 1498 : return ((long)(state->back) << 16) +
\r
1746 ; 1499 : (state->mode == COPY ? state->length :
\r
1747 ; 1500 : (state->mode == MATCH ? state->was - state->length : 0));
\r
1749 0002a 83 f9 18 cmp ecx, 24 ; 00000018H
\r
1750 0002d 75 18 jne SHORT $LN5@inflateMar
\r
1751 0002f 8b 88 c8 1b 00
\r
1752 00 mov ecx, DWORD PTR [eax+7112]
\r
1753 00035 2b 48 40 sub ecx, DWORD PTR [eax+64]
\r
1754 00038 8b 80 c4 1b 00
\r
1755 00 mov eax, DWORD PTR [eax+7108]
\r
1756 0003e c1 e0 10 shl eax, 16 ; 00000010H
\r
1757 00041 03 c1 add eax, ecx
\r
1762 00044 c2 04 00 ret 4
\r
1765 ; 1497 : state = (struct inflate_state FAR *)strm->state;
\r
1766 ; 1498 : return ((long)(state->back) << 16) +
\r
1767 ; 1499 : (state->mode == COPY ? state->length :
\r
1768 ; 1500 : (state->mode == MATCH ? state->was - state->length : 0));
\r
1770 00047 8b 80 c4 1b 00
\r
1771 00 mov eax, DWORD PTR [eax+7108]
\r
1772 0004d 33 c9 xor ecx, ecx
\r
1773 0004f c1 e0 10 shl eax, 16 ; 00000010H
\r
1774 00052 03 c1 add eax, ecx
\r
1779 00055 c2 04 00 ret 4
\r
1782 ; 1494 : struct inflate_state FAR *state;
\r
1784 ; 1496 : if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
\r
1786 00058 b8 00 00 ff ff mov eax, -65536 ; ffff0000H
\r
1791 0005e c2 04 00 ret 4
\r
1792 _inflateMark@4 ENDP
\r
1794 PUBLIC _inflateUndermine@8
\r
1795 ; Function compile flags: /Ogtp
\r
1796 ; COMDAT _inflateUndermine@8
\r
1798 _strm$ = 8 ; size = 4
\r
1799 _subvert$ = 12 ; size = 4
\r
1800 _inflateUndermine@8 PROC ; COMDAT
\r
1805 00001 8b ec mov ebp, esp
\r
1807 ; 1478 : struct inflate_state FAR *state;
\r
1809 ; 1480 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1811 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
1812 00006 85 c0 test eax, eax
\r
1813 00008 74 1a je SHORT $LN1@inflateUnd
\r
1814 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
1815 0000d 85 c0 test eax, eax
\r
1816 0000f 74 13 je SHORT $LN1@inflateUnd
\r
1818 ; 1481 : state = (struct inflate_state FAR *)strm->state;
\r
1819 ; 1482 : state->sane = !subvert;
\r
1820 ; 1483 : #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
\r
1821 ; 1484 : return Z_OK;
\r
1823 ; 1486 : state->sane = 1;
\r
1825 00011 c7 80 c0 1b 00
\r
1826 00 01 00 00 00 mov DWORD PTR [eax+7104], 1
\r
1828 ; 1487 : return Z_DATA_ERROR;
\r
1830 0001b b8 fd ff ff ff mov eax, -3 ; fffffffdH
\r
1836 00021 c2 08 00 ret 8
\r
1839 ; 1478 : struct inflate_state FAR *state;
\r
1841 ; 1480 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
1843 00024 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
1849 0002a c2 08 00 ret 8
\r
1850 _inflateUndermine@8 ENDP
\r
1852 PUBLIC _inflateCopy@8
\r
1853 EXTRN _memcpy:PROC
\r
1854 ; Function compile flags: /Ogtp
\r
1855 ; COMDAT _inflateCopy@8
\r
1857 _copy$ = -4 ; size = 4
\r
1858 _dest$ = 8 ; size = 4
\r
1859 _window$ = 12 ; size = 4
\r
1860 _source$ = 12 ; size = 4
\r
1861 _inflateCopy@8 PROC ; COMDAT
\r
1866 00001 8b ec mov ebp, esp
\r
1869 ; 1431 : struct inflate_state FAR *state;
\r
1870 ; 1432 : struct inflate_state FAR *copy;
\r
1871 ; 1433 : unsigned char FAR *window;
\r
1872 ; 1434 : unsigned wsize;
\r
1874 ; 1436 : /* check input */
\r
1875 ; 1437 : if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
\r
1876 ; 1438 : source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
\r
1878 00004 83 7d 08 00 cmp DWORD PTR _dest$[ebp], 0
\r
1881 0000a 0f 84 36 01 00
\r
1882 00 je $LN6@inflateCop
\r
1883 00010 8b 75 0c mov esi, DWORD PTR _source$[ebp]
\r
1884 00013 85 f6 test esi, esi
\r
1885 00015 0f 84 2b 01 00
\r
1886 00 je $LN6@inflateCop
\r
1887 0001b 8b 5e 1c mov ebx, DWORD PTR [esi+28]
\r
1888 0001e 85 db test ebx, ebx
\r
1889 00020 0f 84 20 01 00
\r
1890 00 je $LN6@inflateCop
\r
1891 00026 8b 46 20 mov eax, DWORD PTR [esi+32]
\r
1892 00029 85 c0 test eax, eax
\r
1893 0002b 0f 84 15 01 00
\r
1894 00 je $LN6@inflateCop
\r
1895 00031 83 7e 24 00 cmp DWORD PTR [esi+36], 0
\r
1896 00035 0f 84 0b 01 00
\r
1897 00 je $LN6@inflateCop
\r
1899 ; 1440 : state = (struct inflate_state FAR *)source->state;
\r
1901 ; 1442 : /* allocate space */
\r
1902 ; 1443 : copy = (struct inflate_state FAR *)
\r
1903 ; 1444 : ZALLOC(source, 1, sizeof(struct inflate_state));
\r
1905 0003b 8b 4e 28 mov ecx, DWORD PTR [esi+40]
\r
1907 0003f 68 cc 1b 00 00 push 7116 ; 00001bccH
\r
1908 00044 6a 01 push 1
\r
1910 00047 ff d0 call eax
\r
1911 00049 8b f8 mov edi, eax
\r
1912 0004b 83 c4 0c add esp, 12 ; 0000000cH
\r
1913 0004e 89 7d fc mov DWORD PTR _copy$[ebp], edi
\r
1915 ; 1445 : if (copy == Z_NULL) return Z_MEM_ERROR;
\r
1917 00051 85 ff test edi, edi
\r
1918 00053 74 3a je SHORT $LN11@inflateCop
\r
1920 ; 1446 : window = Z_NULL;
\r
1921 ; 1447 : if (state->window != Z_NULL) {
\r
1923 00055 83 7b 34 00 cmp DWORD PTR [ebx+52], 0
\r
1924 00059 c7 45 0c 00 00
\r
1925 00 00 mov DWORD PTR _window$[ebp], 0
\r
1926 00060 74 3b je SHORT $LN3@inflateCop
\r
1928 ; 1448 : window = (unsigned char FAR *)
\r
1929 ; 1449 : ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
\r
1931 00062 8b 4b 24 mov ecx, DWORD PTR [ebx+36]
\r
1932 00065 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
1933 00068 ba 01 00 00 00 mov edx, 1
\r
1934 0006d d3 e2 shl edx, cl
\r
1935 0006f 8b 4e 20 mov ecx, DWORD PTR [esi+32]
\r
1936 00072 6a 01 push 1
\r
1939 00076 ff d1 call ecx
\r
1940 00078 83 c4 0c add esp, 12 ; 0000000cH
\r
1941 0007b 89 45 0c mov DWORD PTR _window$[ebp], eax
\r
1943 ; 1450 : if (window == Z_NULL) {
\r
1945 0007e 85 c0 test eax, eax
\r
1946 00080 75 1b jne SHORT $LN3@inflateCop
\r
1948 ; 1451 : ZFREE(source, copy);
\r
1950 00082 8b 56 28 mov edx, DWORD PTR [esi+40]
\r
1951 00085 8b 46 24 mov eax, DWORD PTR [esi+36]
\r
1954 0008a ff d0 call eax
\r
1955 0008c 83 c4 08 add esp, 8
\r
1958 ; 1452 : return Z_MEM_ERROR;
\r
1962 00091 b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
1967 00097 8b e5 mov esp, ebp
\r
1969 0009a c2 08 00 ret 8
\r
1975 ; 1456 : /* copy state */
\r
1976 ; 1457 : zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
\r
1978 0009d 8b 7d 08 mov edi, DWORD PTR _dest$[ebp]
\r
1979 000a0 b9 0e 00 00 00 mov ecx, 14 ; 0000000eH
\r
1981 ; 1458 : zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
\r
1983 000a5 68 cc 1b 00 00 push 7116 ; 00001bccH
\r
1984 000aa f3 a5 rep movsd
\r
1985 000ac 8b 75 fc mov esi, DWORD PTR _copy$[ebp]
\r
1988 000b1 e8 00 00 00 00 call _memcpy
\r
1990 ; 1459 : if (state->lencode >= state->codes &&
\r
1991 ; 1460 : state->lencode <= state->codes + ENOUGH - 1) {
\r
1993 000b6 8b 43 4c mov eax, DWORD PTR [ebx+76]
\r
1994 000b9 8d 8b 30 05 00
\r
1995 00 lea ecx, DWORD PTR [ebx+1328]
\r
1996 000bf 83 c4 0c add esp, 12 ; 0000000cH
\r
1997 000c2 3b c1 cmp eax, ecx
\r
1998 000c4 72 36 jb SHORT $LN2@inflateCop
\r
1999 000c6 8d 93 bc 1b 00
\r
2000 00 lea edx, DWORD PTR [ebx+7100]
\r
2001 000cc 3b c2 cmp eax, edx
\r
2002 000ce 77 2c ja SHORT $LN2@inflateCop
\r
2004 ; 1461 : copy->lencode = copy->codes + (state->lencode - state->codes);
\r
2006 000d0 2b c3 sub eax, ebx
\r
2007 000d2 2d 30 05 00 00 sub eax, 1328 ; 00000530H
\r
2008 000d7 c1 f8 02 sar eax, 2
\r
2009 000da 8d 84 86 30 05
\r
2010 00 00 lea eax, DWORD PTR [esi+eax*4+1328]
\r
2011 000e1 89 46 4c mov DWORD PTR [esi+76], eax
\r
2013 ; 1462 : copy->distcode = copy->codes + (state->distcode - state->codes);
\r
2015 000e4 8b 4b 50 mov ecx, DWORD PTR [ebx+80]
\r
2016 000e7 2b cb sub ecx, ebx
\r
2017 000e9 81 e9 30 05 00
\r
2018 00 sub ecx, 1328 ; 00000530H
\r
2019 000ef c1 f9 02 sar ecx, 2
\r
2020 000f2 8d 94 8e 30 05
\r
2021 00 00 lea edx, DWORD PTR [esi+ecx*4+1328]
\r
2022 000f9 89 56 50 mov DWORD PTR [esi+80], edx
\r
2026 ; 1464 : copy->next = copy->codes + (state->next - state->codes);
\r
2028 000fc 8b 43 6c mov eax, DWORD PTR [ebx+108]
\r
2030 ; 1465 : if (window != Z_NULL) {
\r
2032 000ff 8b 7d 0c mov edi, DWORD PTR _window$[ebp]
\r
2033 00102 2b c3 sub eax, ebx
\r
2034 00104 2d 30 05 00 00 sub eax, 1328 ; 00000530H
\r
2035 00109 c1 f8 02 sar eax, 2
\r
2036 0010c 8d 8c 86 30 05
\r
2037 00 00 lea ecx, DWORD PTR [esi+eax*4+1328]
\r
2038 00113 89 4e 6c mov DWORD PTR [esi+108], ecx
\r
2039 00116 85 ff test edi, edi
\r
2040 00118 74 18 je SHORT $LN1@inflateCop
\r
2042 ; 1466 : wsize = 1U << state->wbits;
\r
2044 0011a 8b 4b 24 mov ecx, DWORD PTR [ebx+36]
\r
2046 ; 1467 : zmemcpy(window, state->window, wsize);
\r
2048 0011d 8b 43 34 mov eax, DWORD PTR [ebx+52]
\r
2049 00120 ba 01 00 00 00 mov edx, 1
\r
2050 00125 d3 e2 shl edx, cl
\r
2054 0012a e8 00 00 00 00 call _memcpy
\r
2055 0012f 83 c4 0c add esp, 12 ; 0000000cH
\r
2059 ; 1469 : copy->window = window;
\r
2060 ; 1470 : dest->state = (struct internal_state FAR *)copy;
\r
2062 00132 8b 4d 08 mov ecx, DWORD PTR _dest$[ebp]
\r
2063 00135 89 7e 34 mov DWORD PTR [esi+52], edi
\r
2065 00139 89 71 1c mov DWORD PTR [ecx+28], esi
\r
2068 ; 1471 : return Z_OK;
\r
2070 0013d 33 c0 xor eax, eax
\r
2075 00140 8b e5 mov esp, ebp
\r
2077 00143 c2 08 00 ret 8
\r
2081 ; 1439 : return Z_STREAM_ERROR;
\r
2083 00147 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2088 0014d 8b e5 mov esp, ebp
\r
2090 00150 c2 08 00 ret 8
\r
2091 _inflateCopy@8 ENDP
\r
2093 PUBLIC _inflateSyncPoint@4
\r
2094 ; Function compile flags: /Ogtp
\r
2095 ; COMDAT _inflateSyncPoint@4
\r
2097 _strm$ = 8 ; size = 4
\r
2098 _inflateSyncPoint@4 PROC ; COMDAT
\r
2103 00001 8b ec mov ebp, esp
\r
2105 ; 1420 : struct inflate_state FAR *state;
\r
2107 ; 1422 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2109 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
2110 00006 85 c0 test eax, eax
\r
2111 00008 74 21 je SHORT $LN1@inflateSyn
\r
2112 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
2113 0000d 85 c0 test eax, eax
\r
2114 0000f 74 1a je SHORT $LN1@inflateSyn
\r
2116 ; 1423 : state = (struct inflate_state FAR *)strm->state;
\r
2117 ; 1424 : return state->mode == STORED && state->bits == 0;
\r
2119 00011 83 38 0d cmp DWORD PTR [eax], 13 ; 0000000dH
\r
2120 00014 75 0f jne SHORT $LN5@inflateSyn
\r
2121 00016 83 78 3c 00 cmp DWORD PTR [eax+60], 0
\r
2122 0001a 75 09 jne SHORT $LN5@inflateSyn
\r
2123 0001c b8 01 00 00 00 mov eax, 1
\r
2128 00022 c2 04 00 ret 4
\r
2131 ; 1423 : state = (struct inflate_state FAR *)strm->state;
\r
2132 ; 1424 : return state->mode == STORED && state->bits == 0;
\r
2134 00025 33 c0 xor eax, eax
\r
2139 00028 c2 04 00 ret 4
\r
2142 ; 1420 : struct inflate_state FAR *state;
\r
2144 ; 1422 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2146 0002b b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2151 00031 c2 04 00 ret 4
\r
2152 _inflateSyncPoint@4 ENDP
\r
2153 ; Function compile flags: /Ogtp
\r
2155 ; COMDAT _syncsearch
\r
2157 _have$ = 8 ; size = 4
\r
2158 _len$ = 12 ; size = 4
\r
2159 _syncsearch PROC ; COMDAT
\r
2165 00001 8b ec mov ebp, esp
\r
2166 00003 8b 55 08 mov edx, DWORD PTR _have$[ebp]
\r
2168 ; 1348 : unsigned got;
\r
2169 ; 1349 : unsigned next;
\r
2171 ; 1351 : got = *have;
\r
2173 00006 8b 0a mov ecx, DWORD PTR [edx]
\r
2175 ; 1352 : next = 0;
\r
2177 00008 33 c0 xor eax, eax
\r
2179 ; 1353 : while (next < len && got < 4) {
\r
2181 0000a 39 45 0c cmp DWORD PTR _len$[ebp], eax
\r
2182 0000d 76 41 jbe SHORT $LN11@syncsearch
\r
2186 00011 83 f9 04 cmp ecx, 4
\r
2187 00014 73 35 jae SHORT $LN12@syncsearch
\r
2189 ; 1354 : if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
\r
2191 00016 8a 14 30 mov dl, BYTE PTR [eax+esi]
\r
2192 00019 83 f9 02 cmp ecx, 2
\r
2193 0001c 1b ff sbb edi, edi
\r
2194 0001e 81 e7 01 ff ff
\r
2195 ff and edi, -255 ; ffffff01H
\r
2196 00024 0f b6 da movzx ebx, dl
\r
2197 00027 81 c7 ff 00 00
\r
2198 00 add edi, 255 ; 000000ffH
\r
2199 0002d 3b df cmp ebx, edi
\r
2200 0002f 75 03 jne SHORT $LN4@syncsearch
\r
2205 00032 eb 11 jmp SHORT $LN1@syncsearch
\r
2208 ; 1356 : else if (buf[next])
\r
2210 00034 84 d2 test dl, dl
\r
2211 00036 74 04 je SHORT $LN2@syncsearch
\r
2215 00038 33 c9 xor ecx, ecx
\r
2219 0003a eb 09 jmp SHORT $LN1@syncsearch
\r
2222 ; 1359 : got = 4 - got;
\r
2224 0003c ba 04 00 00 00 mov edx, 4
\r
2225 00041 2b d1 sub edx, ecx
\r
2226 00043 8b ca mov ecx, edx
\r
2232 00046 3b 45 0c cmp eax, DWORD PTR _len$[ebp]
\r
2233 00049 72 c6 jb SHORT $LL6@syncsearch
\r
2237 ; 1362 : *have = got;
\r
2239 0004b 8b 55 08 mov edx, DWORD PTR _have$[ebp]
\r
2243 00050 89 0a mov DWORD PTR [edx], ecx
\r
2245 ; 1363 : return next;
\r
2252 PUBLIC _inflateGetHeader@8
\r
2253 ; Function compile flags: /Ogtp
\r
2254 ; COMDAT _inflateGetHeader@8
\r
2256 _strm$ = 8 ; size = 4
\r
2257 _head$ = 12 ; size = 4
\r
2258 _inflateGetHeader@8 PROC ; COMDAT
\r
2263 00001 8b ec mov ebp, esp
\r
2265 ; 1319 : struct inflate_state FAR *state;
\r
2267 ; 1321 : /* check state */
\r
2268 ; 1322 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2270 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
2271 00006 85 c0 test eax, eax
\r
2272 00008 74 20 je SHORT $LN2@inflateGet
\r
2273 0000a 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
2274 0000d 85 c0 test eax, eax
\r
2275 0000f 74 19 je SHORT $LN2@inflateGet
\r
2277 ; 1323 : state = (struct inflate_state FAR *)strm->state;
\r
2278 ; 1324 : if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
\r
2280 00011 f6 40 08 02 test BYTE PTR [eax+8], 2
\r
2281 00015 74 13 je SHORT $LN2@inflateGet
\r
2284 ; 1326 : /* save header structure */
\r
2285 ; 1327 : state->head = head;
\r
2287 00017 8b 4d 0c mov ecx, DWORD PTR _head$[ebp]
\r
2288 0001a 89 48 20 mov DWORD PTR [eax+32], ecx
\r
2290 ; 1328 : head->done = 0;
\r
2292 0001d c7 41 30 00 00
\r
2293 00 00 mov DWORD PTR [ecx+48], 0
\r
2295 ; 1329 : return Z_OK;
\r
2297 00024 33 c0 xor eax, eax
\r
2302 00027 c2 08 00 ret 8
\r
2305 ; 1319 : struct inflate_state FAR *state;
\r
2307 ; 1321 : /* check state */
\r
2308 ; 1322 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2310 0002a b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2315 00030 c2 08 00 ret 8
\r
2316 _inflateGetHeader@8 ENDP
\r
2318 PUBLIC _inflateEnd@4
\r
2319 ; Function compile flags: /Ogtp
\r
2320 ; COMDAT _inflateEnd@4
\r
2322 _strm$ = 8 ; size = 4
\r
2323 _inflateEnd@4 PROC ; COMDAT
\r
2328 00001 8b ec mov ebp, esp
\r
2331 ; 1261 : struct inflate_state FAR *state;
\r
2332 ; 1262 : if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
\r
2334 00004 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
2335 00007 85 f6 test esi, esi
\r
2336 00009 74 3d je SHORT $LN2@inflateEnd
\r
2337 0000b 8b 46 1c mov eax, DWORD PTR [esi+28]
\r
2338 0000e 85 c0 test eax, eax
\r
2339 00010 74 36 je SHORT $LN2@inflateEnd
\r
2340 00012 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
2341 00015 85 c9 test ecx, ecx
\r
2342 00017 74 2f je SHORT $LN2@inflateEnd
\r
2344 ; 1264 : state = (struct inflate_state FAR *)strm->state;
\r
2345 ; 1265 : if (state->window != Z_NULL) ZFREE(strm, state->window);
\r
2347 00019 8b 40 34 mov eax, DWORD PTR [eax+52]
\r
2348 0001c 85 c0 test eax, eax
\r
2349 0001e 74 0a je SHORT $LN1@inflateEnd
\r
2351 00021 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
2353 00025 ff d1 call ecx
\r
2354 00027 83 c4 08 add esp, 8
\r
2357 ; 1266 : ZFREE(strm, strm->state);
\r
2359 0002a 8b 4e 1c mov ecx, DWORD PTR [esi+28]
\r
2360 0002d 8b 56 28 mov edx, DWORD PTR [esi+40]
\r
2361 00030 8b 46 24 mov eax, DWORD PTR [esi+36]
\r
2364 00035 ff d0 call eax
\r
2365 00037 83 c4 08 add esp, 8
\r
2367 ; 1267 : strm->state = Z_NULL;
\r
2369 0003a c7 46 1c 00 00
\r
2370 00 00 mov DWORD PTR [esi+28], 0
\r
2372 ; 1268 : Tracev((stderr, "inflate: end\n"));
\r
2373 ; 1269 : return Z_OK;
\r
2375 00041 33 c0 xor eax, eax
\r
2381 00045 c2 04 00 ret 4
\r
2384 ; 1263 : return Z_STREAM_ERROR;
\r
2386 00048 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2392 0004f c2 04 00 ret 4
\r
2393 _inflateEnd@4 ENDP
\r
2394 ; Function compile flags: /Ogtp
\r
2396 ; COMDAT _updatewindow
\r
2398 _dist$ = -4 ; size = 4
\r
2399 _updatewindow PROC ; COMDAT
\r
2406 00001 8b ec mov ebp, esp
\r
2410 ; 382 : struct inflate_state FAR *state;
\r
2411 ; 383 : unsigned copy, dist;
\r
2413 ; 385 : state = (struct inflate_state FAR *)strm->state;
\r
2415 00005 8b 73 1c mov esi, DWORD PTR [ebx+28]
\r
2418 ; 387 : /* if it hasn't been done already, allocate space for the window */
\r
2419 ; 388 : if (state->window == Z_NULL) {
\r
2421 00008 83 7e 34 00 cmp DWORD PTR [esi+52], 0
\r
2423 0000d 8b f8 mov edi, eax
\r
2424 0000f 75 2b jne SHORT $LN13@updatewind
\r
2426 ; 389 : state->window = (unsigned char FAR *)
\r
2427 ; 390 : ZALLOC(strm, 1U << state->wbits,
\r
2428 ; 391 : sizeof(unsigned char));
\r
2430 00011 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
2431 00014 8b 53 20 mov edx, DWORD PTR [ebx+32]
\r
2432 00017 b8 01 00 00 00 mov eax, 1
\r
2433 0001c d3 e0 shl eax, cl
\r
2434 0001e 8b 4b 28 mov ecx, DWORD PTR [ebx+40]
\r
2435 00021 6a 01 push 1
\r
2438 00025 ff d2 call edx
\r
2439 00027 83 c4 0c add esp, 12 ; 0000000cH
\r
2440 0002a 89 46 34 mov DWORD PTR [esi+52], eax
\r
2442 ; 392 : if (state->window == Z_NULL) return 1;
\r
2444 0002d 85 c0 test eax, eax
\r
2445 0002f 75 0b jne SHORT $LN13@updatewind
\r
2447 00032 b8 01 00 00 00 mov eax, 1
\r
2452 00038 8b e5 mov esp, ebp
\r
2459 ; 395 : /* if window not in use yet, initialize */
\r
2460 ; 396 : if (state->wsize == 0) {
\r
2462 0003c 33 c0 xor eax, eax
\r
2463 0003e 39 46 28 cmp DWORD PTR [esi+40], eax
\r
2464 00041 75 13 jne SHORT $LN8@updatewind
\r
2466 ; 397 : state->wsize = 1U << state->wbits;
\r
2468 00043 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
2469 00046 ba 01 00 00 00 mov edx, 1
\r
2470 0004b d3 e2 shl edx, cl
\r
2472 ; 398 : state->wnext = 0;
\r
2474 0004d 89 46 30 mov DWORD PTR [esi+48], eax
\r
2476 ; 399 : state->whave = 0;
\r
2478 00050 89 46 2c mov DWORD PTR [esi+44], eax
\r
2479 00053 89 56 28 mov DWORD PTR [esi+40], edx
\r
2484 ; 402 : /* copy state->wsize or less output bytes into the circular window */
\r
2485 ; 403 : copy = out - strm->avail_out;
\r
2487 00056 2b 7b 10 sub edi, DWORD PTR [ebx+16]
\r
2489 ; 404 : if (copy >= state->wsize) {
\r
2491 00059 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
2492 0005c 3b f8 cmp edi, eax
\r
2493 0005e 72 28 jb SHORT $LN7@updatewind
\r
2495 ; 405 : zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
\r
2497 00060 8b 4b 0c mov ecx, DWORD PTR [ebx+12]
\r
2498 00063 8b 56 34 mov edx, DWORD PTR [esi+52]
\r
2500 00067 2b c8 sub ecx, eax
\r
2503 0006b e8 00 00 00 00 call _memcpy
\r
2505 ; 406 : state->wnext = 0;
\r
2506 ; 407 : state->whave = state->wsize;
\r
2508 00070 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
2509 00073 83 c4 0c add esp, 12 ; 0000000cH
\r
2510 00076 89 46 2c mov DWORD PTR [esi+44], eax
\r
2512 0007a c7 46 30 00 00
\r
2513 00 00 mov DWORD PTR [esi+48], 0
\r
2519 00081 33 c0 xor eax, eax
\r
2524 00084 8b e5 mov esp, ebp
\r
2531 ; 410 : dist = state->wsize - state->wnext;
\r
2533 00088 2b 46 30 sub eax, DWORD PTR [esi+48]
\r
2534 0008b 89 45 fc mov DWORD PTR _dist$[ebp], eax
\r
2536 ; 411 : if (dist > copy) dist = copy;
\r
2538 0008e 3b c7 cmp eax, edi
\r
2539 00090 76 05 jbe SHORT $LN5@updatewind
\r
2540 00092 89 7d fc mov DWORD PTR _dist$[ebp], edi
\r
2541 00095 8b c7 mov eax, edi
\r
2544 ; 412 : zmemcpy(state->window + state->wnext, strm->next_out - copy, dist);
\r
2546 00097 8b 4b 0c mov ecx, DWORD PTR [ebx+12]
\r
2547 0009a 8b 56 34 mov edx, DWORD PTR [esi+52]
\r
2548 0009d 03 56 30 add edx, DWORD PTR [esi+48]
\r
2550 000a1 2b cf sub ecx, edi
\r
2553 000a5 e8 00 00 00 00 call _memcpy
\r
2555 ; 413 : copy -= dist;
\r
2557 000aa 8b 4d fc mov ecx, DWORD PTR _dist$[ebp]
\r
2558 000ad 83 c4 0c add esp, 12 ; 0000000cH
\r
2559 000b0 2b f9 sub edi, ecx
\r
2561 ; 414 : if (copy) {
\r
2563 000b2 74 24 je SHORT $LN4@updatewind
\r
2565 ; 415 : zmemcpy(state->window, strm->next_out - copy, copy);
\r
2567 000b4 8b 43 0c mov eax, DWORD PTR [ebx+12]
\r
2568 000b7 8b 4e 34 mov ecx, DWORD PTR [esi+52]
\r
2570 000bb 2b c7 sub eax, edi
\r
2573 000bf e8 00 00 00 00 call _memcpy
\r
2575 ; 416 : state->wnext = copy;
\r
2576 ; 417 : state->whave = state->wsize;
\r
2578 000c4 8b 56 28 mov edx, DWORD PTR [esi+40]
\r
2579 000c7 83 c4 0c add esp, 12 ; 0000000cH
\r
2580 000ca 89 7e 30 mov DWORD PTR [esi+48], edi
\r
2583 ; 422 : if (state->whave < state->wsize) state->whave += dist;
\r
2585 000ce 89 56 2c mov DWORD PTR [esi+44], edx
\r
2591 000d1 33 c0 xor eax, eax
\r
2596 000d4 8b e5 mov esp, ebp
\r
2603 ; 420 : state->wnext += dist;
\r
2604 ; 421 : if (state->wnext == state->wsize) state->wnext = 0;
\r
2606 000d8 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
2607 000db 01 4e 30 add DWORD PTR [esi+48], ecx
\r
2608 000de 39 46 30 cmp DWORD PTR [esi+48], eax
\r
2609 000e1 75 07 jne SHORT $LN2@updatewind
\r
2610 000e3 c7 46 30 00 00
\r
2611 00 00 mov DWORD PTR [esi+48], 0
\r
2614 ; 422 : if (state->whave < state->wsize) state->whave += dist;
\r
2616 000ea 8b 56 2c mov edx, DWORD PTR [esi+44]
\r
2617 000ed 3b d0 cmp edx, eax
\r
2618 000ef 73 05 jae SHORT $LN1@updatewind
\r
2619 000f1 03 d1 add edx, ecx
\r
2620 000f3 89 56 2c mov DWORD PTR [esi+44], edx
\r
2628 000f7 33 c0 xor eax, eax
\r
2633 000fa 8b e5 mov esp, ebp
\r
2636 _updatewindow ENDP
\r
2637 ; Function compile flags: /Ogtp
\r
2639 ; COMDAT _fixedtables
\r
2641 _fixedtables PROC ; COMDAT
\r
2644 ; 263 : #ifdef BUILDFIXED
\r
2645 ; 264 : static int virgin = 1;
\r
2646 ; 265 : static code *lenfix, *distfix;
\r
2647 ; 266 : static code fixed[544];
\r
2649 ; 268 : /* build fixed huffman tables if first call (may not be thread safe) */
\r
2650 ; 269 : if (virgin) {
\r
2651 ; 270 : unsigned sym, bits;
\r
2652 ; 271 : static code *next;
\r
2654 ; 273 : /* literal/length table */
\r
2656 ; 275 : while (sym < 144) state->lens[sym++] = 8;
\r
2657 ; 276 : while (sym < 256) state->lens[sym++] = 9;
\r
2658 ; 277 : while (sym < 280) state->lens[sym++] = 7;
\r
2659 ; 278 : while (sym < 288) state->lens[sym++] = 8;
\r
2660 ; 279 : next = fixed;
\r
2661 ; 280 : lenfix = next;
\r
2663 ; 282 : inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
\r
2665 ; 284 : /* distance table */
\r
2667 ; 286 : while (sym < 32) state->lens[sym++] = 5;
\r
2668 ; 287 : distfix = next;
\r
2670 ; 289 : inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
\r
2672 ; 291 : /* do this just once */
\r
2673 ; 292 : virgin = 0;
\r
2675 ; 294 : #else /* !BUILDFIXED */
\r
2676 ; 295 : # include "inffixed.h"
\r
2677 ; 296 : #endif /* BUILDFIXED */
\r
2678 ; 297 : state->lencode = lenfix;
\r
2680 00000 c7 40 4c 00 00
\r
2681 00 00 mov DWORD PTR [eax+76], OFFSET ?lenfix@?1??fixedtables@@9@9
\r
2683 ; 298 : state->lenbits = 9;
\r
2685 00007 c7 40 54 09 00
\r
2686 00 00 mov DWORD PTR [eax+84], 9
\r
2688 ; 299 : state->distcode = distfix;
\r
2690 0000e c7 40 50 00 00
\r
2691 00 00 mov DWORD PTR [eax+80], OFFSET ?distfix@?1??fixedtables@@9@9
\r
2693 ; 300 : state->distbits = 5;
\r
2695 00015 c7 40 58 05 00
\r
2696 00 00 mov DWORD PTR [eax+88], 5
\r
2703 PUBLIC _inflatePrime@12
\r
2704 ; Function compile flags: /Ogtp
\r
2705 ; COMDAT _inflatePrime@12
\r
2707 _strm$ = 8 ; size = 4
\r
2708 _bits$ = 12 ; size = 4
\r
2709 _value$ = 16 ; size = 4
\r
2710 _inflatePrime@12 PROC ; COMDAT
\r
2715 00001 8b ec mov ebp, esp
\r
2717 ; 234 : struct inflate_state FAR *state;
\r
2719 ; 236 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2721 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
2722 00006 33 d2 xor edx, edx
\r
2723 00008 3b c2 cmp eax, edx
\r
2724 0000a 74 53 je SHORT $LN4@inflatePri
\r
2725 0000c 8b 40 1c mov eax, DWORD PTR [eax+28]
\r
2726 0000f 3b c2 cmp eax, edx
\r
2727 00011 74 4c je SHORT $LN4@inflatePri
\r
2729 ; 237 : state = (struct inflate_state FAR *)strm->state;
\r
2730 ; 238 : if (bits < 0) {
\r
2732 00013 8b 4d 0c mov ecx, DWORD PTR _bits$[ebp]
\r
2733 00016 3b ca cmp ecx, edx
\r
2734 00018 7d 0c jge SHORT $LN3@inflatePri
\r
2736 ; 239 : state->hold = 0;
\r
2738 0001a 89 50 38 mov DWORD PTR [eax+56], edx
\r
2740 ; 240 : state->bits = 0;
\r
2742 0001d 89 50 3c mov DWORD PTR [eax+60], edx
\r
2744 ; 241 : return Z_OK;
\r
2746 00020 33 c0 xor eax, eax
\r
2751 00023 c2 0c 00 ret 12 ; 0000000cH
\r
2756 ; 243 : if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
\r
2758 00027 83 f9 10 cmp ecx, 16 ; 00000010H
\r
2759 0002a 7f 29 jg SHORT $LN1@inflatePri
\r
2760 0002c 8b 50 3c mov edx, DWORD PTR [eax+60]
\r
2761 0002f 8d 34 0a lea esi, DWORD PTR [edx+ecx]
\r
2762 00032 83 fe 20 cmp esi, 32 ; 00000020H
\r
2763 00035 77 1e ja SHORT $LN1@inflatePri
\r
2765 ; 244 : value &= (1L << bits) - 1;
\r
2768 00038 bf 01 00 00 00 mov edi, 1
\r
2769 0003d d3 e7 shl edi, cl
\r
2771 ; 245 : state->hold += value << state->bits;
\r
2773 0003f 8b ca mov ecx, edx
\r
2775 ; 246 : state->bits += bits;
\r
2777 00041 89 70 3c mov DWORD PTR [eax+60], esi
\r
2779 00045 23 7d 10 and edi, DWORD PTR _value$[ebp]
\r
2780 00048 d3 e7 shl edi, cl
\r
2781 0004a 01 78 38 add DWORD PTR [eax+56], edi
\r
2784 ; 247 : return Z_OK;
\r
2786 0004e 33 c0 xor eax, eax
\r
2792 00052 c2 0c 00 ret 12 ; 0000000cH
\r
2796 ; 243 : if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
\r
2798 00055 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2804 0005c c2 0c 00 ret 12 ; 0000000cH
\r
2807 ; 234 : struct inflate_state FAR *state;
\r
2809 ; 236 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2811 0005f b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2816 00065 c2 0c 00 ret 12 ; 0000000cH
\r
2817 _inflatePrime@12 ENDP
\r
2819 PUBLIC _inflateResetKeep@4
\r
2820 ; Function compile flags: /Ogtp
\r
2821 ; COMDAT _inflateResetKeep@4
\r
2823 _strm$ = 8 ; size = 4
\r
2824 _inflateResetKeep@4 PROC ; COMDAT
\r
2829 00001 8b ec mov ebp, esp
\r
2831 ; 106 : struct inflate_state FAR *state;
\r
2833 ; 108 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2835 00003 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
2837 00007 33 f6 xor esi, esi
\r
2838 00009 3b ce cmp ecx, esi
\r
2839 0000b 74 62 je SHORT $LN2@inflateRes
\r
2840 0000d 8b 41 1c mov eax, DWORD PTR [ecx+28]
\r
2841 00010 3b c6 cmp eax, esi
\r
2842 00012 74 5b je SHORT $LN2@inflateRes
\r
2844 ; 109 : state = (struct inflate_state FAR *)strm->state;
\r
2845 ; 110 : strm->total_in = strm->total_out = state->total = 0;
\r
2847 00014 89 70 1c mov DWORD PTR [eax+28], esi
\r
2848 00017 89 71 14 mov DWORD PTR [ecx+20], esi
\r
2849 0001a 89 71 08 mov DWORD PTR [ecx+8], esi
\r
2851 ; 111 : strm->msg = Z_NULL;
\r
2853 0001d 89 71 18 mov DWORD PTR [ecx+24], esi
\r
2855 ; 112 : if (state->wrap) /* to support ill-conceived Java test suite */
\r
2857 00020 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2858 00023 3b d6 cmp edx, esi
\r
2859 00025 74 06 je SHORT $LN1@inflateRes
\r
2861 ; 113 : strm->adler = state->wrap & 1;
\r
2863 00027 83 e2 01 and edx, 1
\r
2864 0002a 89 51 30 mov DWORD PTR [ecx+48], edx
\r
2867 ; 114 : state->mode = HEAD;
\r
2868 ; 115 : state->last = 0;
\r
2869 ; 116 : state->havedict = 0;
\r
2870 ; 117 : state->dmax = 32768U;
\r
2871 ; 118 : state->head = Z_NULL;
\r
2872 ; 119 : state->hold = 0;
\r
2873 ; 120 : state->bits = 0;
\r
2874 ; 121 : state->lencode = state->distcode = state->next = state->codes;
\r
2876 0002d 8d 88 30 05 00
\r
2877 00 lea ecx, DWORD PTR [eax+1328]
\r
2878 00033 89 30 mov DWORD PTR [eax], esi
\r
2879 00035 89 70 04 mov DWORD PTR [eax+4], esi
\r
2880 00038 89 70 0c mov DWORD PTR [eax+12], esi
\r
2881 0003b 89 70 20 mov DWORD PTR [eax+32], esi
\r
2882 0003e 89 70 38 mov DWORD PTR [eax+56], esi
\r
2883 00041 89 70 3c mov DWORD PTR [eax+60], esi
\r
2884 00044 c7 40 14 00 80
\r
2885 00 00 mov DWORD PTR [eax+20], 32768 ; 00008000H
\r
2886 0004b 89 48 6c mov DWORD PTR [eax+108], ecx
\r
2887 0004e 89 48 50 mov DWORD PTR [eax+80], ecx
\r
2888 00051 89 48 4c mov DWORD PTR [eax+76], ecx
\r
2890 ; 122 : state->sane = 1;
\r
2892 00054 c7 80 c0 1b 00
\r
2893 00 01 00 00 00 mov DWORD PTR [eax+7104], 1
\r
2895 ; 123 : state->back = -1;
\r
2897 0005e c7 80 c4 1b 00
\r
2898 00 ff ff ff ff mov DWORD PTR [eax+7108], -1
\r
2900 ; 124 : Tracev((stderr, "inflate: reset\n"));
\r
2901 ; 125 : return Z_OK;
\r
2903 00068 33 c0 xor eax, eax
\r
2909 0006c c2 04 00 ret 4
\r
2912 ; 106 : struct inflate_state FAR *state;
\r
2914 ; 108 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2916 0006f b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2922 00076 c2 04 00 ret 4
\r
2923 _inflateResetKeep@4 ENDP
\r
2924 PUBLIC _inflateSetDictionary@12
\r
2925 ; Function compile flags: /Ogtp
\r
2926 ; COMDAT _inflateSetDictionary@12
\r
2928 _avail$ = 8 ; size = 4
\r
2929 _strm$ = 8 ; size = 4
\r
2930 _dictionary$ = 12 ; size = 4
\r
2931 _next$ = 16 ; size = 4
\r
2932 _dictLength$ = 16 ; size = 4
\r
2933 _inflateSetDictionary@12 PROC ; COMDAT
\r
2938 00001 8b ec mov ebp, esp
\r
2941 ; 1277 : struct inflate_state FAR *state;
\r
2942 ; 1278 : unsigned long id;
\r
2943 ; 1279 : unsigned char *next;
\r
2944 ; 1280 : unsigned avail;
\r
2947 ; 1283 : /* check state */
\r
2948 ; 1284 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
2950 00004 8b 5d 08 mov ebx, DWORD PTR _strm$[ebp]
\r
2952 00008 85 db test ebx, ebx
\r
2953 0000a 0f 84 a6 00 00
\r
2954 00 je $LN5@inflateSet
\r
2955 00010 8b 7b 1c mov edi, DWORD PTR [ebx+28]
\r
2956 00013 85 ff test edi, edi
\r
2957 00015 0f 84 9b 00 00
\r
2958 00 je $LN5@inflateSet
\r
2960 ; 1285 : state = (struct inflate_state FAR *)strm->state;
\r
2961 ; 1286 : if (state->wrap != 0 && state->mode != DICT)
\r
2963 0001b 83 7f 08 00 cmp DWORD PTR [edi+8], 0
\r
2965 00020 8b 75 10 mov esi, DWORD PTR _dictLength$[ebp]
\r
2966 00023 74 11 je SHORT $LN4@inflateSet
\r
2967 00025 83 3f 0a cmp DWORD PTR [edi], 10 ; 0000000aH
\r
2968 00028 74 11 je SHORT $LN9@inflateSet
\r
2970 ; 1287 : return Z_STREAM_ERROR;
\r
2974 0002c b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
2980 00033 c2 0c 00 ret 12 ; 0000000cH
\r
2984 ; 1289 : /* check for correct dictionary id */
\r
2985 ; 1290 : if (state->mode == DICT) {
\r
2987 00036 83 3f 0a cmp DWORD PTR [edi], 10 ; 0000000aH
\r
2988 00039 75 27 jne SHORT $LN10@inflateSet
\r
2991 ; 1291 : id = adler32(0L, Z_NULL, 0);
\r
2992 ; 1292 : id = adler32(id, dictionary, dictLength);
\r
2994 0003b 8b 45 0c mov eax, DWORD PTR _dictionary$[ebp]
\r
2997 00040 6a 00 push 0
\r
2998 00042 6a 00 push 0
\r
2999 00044 6a 00 push 0
\r
3000 00046 e8 00 00 00 00 call _adler32@12
\r
3002 0004c e8 00 00 00 00 call _adler32@12
\r
3004 ; 1293 : if (id != state->check)
\r
3006 00051 3b 47 18 cmp eax, DWORD PTR [edi+24]
\r
3007 00054 74 0c je SHORT $LN10@inflateSet
\r
3009 ; 1294 : return Z_DATA_ERROR;
\r
3013 00058 b8 fd ff ff ff mov eax, -3 ; fffffffdH
\r
3019 0005f c2 0c 00 ret 12 ; 0000000cH
\r
3024 ; 1297 : /* copy dictionary to window using updatewindow(), which will amend the
\r
3025 ; 1298 : existing dictionary if appropriate */
\r
3026 ; 1299 : next = strm->next_out;
\r
3027 ; 1300 : avail = strm->avail_out;
\r
3028 ; 1301 : strm->next_out = (Bytef *)dictionary + dictLength;
\r
3030 00062 8b 45 0c mov eax, DWORD PTR _dictionary$[ebp]
\r
3031 00065 8b 4b 0c mov ecx, DWORD PTR [ebx+12]
\r
3032 00068 8b 53 10 mov edx, DWORD PTR [ebx+16]
\r
3033 0006b 03 c6 add eax, esi
\r
3034 0006d 89 43 0c mov DWORD PTR [ebx+12], eax
\r
3036 ; 1302 : strm->avail_out = 0;
\r
3037 ; 1303 : ret = updatewindow(strm, dictLength);
\r
3039 00070 8b c6 mov eax, esi
\r
3040 00072 89 4d 10 mov DWORD PTR _next$[ebp], ecx
\r
3041 00075 89 55 08 mov DWORD PTR _avail$[ebp], edx
\r
3042 00078 c7 43 10 00 00
\r
3043 00 00 mov DWORD PTR [ebx+16], 0
\r
3044 0007f e8 00 00 00 00 call _updatewindow
\r
3046 ; 1304 : strm->avail_out = avail;
\r
3048 00084 8b 4d 08 mov ecx, DWORD PTR _avail$[ebp]
\r
3050 ; 1305 : strm->next_out = next;
\r
3052 00087 8b 55 10 mov edx, DWORD PTR _next$[ebp]
\r
3053 0008a 89 4b 10 mov DWORD PTR [ebx+16], ecx
\r
3054 0008d 89 53 0c mov DWORD PTR [ebx+12], edx
\r
3056 ; 1306 : if (ret) {
\r
3058 00090 85 c0 test eax, eax
\r
3059 00092 74 12 je SHORT $LN1@inflateSet
\r
3061 ; 1307 : state->mode = MEM;
\r
3064 00095 c7 07 1e 00 00
\r
3065 00 mov DWORD PTR [edi], 30 ; 0000001eH
\r
3068 ; 1308 : return Z_MEM_ERROR;
\r
3070 0009c b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
3076 000a3 c2 0c 00 ret 12 ; 0000000cH
\r
3081 ; 1310 : state->havedict = 1;
\r
3083 000a7 c7 47 0c 01 00
\r
3084 00 00 mov DWORD PTR [edi+12], 1
\r
3087 ; 1311 : Tracev((stderr, "inflate: dictionary set\n"));
\r
3088 ; 1312 : return Z_OK;
\r
3090 000af 33 c0 xor eax, eax
\r
3096 000b3 c2 0c 00 ret 12 ; 0000000cH
\r
3100 ; 1277 : struct inflate_state FAR *state;
\r
3101 ; 1278 : unsigned long id;
\r
3102 ; 1279 : unsigned char *next;
\r
3103 ; 1280 : unsigned avail;
\r
3106 ; 1283 : /* check state */
\r
3107 ; 1284 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
3109 000b7 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
3115 000be c2 0c 00 ret 12 ; 0000000cH
\r
3116 _inflateSetDictionary@12 ENDP
\r
3119 ; Function compile flags: /Ogtp
\r
3120 ; COMDAT _inflate@8
\r
3122 _in$ = -48 ; size = 4
\r
3123 tv3076 = -44 ; size = 4
\r
3124 tv2368 = -44 ; size = 4
\r
3125 tv2363 = -44 ; size = 4
\r
3126 tv2303 = -44 ; size = 4
\r
3127 tv2288 = -44 ; size = 4
\r
3128 tv2173 = -44 ; size = 4
\r
3129 tv2157 = -44 ; size = 4
\r
3130 tv2134 = -44 ; size = 4
\r
3131 _from$ = -44 ; size = 4
\r
3132 _ret$ = -40 ; size = 4
\r
3133 tv2314 = -36 ; size = 4
\r
3134 tv2131 = -36 ; size = 4
\r
3135 _last$ = -36 ; size = 4
\r
3136 _out$ = -32 ; size = 4
\r
3137 tv2387 = -28 ; size = 4
\r
3138 tv2366 = -28 ; size = 4
\r
3139 tv2361 = -28 ; size = 4
\r
3140 tv2289 = -28 ; size = 4
\r
3141 _len$ = -28 ; size = 4
\r
3142 _put$ = -24 ; size = 4
\r
3143 _hbuf$ = -20 ; size = 4
\r
3144 _left$ = -16 ; size = 4
\r
3145 _here$ = -12 ; size = 4
\r
3146 _copy$ = -12 ; size = 4
\r
3147 _next$ = -8 ; size = 4
\r
3148 _have$ = -4 ; size = 4
\r
3149 tv1321 = 8 ; size = 4
\r
3150 _strm$ = 8 ; size = 4
\r
3151 _flush$ = 12 ; size = 4
\r
3152 _inflate@8 PROC ; COMDAT
\r
3157 00001 8b ec mov ebp, esp
\r
3159 ; 613 : struct inflate_state FAR *state;
\r
3160 ; 614 : unsigned char FAR *next; /* next input */
\r
3161 ; 615 : unsigned char FAR *put; /* next output */
\r
3162 ; 616 : unsigned have, left; /* available input and output */
\r
3163 ; 617 : unsigned long hold; /* bit buffer */
\r
3164 ; 618 : unsigned bits; /* bits in bit buffer */
\r
3165 ; 619 : unsigned in, out; /* save starting available input and output */
\r
3166 ; 620 : unsigned copy; /* number of stored or match bytes to copy */
\r
3167 ; 621 : unsigned char FAR *from; /* where to copy match bytes from */
\r
3168 ; 622 : code here; /* current decoding table entry */
\r
3169 ; 623 : code last; /* parent table entry */
\r
3170 ; 624 : unsigned len; /* length to copy for repeats, bits to drop */
\r
3171 ; 625 : int ret; /* return code */
\r
3172 ; 626 : #ifdef GUNZIP
\r
3173 ; 627 : unsigned char hbuf[4]; /* buffer for gzip header crc calculation */
\r
3175 ; 629 : static const unsigned short order[19] = /* permutation of code lengths */
\r
3176 ; 630 : {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
\r
3178 ; 632 : if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
\r
3179 ; 633 : (strm->next_in == Z_NULL && strm->avail_in != 0))
\r
3181 00003 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
3182 00006 83 ec 30 sub esp, 48 ; 00000030H
\r
3184 0000a 85 c0 test eax, eax
\r
3185 0000c 0f 84 48 14 00
\r
3186 00 je $LN498@inflate
\r
3187 00012 8b 78 1c mov edi, DWORD PTR [eax+28]
\r
3188 00015 85 ff test edi, edi
\r
3189 00017 0f 84 3d 14 00
\r
3190 00 je $LN498@inflate
\r
3191 0001d 83 78 0c 00 cmp DWORD PTR [eax+12], 0
\r
3192 00021 0f 84 33 14 00
\r
3193 00 je $LN498@inflate
\r
3194 00027 83 38 00 cmp DWORD PTR [eax], 0
\r
3195 0002a 75 0a jne SHORT $LN499@inflate
\r
3196 0002c 83 78 04 00 cmp DWORD PTR [eax+4], 0
\r
3197 00030 0f 85 24 14 00
\r
3198 00 jne $LN498@inflate
\r
3202 ; 636 : state = (struct inflate_state FAR *)strm->state;
\r
3203 ; 637 : if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */
\r
3205 00036 83 3f 0b cmp DWORD PTR [edi], 11 ; 0000000bH
\r
3206 00039 75 06 jne SHORT $LN496@inflate
\r
3207 0003b c7 07 0c 00 00
\r
3208 00 mov DWORD PTR [edi], 12 ; 0000000cH
\r
3213 00041 8b 48 0c mov ecx, DWORD PTR [eax+12]
\r
3214 00044 8b 10 mov edx, DWORD PTR [eax]
\r
3215 00046 89 4d e8 mov DWORD PTR _put$[ebp], ecx
\r
3216 00049 8b 48 10 mov ecx, DWORD PTR [eax+16]
\r
3217 0004c 8b 40 04 mov eax, DWORD PTR [eax+4]
\r
3219 00050 8b 5f 38 mov ebx, DWORD PTR [edi+56]
\r
3220 00053 89 45 fc mov DWORD PTR _have$[ebp], eax
\r
3222 ; 639 : in = have;
\r
3224 00056 89 45 d0 mov DWORD PTR _in$[ebp], eax
\r
3226 ; 640 : out = left;
\r
3227 ; 641 : ret = Z_OK;
\r
3229 ; 643 : switch (state->mode) {
\r
3231 00059 8b 07 mov eax, DWORD PTR [edi]
\r
3233 0005c 8b 77 3c mov esi, DWORD PTR [edi+60]
\r
3234 0005f 89 4d f0 mov DWORD PTR _left$[ebp], ecx
\r
3235 00062 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3236 00065 89 4d e0 mov DWORD PTR _out$[ebp], ecx
\r
3237 00068 c7 45 d8 00 00
\r
3238 00 00 mov DWORD PTR _ret$[ebp], 0
\r
3239 0006f 83 f8 1e cmp eax, 30 ; 0000001eH
\r
3240 00072 0f 87 6a 12 00
\r
3241 00 ja $LN12@inflate
\r
3243 00078 ff 24 85 00 00
\r
3244 00 00 jmp DWORD PTR $LN787@inflate[eax*4]
\r
3247 ; 644 : case HEAD:
\r
3248 ; 645 : if (state->wrap == 0) {
\r
3250 0007f 8b 47 08 mov eax, DWORD PTR [edi+8]
\r
3251 00082 85 c0 test eax, eax
\r
3252 00084 75 0b jne SHORT $LN487@inflate
\r
3254 ; 646 : state->mode = TYPEDO;
\r
3256 00086 c7 07 0c 00 00
\r
3257 00 mov DWORD PTR [edi], 12 ; 0000000cH
\r
3261 0008c e9 46 12 00 00 jmp $LN490@inflate
\r
3265 ; 649 : NEEDBITS(16);
\r
3267 00091 83 fe 10 cmp esi, 16 ; 00000010H
\r
3268 00094 73 22 jae SHORT $LN486@inflate
\r
3270 00096 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3271 0009a 0f 84 95 12 00
\r
3272 00 je $inf_leave$80408
\r
3273 000a0 0f b6 02 movzx eax, BYTE PTR [edx]
\r
3274 000a3 ff 4d fc dec DWORD PTR _have$[ebp]
\r
3275 000a6 8b ce mov ecx, esi
\r
3276 000a8 d3 e0 shl eax, cl
\r
3278 000ab 83 c6 08 add esi, 8
\r
3279 000ae 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3280 000b1 03 d8 add ebx, eax
\r
3281 000b3 83 fe 10 cmp esi, 16 ; 00000010H
\r
3282 000b6 72 de jb SHORT $LL484@inflate
\r
3285 ; 650 : #ifdef GUNZIP
\r
3286 ; 651 : if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
\r
3288 000b8 f6 47 08 02 test BYTE PTR [edi+8], 2
\r
3289 000bc 74 3b je SHORT $LN478@inflate
\r
3290 000be 81 fb 1f 8b 00
\r
3291 00 cmp ebx, 35615 ; 00008b1fH
\r
3292 000c4 75 33 jne SHORT $LN478@inflate
\r
3294 ; 652 : state->check = crc32(0L, Z_NULL, 0);
\r
3296 000c6 6a 00 push 0
\r
3297 000c8 6a 00 push 0
\r
3298 000ca 6a 00 push 0
\r
3299 000cc e8 00 00 00 00 call _crc32@12
\r
3301 ; 653 : CRC2(state->check, hold);
\r
3303 000d1 6a 02 push 2
\r
3304 000d3 8d 4d ec lea ecx, DWORD PTR _hbuf$[ebp]
\r
3307 000d8 89 47 18 mov DWORD PTR [edi+24], eax
\r
3308 000db 66 89 5d ec mov WORD PTR _hbuf$[ebp], bx
\r
3309 000df e8 00 00 00 00 call _crc32@12
\r
3311 ; 654 : INITBITS();
\r
3312 ; 655 : state->mode = FLAGS;
\r
3315 000e4 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3316 000e7 33 db xor ebx, ebx
\r
3317 000e9 89 47 18 mov DWORD PTR [edi+24], eax
\r
3318 000ec 33 f6 xor esi, esi
\r
3319 000ee c7 07 01 00 00
\r
3320 00 mov DWORD PTR [edi], 1
\r
3321 000f4 e9 de 11 00 00 jmp $LN490@inflate
\r
3325 ; 658 : state->flags = 0; /* expect zlib header */
\r
3326 ; 659 : if (state->head != Z_NULL)
\r
3328 000f9 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3329 000fc c7 47 10 00 00
\r
3330 00 00 mov DWORD PTR [edi+16], 0
\r
3331 00103 85 c0 test eax, eax
\r
3332 00105 74 07 je SHORT $LN471@inflate
\r
3334 ; 660 : state->head->done = -1;
\r
3336 00107 c7 40 30 ff ff
\r
3337 ff ff mov DWORD PTR [eax+48], -1
\r
3340 ; 661 : if (!(state->wrap & 1) || /* check if zlib header allowed */
\r
3344 ; 665 : ((BITS(8) << 8) + (hold >> 8)) % 31) {
\r
3346 0010e f6 47 08 01 test BYTE PTR [edi+8], 1
\r
3347 00112 0f 84 9f 00 00
\r
3348 00 je $LN469@inflate
\r
3349 00118 0f b6 c3 movzx eax, bl
\r
3350 0011b c1 e0 08 shl eax, 8
\r
3351 0011e 8b d3 mov edx, ebx
\r
3352 00120 c1 ea 08 shr edx, 8
\r
3353 00123 03 c2 add eax, edx
\r
3354 00125 33 d2 xor edx, edx
\r
3355 00127 b9 1f 00 00 00 mov ecx, 31 ; 0000001fH
\r
3356 0012c f7 f1 div ecx
\r
3357 0012e 85 d2 test edx, edx
\r
3358 00130 0f 85 81 00 00
\r
3359 00 jne $LN469@inflate
\r
3362 ; 670 : if (BITS(4) != Z_DEFLATED) {
\r
3364 00136 8b d3 mov edx, ebx
\r
3365 00138 80 e2 0f and dl, 15 ; 0000000fH
\r
3366 0013b 80 fa 08 cmp dl, 8
\r
3367 0013e 74 12 je SHORT $LN467@inflate
\r
3369 ; 671 : strm->msg = (char *)"unknown compression method";
\r
3371 00140 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
3373 ; 672 : state->mode = BAD;
\r
3376 00143 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3377 00146 c7 40 18 00 00
\r
3378 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@
\r
3379 0014d e9 7f 11 00 00 jmp $LN786@inflate
\r
3383 ; 675 : DROPBITS(4);
\r
3384 ; 676 : len = BITS(4) + 8;
\r
3385 ; 677 : if (state->wbits == 0)
\r
3387 00152 8b 47 24 mov eax, DWORD PTR [edi+36]
\r
3388 00155 c1 eb 04 shr ebx, 4
\r
3389 00158 8b cb mov ecx, ebx
\r
3390 0015a 83 e1 0f and ecx, 15 ; 0000000fH
\r
3391 0015d 83 ee 04 sub esi, 4
\r
3392 00160 83 c1 08 add ecx, 8
\r
3393 00163 85 c0 test eax, eax
\r
3394 00165 75 3a jne SHORT $LN464@inflate
\r
3396 ; 678 : state->wbits = len;
\r
3398 00167 89 4f 24 mov DWORD PTR [edi+36], ecx
\r
3402 ; 684 : state->dmax = 1U << len;
\r
3404 0016a ba 01 00 00 00 mov edx, 1
\r
3406 ; 685 : Tracev((stderr, "inflate: zlib header ok\n"));
\r
3407 ; 686 : strm->adler = state->check = adler32(0L, Z_NULL, 0);
\r
3409 0016f 6a 00 push 0
\r
3410 00171 d3 e2 shl edx, cl
\r
3411 00173 6a 00 push 0
\r
3412 00175 6a 00 push 0
\r
3413 00177 89 57 14 mov DWORD PTR [edi+20], edx
\r
3414 0017a e8 00 00 00 00 call _adler32@12
\r
3415 0017f 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
3417 ; 687 : state->mode = hold & 0x200 ? DICTID : TYPE;
\r
3418 ; 688 : INITBITS();
\r
3421 00182 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3422 00185 c1 eb 08 shr ebx, 8
\r
3423 00188 f7 d3 not ebx
\r
3424 0018a 83 e3 02 and ebx, 2
\r
3425 0018d 83 cb 09 or ebx, 9
\r
3426 00190 89 47 18 mov DWORD PTR [edi+24], eax
\r
3427 00193 89 41 30 mov DWORD PTR [ecx+48], eax
\r
3428 00196 89 1f mov DWORD PTR [edi], ebx
\r
3429 00198 33 db xor ebx, ebx
\r
3430 0019a 33 f6 xor esi, esi
\r
3431 0019c e9 36 11 00 00 jmp $LN490@inflate
\r
3434 ; 679 : else if (len > state->wbits) {
\r
3436 001a1 3b c8 cmp ecx, eax
\r
3437 001a3 76 c5 jbe SHORT $LN462@inflate
\r
3439 ; 680 : strm->msg = (char *)"invalid window size";
\r
3441 001a5 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
3443 ; 681 : state->mode = BAD;
\r
3446 001a8 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3447 001ab c7 41 18 00 00
\r
3448 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BE@EMOGCLGO@invalid?5window?5size?$AA@
\r
3449 001b2 e9 1a 11 00 00 jmp $LN786@inflate
\r
3452 ; 666 : strm->msg = (char *)"incorrect header check";
\r
3454 001b7 8b 55 08 mov edx, DWORD PTR _strm$[ebp]
\r
3455 001ba c7 42 18 00 00
\r
3456 00 00 mov DWORD PTR [edx+24], OFFSET ??_C@_0BH@LIBMMIGA@incorrect?5header?5check?$AA@
\r
3458 ; 667 : state->mode = BAD;
\r
3461 001c1 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3462 001c4 e9 08 11 00 00 jmp $LN786@inflate
\r
3465 ; 690 : #ifdef GUNZIP
\r
3466 ; 691 : case FLAGS:
\r
3467 ; 692 : NEEDBITS(16);
\r
3469 001c9 83 fe 10 cmp esi, 16 ; 00000010H
\r
3470 001cc 73 24 jae SHORT $LN456@inflate
\r
3471 001ce 8b ff npad 2
\r
3473 001d0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3474 001d4 0f 84 5b 11 00
\r
3475 00 je $inf_leave$80408
\r
3476 001da 0f b6 02 movzx eax, BYTE PTR [edx]
\r
3477 001dd ff 4d fc dec DWORD PTR _have$[ebp]
\r
3478 001e0 8b ce mov ecx, esi
\r
3479 001e2 d3 e0 shl eax, cl
\r
3481 001e5 83 c6 08 add esi, 8
\r
3482 001e8 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3483 001eb 03 d8 add ebx, eax
\r
3484 001ed 83 fe 10 cmp esi, 16 ; 00000010H
\r
3485 001f0 72 de jb SHORT $LL454@inflate
\r
3488 ; 693 : state->flags = (int)(hold);
\r
3490 001f2 89 5f 10 mov DWORD PTR [edi+16], ebx
\r
3492 ; 694 : if ((state->flags & 0xff) != Z_DEFLATED) {
\r
3494 001f5 80 fb 08 cmp bl, 8
\r
3495 001f8 74 0f je SHORT $LN448@inflate
\r
3497 ; 695 : strm->msg = (char *)"unknown compression method";
\r
3499 001fa 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
3500 001fd c7 41 18 00 00
\r
3501 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BL@IHKGDAEE@unknown?5compression?5method?$AA@
\r
3503 ; 696 : state->mode = BAD;
\r
3506 00204 e9 c8 10 00 00 jmp $LN786@inflate
\r
3510 ; 699 : if (state->flags & 0xe000) {
\r
3512 00209 f7 c3 00 e0 00
\r
3513 00 test ebx, 57344 ; 0000e000H
\r
3514 0020f 74 0f je SHORT $LN447@inflate
\r
3516 ; 700 : strm->msg = (char *)"unknown header flags set";
\r
3518 00211 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
3519 00214 c7 40 18 00 00
\r
3520 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BJ@BLBBCOMO@unknown?5header?5flags?5set?$AA@
\r
3522 ; 701 : state->mode = BAD;
\r
3525 0021b e9 b1 10 00 00 jmp $LN786@inflate
\r
3529 ; 704 : if (state->head != Z_NULL)
\r
3531 00220 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3532 00223 85 c0 test eax, eax
\r
3533 00225 74 0a je SHORT $LN446@inflate
\r
3535 ; 705 : state->head->text = (int)((hold >> 8) & 1);
\r
3537 00227 8b cb mov ecx, ebx
\r
3538 00229 c1 e9 08 shr ecx, 8
\r
3539 0022c 83 e1 01 and ecx, 1
\r
3540 0022f 89 08 mov DWORD PTR [eax], ecx
\r
3543 ; 706 : if (state->flags & 0x0200) CRC2(state->check, hold);
\r
3545 00231 f7 47 10 00 02
\r
3546 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3547 00238 74 1e je SHORT $LN442@inflate
\r
3548 0023a 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
3549 0023d 6a 02 push 2
\r
3550 0023f 8d 55 ec lea edx, DWORD PTR _hbuf$[ebp]
\r
3551 00242 88 5d ec mov BYTE PTR _hbuf$[ebp], bl
\r
3553 00246 c1 eb 08 shr ebx, 8
\r
3555 0024a 88 5d ed mov BYTE PTR _hbuf$[ebp+1], bl
\r
3556 0024d e8 00 00 00 00 call _crc32@12
\r
3557 00252 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3558 00255 89 47 18 mov DWORD PTR [edi+24], eax
\r
3561 ; 707 : INITBITS();
\r
3563 00258 33 db xor ebx, ebx
\r
3564 0025a 33 f6 xor esi, esi
\r
3566 ; 708 : state->mode = TIME;
\r
3568 0025c c7 07 02 00 00
\r
3569 00 mov DWORD PTR [edi], 2
\r
3571 ; 709 : case TIME:
\r
3572 ; 710 : NEEDBITS(32);
\r
3574 00262 eb 0c jmp SHORT $LL434@inflate
\r
3576 00264 83 fe 20 cmp esi, 32 ; 00000020H
\r
3577 00267 73 29 jae SHORT $LN436@inflate
\r
3578 00269 8d a4 24 00 00
\r
3581 00270 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3582 00274 0f 84 bb 10 00
\r
3583 00 je $inf_leave$80408
\r
3584 0027a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
3585 0027d ff 4d fc dec DWORD PTR _have$[ebp]
\r
3586 00280 8b ce mov ecx, esi
\r
3587 00282 d3 e0 shl eax, cl
\r
3589 00285 83 c6 08 add esi, 8
\r
3590 00288 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3591 0028b 03 d8 add ebx, eax
\r
3592 0028d 83 fe 20 cmp esi, 32 ; 00000020H
\r
3593 00290 72 de jb SHORT $LL434@inflate
\r
3596 ; 711 : if (state->head != Z_NULL)
\r
3598 00292 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3599 00295 85 c0 test eax, eax
\r
3600 00297 74 03 je SHORT $LN428@inflate
\r
3602 ; 712 : state->head->time = hold;
\r
3604 00299 89 58 04 mov DWORD PTR [eax+4], ebx
\r
3607 ; 713 : if (state->flags & 0x0200) CRC4(state->check, hold);
\r
3609 0029c f7 47 10 00 02
\r
3610 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3611 002a3 74 2e je SHORT $LN424@inflate
\r
3612 002a5 8b cb mov ecx, ebx
\r
3613 002a7 c1 e9 08 shr ecx, 8
\r
3614 002aa 6a 04 push 4
\r
3615 002ac 8d 45 ec lea eax, DWORD PTR _hbuf$[ebp]
\r
3616 002af 88 4d ed mov BYTE PTR _hbuf$[ebp+1], cl
\r
3617 002b2 8b 4f 18 mov ecx, DWORD PTR [edi+24]
\r
3618 002b5 8b d3 mov edx, ebx
\r
3619 002b7 88 5d ec mov BYTE PTR _hbuf$[ebp], bl
\r
3621 002bb c1 ea 10 shr edx, 16 ; 00000010H
\r
3622 002be c1 eb 18 shr ebx, 24 ; 00000018H
\r
3624 002c2 88 55 ee mov BYTE PTR _hbuf$[ebp+2], dl
\r
3625 002c5 88 5d ef mov BYTE PTR _hbuf$[ebp+3], bl
\r
3626 002c8 e8 00 00 00 00 call _crc32@12
\r
3627 002cd 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3628 002d0 89 47 18 mov DWORD PTR [edi+24], eax
\r
3631 ; 714 : INITBITS();
\r
3633 002d3 33 db xor ebx, ebx
\r
3634 002d5 33 f6 xor esi, esi
\r
3636 ; 715 : state->mode = OS;
\r
3638 002d7 c7 07 03 00 00
\r
3639 00 mov DWORD PTR [edi], 3
\r
3642 ; 717 : NEEDBITS(16);
\r
3644 002dd eb 05 jmp SHORT $LL416@inflate
\r
3646 002df 83 fe 10 cmp esi, 16 ; 00000010H
\r
3647 002e2 73 22 jae SHORT $LN418@inflate
\r
3649 002e4 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3650 002e8 0f 84 47 10 00
\r
3651 00 je $inf_leave$80408
\r
3652 002ee 0f b6 02 movzx eax, BYTE PTR [edx]
\r
3653 002f1 ff 4d fc dec DWORD PTR _have$[ebp]
\r
3654 002f4 8b ce mov ecx, esi
\r
3655 002f6 d3 e0 shl eax, cl
\r
3657 002f9 83 c6 08 add esi, 8
\r
3658 002fc 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3659 002ff 03 d8 add ebx, eax
\r
3660 00301 83 fe 10 cmp esi, 16 ; 00000010H
\r
3661 00304 72 de jb SHORT $LL416@inflate
\r
3664 ; 718 : if (state->head != Z_NULL) {
\r
3666 00306 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3667 00309 85 c0 test eax, eax
\r
3668 0030b 74 16 je SHORT $LN410@inflate
\r
3670 ; 719 : state->head->xflags = (int)(hold & 0xff);
\r
3672 0030d 8b cb mov ecx, ebx
\r
3673 0030f 81 e1 ff 00 00
\r
3674 00 and ecx, 255 ; 000000ffH
\r
3675 00315 89 48 08 mov DWORD PTR [eax+8], ecx
\r
3677 ; 720 : state->head->os = (int)(hold >> 8);
\r
3679 00318 8b 4f 20 mov ecx, DWORD PTR [edi+32]
\r
3680 0031b 8b c3 mov eax, ebx
\r
3681 0031d c1 e8 08 shr eax, 8
\r
3682 00320 89 41 0c mov DWORD PTR [ecx+12], eax
\r
3686 ; 722 : if (state->flags & 0x0200) CRC2(state->check, hold);
\r
3688 00323 f7 47 10 00 02
\r
3689 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3690 0032a 74 1e je SHORT $LN406@inflate
\r
3691 0032c 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
3692 0032f 6a 02 push 2
\r
3693 00331 8d 55 ec lea edx, DWORD PTR _hbuf$[ebp]
\r
3694 00334 88 5d ec mov BYTE PTR _hbuf$[ebp], bl
\r
3696 00338 c1 eb 08 shr ebx, 8
\r
3698 0033c 88 5d ed mov BYTE PTR _hbuf$[ebp+1], bl
\r
3699 0033f e8 00 00 00 00 call _crc32@12
\r
3700 00344 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3701 00347 89 47 18 mov DWORD PTR [edi+24], eax
\r
3704 ; 723 : INITBITS();
\r
3706 0034a 33 db xor ebx, ebx
\r
3707 0034c 33 f6 xor esi, esi
\r
3709 ; 724 : state->mode = EXLEN;
\r
3711 0034e c7 07 04 00 00
\r
3712 00 mov DWORD PTR [edi], 4
\r
3715 ; 725 : case EXLEN:
\r
3716 ; 726 : if (state->flags & 0x0400) {
\r
3718 00354 f7 47 10 00 04
\r
3719 00 00 test DWORD PTR [edi+16], 1024 ; 00000400H
\r
3720 0035b 74 61 je SHORT $LN401@inflate
\r
3722 ; 727 : NEEDBITS(16);
\r
3724 0035d 83 fe 10 cmp esi, 16 ; 00000010H
\r
3725 00360 73 22 jae SHORT $LN399@inflate
\r
3727 00362 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3728 00366 0f 84 c9 0f 00
\r
3729 00 je $inf_leave$80408
\r
3730 0036c 0f b6 02 movzx eax, BYTE PTR [edx]
\r
3731 0036f ff 4d fc dec DWORD PTR _have$[ebp]
\r
3732 00372 8b ce mov ecx, esi
\r
3733 00374 d3 e0 shl eax, cl
\r
3735 00377 83 c6 08 add esi, 8
\r
3736 0037a 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3737 0037d 03 d8 add ebx, eax
\r
3738 0037f 83 fe 10 cmp esi, 16 ; 00000010H
\r
3739 00382 72 de jb SHORT $LL397@inflate
\r
3742 ; 728 : state->length = (unsigned)(hold);
\r
3743 ; 729 : if (state->head != Z_NULL)
\r
3745 00384 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3746 00387 89 5f 40 mov DWORD PTR [edi+64], ebx
\r
3747 0038a 85 c0 test eax, eax
\r
3748 0038c 74 03 je SHORT $LN391@inflate
\r
3750 ; 730 : state->head->extra_len = (unsigned)hold;
\r
3752 0038e 89 58 14 mov DWORD PTR [eax+20], ebx
\r
3755 ; 731 : if (state->flags & 0x0200) CRC2(state->check, hold);
\r
3757 00391 f7 47 10 00 02
\r
3758 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3759 00398 74 1e je SHORT $LN387@inflate
\r
3760 0039a 8b 57 18 mov edx, DWORD PTR [edi+24]
\r
3761 0039d 6a 02 push 2
\r
3762 0039f 8d 4d ec lea ecx, DWORD PTR _hbuf$[ebp]
\r
3763 003a2 88 5d ec mov BYTE PTR _hbuf$[ebp], bl
\r
3765 003a6 c1 eb 08 shr ebx, 8
\r
3767 003aa 88 5d ed mov BYTE PTR _hbuf$[ebp+1], bl
\r
3768 003ad e8 00 00 00 00 call _crc32@12
\r
3769 003b2 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3770 003b5 89 47 18 mov DWORD PTR [edi+24], eax
\r
3773 ; 732 : INITBITS();
\r
3775 003b8 33 db xor ebx, ebx
\r
3776 003ba 33 f6 xor esi, esi
\r
3779 ; 734 : else if (state->head != Z_NULL)
\r
3781 003bc eb 0e jmp SHORT $LN382@inflate
\r
3783 003be 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3784 003c1 85 c0 test eax, eax
\r
3785 003c3 74 07 je SHORT $LN382@inflate
\r
3787 ; 735 : state->head->extra = Z_NULL;
\r
3789 003c5 c7 40 10 00 00
\r
3790 00 00 mov DWORD PTR [eax+16], 0
\r
3793 ; 736 : state->mode = EXTRA;
\r
3795 003cc c7 07 05 00 00
\r
3796 00 mov DWORD PTR [edi], 5
\r
3799 ; 737 : case EXTRA:
\r
3800 ; 738 : if (state->flags & 0x0400) {
\r
3802 003d2 f7 47 10 00 04
\r
3803 00 00 test DWORD PTR [edi+16], 1024 ; 00000400H
\r
3804 003d9 0f 84 93 00 00
\r
3805 00 je $LN375@inflate
\r
3807 ; 739 : copy = state->length;
\r
3809 003df 8b 47 40 mov eax, DWORD PTR [edi+64]
\r
3811 ; 740 : if (copy > have) copy = have;
\r
3813 003e2 8b 4d fc mov ecx, DWORD PTR _have$[ebp]
\r
3814 003e5 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
3815 003e8 3b c1 cmp eax, ecx
\r
3816 003ea 76 05 jbe SHORT $LN379@inflate
\r
3817 003ec 8b c1 mov eax, ecx
\r
3818 003ee 89 4d f4 mov DWORD PTR _copy$[ebp], ecx
\r
3821 ; 741 : if (copy) {
\r
3823 003f1 85 c0 test eax, eax
\r
3824 003f3 74 73 je SHORT $LN378@inflate
\r
3826 ; 742 : if (state->head != Z_NULL &&
\r
3827 ; 743 : state->head->extra != Z_NULL) {
\r
3829 003f5 8b 4f 20 mov ecx, DWORD PTR [edi+32]
\r
3830 003f8 85 c9 test ecx, ecx
\r
3831 003fa 74 3e je SHORT $LN750@inflate
\r
3832 003fc 8b 49 10 mov ecx, DWORD PTR [ecx+16]
\r
3833 003ff 89 4d d4 mov DWORD PTR tv2134[ebp], ecx
\r
3834 00402 85 c9 test ecx, ecx
\r
3835 00404 74 34 je SHORT $LN750@inflate
\r
3837 ; 744 : len = state->head->extra_len - state->length;
\r
3839 00406 8b 57 20 mov edx, DWORD PTR [edi+32]
\r
3840 00409 8b 4a 14 mov ecx, DWORD PTR [edx+20]
\r
3841 0040c 2b 4f 40 sub ecx, DWORD PTR [edi+64]
\r
3843 ; 745 : zmemcpy(state->head->extra + len, next,
\r
3844 ; 746 : len + copy > state->head->extra_max ?
\r
3845 ; 747 : state->head->extra_max - len : copy);
\r
3847 0040f 8b 52 18 mov edx, DWORD PTR [edx+24]
\r
3848 00412 89 4d e4 mov DWORD PTR _len$[ebp], ecx
\r
3849 00415 03 c8 add ecx, eax
\r
3850 00417 3b ca cmp ecx, edx
\r
3851 00419 76 05 jbe SHORT $LN502@inflate
\r
3852 0041b 2b 55 e4 sub edx, DWORD PTR _len$[ebp]
\r
3853 0041e 8b c2 mov eax, edx
\r
3855 00420 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3857 00424 8b 45 d4 mov eax, DWORD PTR tv2134[ebp]
\r
3858 00427 03 45 e4 add eax, DWORD PTR _len$[ebp]
\r
3861 0042c e8 00 00 00 00 call _memcpy
\r
3862 00431 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
3863 00434 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3864 00437 83 c4 0c add esp, 12 ; 0000000cH
\r
3868 ; 749 : if (state->flags & 0x0200)
\r
3870 0043a f7 47 10 00 02
\r
3871 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3872 00441 74 1a je SHORT $LN376@inflate
\r
3874 ; 750 : state->check = crc32(state->check, next, copy);
\r
3876 00443 8b 55 f4 mov edx, DWORD PTR _copy$[ebp]
\r
3877 00446 8b 45 f8 mov eax, DWORD PTR _next$[ebp]
\r
3878 00449 8b 4f 18 mov ecx, DWORD PTR [edi+24]
\r
3882 0044f e8 00 00 00 00 call _crc32@12
\r
3883 00454 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3884 00457 89 47 18 mov DWORD PTR [edi+24], eax
\r
3885 0045a 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
3888 ; 751 : have -= copy;
\r
3890 0045d 29 45 fc sub DWORD PTR _have$[ebp], eax
\r
3892 ; 752 : next += copy;
\r
3894 00460 03 d0 add edx, eax
\r
3896 ; 753 : state->length -= copy;
\r
3898 00462 29 47 40 sub DWORD PTR [edi+64], eax
\r
3899 00465 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
3903 ; 755 : if (state->length) goto inf_leave;
\r
3905 00468 83 7f 40 00 cmp DWORD PTR [edi+64], 0
\r
3906 0046c 0f 85 c3 0e 00
\r
3907 00 jne $inf_leave$80408
\r
3911 ; 757 : state->length = 0;
\r
3913 00472 c7 47 40 00 00
\r
3914 00 00 mov DWORD PTR [edi+64], 0
\r
3916 ; 758 : state->mode = NAME;
\r
3918 00479 c7 07 06 00 00
\r
3919 00 mov DWORD PTR [edi], 6
\r
3922 ; 759 : case NAME:
\r
3923 ; 760 : if (state->flags & 0x0800) {
\r
3925 0047f f7 47 10 00 08
\r
3926 00 00 test DWORD PTR [edi+16], 2048 ; 00000800H
\r
3927 00486 0f 84 84 00 00
\r
3928 00 je $LN373@inflate
\r
3930 ; 761 : if (have == 0) goto inf_leave;
\r
3932 0048c 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
3933 00490 0f 84 9f 0e 00
\r
3934 00 je $inf_leave$80408
\r
3938 00496 33 c0 xor eax, eax
\r
3942 ; 764 : len = (unsigned)(next[copy++]);
\r
3944 00498 0f b6 0c 10 movzx ecx, BYTE PTR [eax+edx]
\r
3946 0049d 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
3948 ; 765 : if (state->head != Z_NULL &&
\r
3949 ; 766 : state->head->name != Z_NULL &&
\r
3950 ; 767 : state->length < state->head->name_max)
\r
3952 004a0 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
3953 004a3 89 4d e4 mov DWORD PTR _len$[ebp], ecx
\r
3954 004a6 85 c0 test eax, eax
\r
3955 004a8 74 21 je SHORT $LN370@inflate
\r
3956 004aa 8b 48 1c mov ecx, DWORD PTR [eax+28]
\r
3957 004ad 89 4d d4 mov DWORD PTR tv2157[ebp], ecx
\r
3958 004b0 85 c9 test ecx, ecx
\r
3959 004b2 74 17 je SHORT $LN370@inflate
\r
3960 004b4 8b 4f 40 mov ecx, DWORD PTR [edi+64]
\r
3961 004b7 3b 48 20 cmp ecx, DWORD PTR [eax+32]
\r
3962 004ba 73 0f jae SHORT $LN370@inflate
\r
3964 ; 768 : state->head->name[state->length++] = len;
\r
3966 004bc 8b 55 d4 mov edx, DWORD PTR tv2157[ebp]
\r
3967 004bf 8a 45 e4 mov al, BYTE PTR _len$[ebp]
\r
3968 004c2 88 04 0a mov BYTE PTR [edx+ecx], al
\r
3969 004c5 ff 47 40 inc DWORD PTR [edi+64]
\r
3970 004c8 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3973 ; 769 : } while (len && copy < have);
\r
3975 004cb 83 7d e4 00 cmp DWORD PTR _len$[ebp], 0
\r
3976 004cf 74 08 je SHORT $LN367@inflate
\r
3977 004d1 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
3978 004d4 3b 45 fc cmp eax, DWORD PTR _have$[ebp]
\r
3979 004d7 72 bf jb SHORT $LL371@inflate
\r
3982 ; 770 : if (state->flags & 0x0200)
\r
3984 004d9 f7 47 10 00 02
\r
3985 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
3986 004e0 74 17 je SHORT $LN366@inflate
\r
3988 ; 771 : state->check = crc32(state->check, next, copy);
\r
3990 004e2 8b 4d f4 mov ecx, DWORD PTR _copy$[ebp]
\r
3991 004e5 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3992 004e8 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
3996 004ee e8 00 00 00 00 call _crc32@12
\r
3997 004f3 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
3998 004f6 89 47 18 mov DWORD PTR [edi+24], eax
\r
4001 ; 772 : have -= copy;
\r
4003 004f9 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
4004 004fc 29 45 fc sub DWORD PTR _have$[ebp], eax
\r
4006 ; 773 : next += copy;
\r
4008 004ff 03 d0 add edx, eax
\r
4010 ; 774 : if (len) goto inf_leave;
\r
4012 00501 83 7d e4 00 cmp DWORD PTR _len$[ebp], 0
\r
4013 00505 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4014 00508 0f 85 27 0e 00
\r
4015 00 jne $inf_leave$80408
\r
4018 ; 776 : else if (state->head != Z_NULL)
\r
4020 0050e eb 0e jmp SHORT $LN363@inflate
\r
4022 00510 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
4023 00513 85 c0 test eax, eax
\r
4024 00515 74 07 je SHORT $LN363@inflate
\r
4026 ; 777 : state->head->name = Z_NULL;
\r
4028 00517 c7 40 1c 00 00
\r
4029 00 00 mov DWORD PTR [eax+28], 0
\r
4032 ; 778 : state->length = 0;
\r
4034 0051e c7 47 40 00 00
\r
4035 00 00 mov DWORD PTR [edi+64], 0
\r
4037 ; 779 : state->mode = COMMENT;
\r
4039 00525 c7 07 07 00 00
\r
4040 00 mov DWORD PTR [edi], 7
\r
4043 ; 780 : case COMMENT:
\r
4044 ; 781 : if (state->flags & 0x1000) {
\r
4046 0052b f7 47 10 00 10
\r
4047 00 00 test DWORD PTR [edi+16], 4096 ; 00001000H
\r
4048 00532 0f 84 84 00 00
\r
4049 00 je $LN361@inflate
\r
4051 ; 782 : if (have == 0) goto inf_leave;
\r
4053 00538 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4054 0053c 0f 84 f3 0d 00
\r
4055 00 je $inf_leave$80408
\r
4059 00542 33 c0 xor eax, eax
\r
4063 ; 785 : len = (unsigned)(next[copy++]);
\r
4065 00544 0f b6 0c 10 movzx ecx, BYTE PTR [eax+edx]
\r
4067 00549 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
4069 ; 786 : if (state->head != Z_NULL &&
\r
4070 ; 787 : state->head->comment != Z_NULL &&
\r
4071 ; 788 : state->length < state->head->comm_max)
\r
4073 0054c 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
4074 0054f 89 4d e4 mov DWORD PTR _len$[ebp], ecx
\r
4075 00552 85 c0 test eax, eax
\r
4076 00554 74 21 je SHORT $LN358@inflate
\r
4077 00556 8b 48 24 mov ecx, DWORD PTR [eax+36]
\r
4078 00559 89 4d d4 mov DWORD PTR tv2173[ebp], ecx
\r
4079 0055c 85 c9 test ecx, ecx
\r
4080 0055e 74 17 je SHORT $LN358@inflate
\r
4081 00560 8b 4f 40 mov ecx, DWORD PTR [edi+64]
\r
4082 00563 3b 48 28 cmp ecx, DWORD PTR [eax+40]
\r
4083 00566 73 0f jae SHORT $LN358@inflate
\r
4085 ; 789 : state->head->comment[state->length++] = len;
\r
4087 00568 8b 55 d4 mov edx, DWORD PTR tv2173[ebp]
\r
4088 0056b 8a 45 e4 mov al, BYTE PTR _len$[ebp]
\r
4089 0056e 88 04 0a mov BYTE PTR [edx+ecx], al
\r
4090 00571 ff 47 40 inc DWORD PTR [edi+64]
\r
4091 00574 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4094 ; 790 : } while (len && copy < have);
\r
4096 00577 83 7d e4 00 cmp DWORD PTR _len$[ebp], 0
\r
4097 0057b 74 08 je SHORT $LN355@inflate
\r
4098 0057d 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
4099 00580 3b 45 fc cmp eax, DWORD PTR _have$[ebp]
\r
4100 00583 72 bf jb SHORT $LL359@inflate
\r
4103 ; 791 : if (state->flags & 0x0200)
\r
4105 00585 f7 47 10 00 02
\r
4106 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
4107 0058c 74 17 je SHORT $LN354@inflate
\r
4109 ; 792 : state->check = crc32(state->check, next, copy);
\r
4111 0058e 8b 4d f4 mov ecx, DWORD PTR _copy$[ebp]
\r
4112 00591 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4113 00594 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
4117 0059a e8 00 00 00 00 call _crc32@12
\r
4118 0059f 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4119 005a2 89 47 18 mov DWORD PTR [edi+24], eax
\r
4122 ; 793 : have -= copy;
\r
4124 005a5 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
4125 005a8 29 45 fc sub DWORD PTR _have$[ebp], eax
\r
4127 ; 794 : next += copy;
\r
4129 005ab 03 d0 add edx, eax
\r
4131 ; 795 : if (len) goto inf_leave;
\r
4133 005ad 83 7d e4 00 cmp DWORD PTR _len$[ebp], 0
\r
4134 005b1 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4135 005b4 0f 85 7b 0d 00
\r
4136 00 jne $inf_leave$80408
\r
4139 ; 797 : else if (state->head != Z_NULL)
\r
4141 005ba eb 0e jmp SHORT $LN351@inflate
\r
4143 005bc 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
4144 005bf 85 c0 test eax, eax
\r
4145 005c1 74 07 je SHORT $LN351@inflate
\r
4147 ; 798 : state->head->comment = Z_NULL;
\r
4149 005c3 c7 40 24 00 00
\r
4150 00 00 mov DWORD PTR [eax+36], 0
\r
4153 ; 799 : state->mode = HCRC;
\r
4155 005ca c7 07 08 00 00
\r
4156 00 mov DWORD PTR [edi], 8
\r
4159 ; 800 : case HCRC:
\r
4160 ; 801 : if (state->flags & 0x0200) {
\r
4162 005d0 f7 47 10 00 02
\r
4163 00 00 test DWORD PTR [edi+16], 512 ; 00000200H
\r
4164 005d7 74 44 je SHORT $LN336@inflate
\r
4166 ; 802 : NEEDBITS(16);
\r
4168 005d9 83 fe 10 cmp esi, 16 ; 00000010H
\r
4169 005dc 73 24 jae SHORT $LN347@inflate
\r
4170 005de 8b ff npad 2
\r
4172 005e0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4173 005e4 0f 84 4b 0d 00
\r
4174 00 je $inf_leave$80408
\r
4175 005ea 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4176 005ed ff 4d fc dec DWORD PTR _have$[ebp]
\r
4177 005f0 8b ce mov ecx, esi
\r
4178 005f2 d3 e0 shl eax, cl
\r
4180 005f5 83 c6 08 add esi, 8
\r
4181 005f8 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4182 005fb 03 d8 add ebx, eax
\r
4183 005fd 83 fe 10 cmp esi, 16 ; 00000010H
\r
4184 00600 72 de jb SHORT $LL345@inflate
\r
4187 ; 803 : if (hold != (state->check & 0xffff)) {
\r
4189 00602 0f b7 4f 18 movzx ecx, WORD PTR [edi+24]
\r
4190 00606 3b d9 cmp ebx, ecx
\r
4191 00608 74 0f je SHORT $LN338@inflate
\r
4193 ; 804 : strm->msg = (char *)"header crc mismatch";
\r
4195 0060a 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
4196 0060d c7 40 18 00 00
\r
4197 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BE@GONKLEPM@header?5crc?5mismatch?$AA@
\r
4199 ; 805 : state->mode = BAD;
\r
4202 00614 e9 b8 0c 00 00 jmp $LN786@inflate
\r
4206 ; 808 : INITBITS();
\r
4208 00619 33 db xor ebx, ebx
\r
4209 0061b 33 f6 xor esi, esi
\r
4213 ; 810 : if (state->head != Z_NULL) {
\r
4215 0061d 8b 47 20 mov eax, DWORD PTR [edi+32]
\r
4216 00620 85 c0 test eax, eax
\r
4217 00622 74 16 je SHORT $LN335@inflate
\r
4219 ; 811 : state->head->hcrc = (int)((state->flags >> 9) & 1);
\r
4221 00624 8b 4f 10 mov ecx, DWORD PTR [edi+16]
\r
4222 00627 c1 f9 09 sar ecx, 9
\r
4223 0062a 83 e1 01 and ecx, 1
\r
4224 0062d 89 48 2c mov DWORD PTR [eax+44], ecx
\r
4226 ; 812 : state->head->done = 1;
\r
4228 00630 8b 57 20 mov edx, DWORD PTR [edi+32]
\r
4229 00633 c7 42 30 01 00
\r
4230 00 00 mov DWORD PTR [edx+48], 1
\r
4234 ; 814 : strm->adler = state->check = crc32(0L, Z_NULL, 0);
\r
4236 0063a 6a 00 push 0
\r
4237 0063c 6a 00 push 0
\r
4238 0063e 6a 00 push 0
\r
4239 00640 e8 00 00 00 00 call _crc32@12
\r
4240 00645 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
4242 ; 815 : state->mode = TYPE;
\r
4245 00648 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4246 0064b 89 47 18 mov DWORD PTR [edi+24], eax
\r
4247 0064e 89 41 30 mov DWORD PTR [ecx+48], eax
\r
4248 00651 c7 07 0b 00 00
\r
4249 00 mov DWORD PTR [edi], 11 ; 0000000bH
\r
4250 00657 e9 7b 0c 00 00 jmp $LN490@inflate
\r
4254 ; 818 : case DICTID:
\r
4255 ; 819 : NEEDBITS(32);
\r
4257 0065c 83 fe 20 cmp esi, 32 ; 00000020H
\r
4258 0065f 73 22 jae SHORT $LN332@inflate
\r
4260 00661 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4261 00665 0f 84 ca 0c 00
\r
4262 00 je $inf_leave$80408
\r
4263 0066b 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4264 0066e ff 4d fc dec DWORD PTR _have$[ebp]
\r
4265 00671 8b ce mov ecx, esi
\r
4266 00673 d3 e0 shl eax, cl
\r
4268 00676 83 c6 08 add esi, 8
\r
4269 00679 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4270 0067c 03 d8 add ebx, eax
\r
4271 0067e 83 fe 20 cmp esi, 32 ; 00000020H
\r
4272 00681 72 de jb SHORT $LL330@inflate
\r
4275 ; 820 : strm->adler = state->check = REVERSE(hold);
\r
4277 00683 8b cb mov ecx, ebx
\r
4278 00685 8b c3 mov eax, ebx
\r
4279 00687 c1 e0 10 shl eax, 16 ; 00000010H
\r
4280 0068a 81 e1 00 ff 00
\r
4281 00 and ecx, 65280 ; 0000ff00H
\r
4282 00690 03 c8 add ecx, eax
\r
4283 00692 8b c3 mov eax, ebx
\r
4284 00694 c1 e8 08 shr eax, 8
\r
4285 00697 c1 e1 08 shl ecx, 8
\r
4286 0069a 25 00 ff 00 00 and eax, 65280 ; 0000ff00H
\r
4287 0069f 03 c1 add eax, ecx
\r
4288 006a1 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
4289 006a4 c1 eb 18 shr ebx, 24 ; 00000018H
\r
4290 006a7 03 c3 add eax, ebx
\r
4291 006a9 89 47 18 mov DWORD PTR [edi+24], eax
\r
4292 006ac 89 41 30 mov DWORD PTR [ecx+48], eax
\r
4294 ; 821 : INITBITS();
\r
4296 006af 33 db xor ebx, ebx
\r
4297 006b1 33 f6 xor esi, esi
\r
4299 ; 822 : state->mode = DICT;
\r
4301 006b3 c7 07 0a 00 00
\r
4302 00 mov DWORD PTR [edi], 10 ; 0000000aH
\r
4305 ; 823 : case DICT:
\r
4306 ; 824 : if (state->havedict == 0) {
\r
4308 006b9 83 7f 0c 00 cmp DWORD PTR [edi+12], 0
\r
4309 006bd 0f 84 2d 0c 00
\r
4310 00 je $LN579@inflate
\r
4313 ; 828 : strm->adler = state->check = adler32(0L, Z_NULL, 0);
\r
4315 006c3 6a 00 push 0
\r
4316 006c5 6a 00 push 0
\r
4317 006c7 6a 00 push 0
\r
4318 006c9 e8 00 00 00 00 call _adler32@12
\r
4319 006ce 8b 55 08 mov edx, DWORD PTR _strm$[ebp]
\r
4320 006d1 89 47 18 mov DWORD PTR [edi+24], eax
\r
4321 006d4 89 42 30 mov DWORD PTR [edx+48], eax
\r
4323 ; 829 : state->mode = TYPE;
\r
4325 006d7 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4326 006da c7 07 0b 00 00
\r
4327 00 mov DWORD PTR [edi], 11 ; 0000000bH
\r
4330 ; 830 : case TYPE:
\r
4331 ; 831 : if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
\r
4333 006e0 83 7d 0c 05 cmp DWORD PTR _flush$[ebp], 5
\r
4334 006e4 0f 84 4b 0c 00
\r
4335 00 je $inf_leave$80408
\r
4336 006ea 83 7d 0c 06 cmp DWORD PTR _flush$[ebp], 6
\r
4337 006ee 0f 84 41 0c 00
\r
4338 00 je $inf_leave$80408
\r
4341 ; 832 : case TYPEDO:
\r
4342 ; 833 : if (state->last) {
\r
4344 006f4 83 7f 04 00 cmp DWORD PTR [edi+4], 0
\r
4345 006f8 74 14 je SHORT $LN308@inflate
\r
4347 ; 834 : BYTEBITS();
\r
4349 006fa 8b ce mov ecx, esi
\r
4350 006fc 83 e1 07 and ecx, 7
\r
4351 006ff d3 eb shr ebx, cl
\r
4352 00701 2b f1 sub esi, ecx
\r
4354 ; 835 : state->mode = CHECK;
\r
4356 00703 c7 07 1a 00 00
\r
4357 00 mov DWORD PTR [edi], 26 ; 0000001aH
\r
4361 00709 e9 c9 0b 00 00 jmp $LN490@inflate
\r
4365 ; 838 : NEEDBITS(3);
\r
4367 0070e 83 fe 03 cmp esi, 3
\r
4368 00711 73 22 jae SHORT $LN307@inflate
\r
4370 00713 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4371 00717 0f 84 18 0c 00
\r
4372 00 je $inf_leave$80408
\r
4373 0071d 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4374 00720 ff 4d fc dec DWORD PTR _have$[ebp]
\r
4375 00723 8b ce mov ecx, esi
\r
4376 00725 d3 e0 shl eax, cl
\r
4378 00728 83 c6 08 add esi, 8
\r
4379 0072b 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4380 0072e 03 d8 add ebx, eax
\r
4381 00730 83 fe 03 cmp esi, 3
\r
4382 00733 72 de jb SHORT $LL305@inflate
\r
4385 ; 839 : state->last = BITS(1);
\r
4387 00735 8b cb mov ecx, ebx
\r
4389 ; 840 : DROPBITS(1);
\r
4391 00737 d1 eb shr ebx, 1
\r
4393 ; 841 : switch (BITS(2)) {
\r
4395 00739 8b c3 mov eax, ebx
\r
4396 0073b 83 e1 01 and ecx, 1
\r
4397 0073e 83 e0 03 and eax, 3
\r
4398 00741 89 4f 04 mov DWORD PTR [edi+4], ecx
\r
4399 00744 83 f8 03 cmp eax, 3
\r
4400 00747 77 57 ja SHORT $LN286@inflate
\r
4401 00749 ff 24 85 00 00
\r
4402 00 00 jmp DWORD PTR $LN788@inflate[eax*4]
\r
4406 ; 866 : DROPBITS(2);
\r
4408 00750 c1 eb 02 shr ebx, 2
\r
4409 00753 c7 07 0d 00 00
\r
4410 00 mov DWORD PTR [edi], 13 ; 0000000dH
\r
4411 00759 83 ee 03 sub esi, 3
\r
4415 0075c e9 76 0b 00 00 jmp $LN490@inflate
\r
4418 ; 842 : case 0: /* stored block */
\r
4419 ; 843 : Tracev((stderr, "inflate: stored block%s\n",
\r
4420 ; 844 : state->last ? " (last)" : ""));
\r
4421 ; 845 : state->mode = STORED;
\r
4423 ; 847 : case 1: /* fixed block */
\r
4424 ; 848 : fixedtables(state);
\r
4426 00761 8b c7 mov eax, edi
\r
4427 00763 e8 00 00 00 00 call _fixedtables
\r
4429 ; 849 : Tracev((stderr, "inflate: fixed codes block%s\n",
\r
4430 ; 850 : state->last ? " (last)" : ""));
\r
4431 ; 851 : state->mode = LEN_; /* decode codes */
\r
4432 ; 852 : if (flush == Z_TREES) {
\r
4434 00768 83 7d 0c 06 cmp DWORD PTR _flush$[ebp], 6
\r
4435 0076c c7 07 13 00 00
\r
4436 00 mov DWORD PTR [edi], 19 ; 00000013H
\r
4437 00772 75 2c jne SHORT $LN286@inflate
\r
4439 ; 853 : DROPBITS(2);
\r
4441 00774 c1 eb 02 shr ebx, 2
\r
4442 00777 83 ee 03 sub esi, 3
\r
4444 ; 854 : goto inf_leave;
\r
4446 0077a e9 b6 0b 00 00 jmp $inf_leave$80408
\r
4450 ; 866 : DROPBITS(2);
\r
4452 0077f c1 eb 02 shr ebx, 2
\r
4453 00782 c7 07 10 00 00
\r
4454 00 mov DWORD PTR [edi], 16 ; 00000010H
\r
4455 00788 83 ee 03 sub esi, 3
\r
4459 0078b e9 47 0b 00 00 jmp $LN490@inflate
\r
4464 ; 857 : case 2: /* dynamic block */
\r
4465 ; 858 : Tracev((stderr, "inflate: dynamic codes block%s\n",
\r
4466 ; 859 : state->last ? " (last)" : ""));
\r
4467 ; 860 : state->mode = TABLE;
\r
4470 ; 863 : strm->msg = (char *)"invalid block type";
\r
4472 00790 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
4473 00793 c7 40 18 00 00
\r
4474 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BD@PJCBIDD@invalid?5block?5type?$AA@
\r
4476 ; 864 : state->mode = BAD;
\r
4478 0079a c7 07 1d 00 00
\r
4479 00 mov DWORD PTR [edi], 29 ; 0000001dH
\r
4483 ; 866 : DROPBITS(2);
\r
4485 007a0 c1 eb 02 shr ebx, 2
\r
4486 007a3 83 ee 03 sub esi, 3
\r
4490 007a6 e9 2c 0b 00 00 jmp $LN490@inflate
\r
4493 ; 868 : case STORED:
\r
4494 ; 869 : BYTEBITS(); /* go to byte boundary */
\r
4496 007ab 8b ce mov ecx, esi
\r
4497 007ad 83 e1 07 and ecx, 7
\r
4498 007b0 2b f1 sub esi, ecx
\r
4499 007b2 d3 eb shr ebx, cl
\r
4501 ; 870 : NEEDBITS(32);
\r
4503 007b4 83 fe 20 cmp esi, 32 ; 00000020H
\r
4504 007b7 73 29 jae SHORT $LN278@inflate
\r
4505 007b9 8d a4 24 00 00
\r
4508 007c0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4509 007c4 0f 84 6b 0b 00
\r
4510 00 je $inf_leave$80408
\r
4511 007ca 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4512 007cd ff 4d fc dec DWORD PTR _have$[ebp]
\r
4513 007d0 8b ce mov ecx, esi
\r
4514 007d2 d3 e0 shl eax, cl
\r
4516 007d5 83 c6 08 add esi, 8
\r
4517 007d8 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4518 007db 03 d8 add ebx, eax
\r
4519 007dd 83 fe 20 cmp esi, 32 ; 00000020H
\r
4520 007e0 72 de jb SHORT $LL276@inflate
\r
4523 ; 871 : if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
\r
4525 007e2 8b cb mov ecx, ebx
\r
4526 007e4 8b c3 mov eax, ebx
\r
4527 007e6 f7 d1 not ecx
\r
4528 007e8 25 ff ff 00 00 and eax, 65535 ; 0000ffffH
\r
4529 007ed c1 e9 10 shr ecx, 16 ; 00000010H
\r
4530 007f0 3b c1 cmp eax, ecx
\r
4531 007f2 74 0f je SHORT $LN270@inflate
\r
4533 ; 872 : strm->msg = (char *)"invalid stored block lengths";
\r
4535 007f4 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
4536 007f7 c7 40 18 00 00
\r
4537 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BN@LGAADGOK@invalid?5stored?5block?5lengths?$AA@
\r
4539 ; 873 : state->mode = BAD;
\r
4542 007fe e9 ce 0a 00 00 jmp $LN786@inflate
\r
4546 ; 876 : state->length = (unsigned)hold & 0xffff;
\r
4547 ; 877 : Tracev((stderr, "inflate: stored length %u\n",
\r
4548 ; 878 : state->length));
\r
4549 ; 879 : INITBITS();
\r
4551 00803 33 db xor ebx, ebx
\r
4552 00805 33 f6 xor esi, esi
\r
4554 ; 880 : state->mode = COPY_;
\r
4555 ; 881 : if (flush == Z_TREES) goto inf_leave;
\r
4557 00807 83 7d 0c 06 cmp DWORD PTR _flush$[ebp], 6
\r
4558 0080b 89 47 40 mov DWORD PTR [edi+64], eax
\r
4559 0080e c7 07 0e 00 00
\r
4560 00 mov DWORD PTR [edi], 14 ; 0000000eH
\r
4561 00814 0f 84 1b 0b 00
\r
4562 00 je $inf_leave$80408
\r
4565 ; 882 : case COPY_:
\r
4566 ; 883 : state->mode = COPY;
\r
4568 0081a c7 07 0f 00 00
\r
4569 00 mov DWORD PTR [edi], 15 ; 0000000fH
\r
4572 ; 884 : case COPY:
\r
4573 ; 885 : copy = state->length;
\r
4575 00820 8b 47 40 mov eax, DWORD PTR [edi+64]
\r
4576 00823 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
4578 ; 886 : if (copy) {
\r
4580 00826 85 c0 test eax, eax
\r
4581 00828 0f 84 73 06 00
\r
4582 00 je $LN263@inflate
\r
4584 ; 887 : if (copy > have) copy = have;
\r
4586 0082e 8b 4d fc mov ecx, DWORD PTR _have$[ebp]
\r
4587 00831 3b c1 cmp eax, ecx
\r
4588 00833 76 05 jbe SHORT $LN262@inflate
\r
4589 00835 8b c1 mov eax, ecx
\r
4590 00837 89 4d f4 mov DWORD PTR _copy$[ebp], ecx
\r
4593 ; 888 : if (copy > left) copy = left;
\r
4595 0083a 8b 4d f0 mov ecx, DWORD PTR _left$[ebp]
\r
4596 0083d 3b c1 cmp eax, ecx
\r
4597 0083f 76 05 jbe SHORT $LN261@inflate
\r
4598 00841 8b c1 mov eax, ecx
\r
4599 00843 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
4602 ; 889 : if (copy == 0) goto inf_leave;
\r
4604 00846 85 c0 test eax, eax
\r
4605 00848 0f 84 e7 0a 00
\r
4606 00 je $inf_leave$80408
\r
4608 ; 890 : zmemcpy(put, next, copy);
\r
4610 0084e 8b 4d f4 mov ecx, DWORD PTR _copy$[ebp]
\r
4611 00851 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4612 00854 8b 45 e8 mov eax, DWORD PTR _put$[ebp]
\r
4616 0085a e8 00 00 00 00 call _memcpy
\r
4618 ; 891 : have -= copy;
\r
4620 0085f 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
4622 ; 892 : next += copy;
\r
4624 00862 01 45 f8 add DWORD PTR _next$[ebp], eax
\r
4625 00865 29 45 fc sub DWORD PTR _have$[ebp], eax
\r
4627 ; 893 : left -= copy;
\r
4629 00868 29 45 f0 sub DWORD PTR _left$[ebp], eax
\r
4631 ; 894 : put += copy;
\r
4633 0086b 01 45 e8 add DWORD PTR _put$[ebp], eax
\r
4635 ; 895 : state->length -= copy;
\r
4638 0086e 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4639 00871 83 c4 0c add esp, 12 ; 0000000cH
\r
4640 00874 29 47 40 sub DWORD PTR [edi+64], eax
\r
4641 00877 e9 5b 0a 00 00 jmp $LN490@inflate
\r
4645 ; 898 : Tracev((stderr, "inflate: stored end\n"));
\r
4646 ; 899 : state->mode = TYPE;
\r
4648 ; 901 : case TABLE:
\r
4649 ; 902 : NEEDBITS(14);
\r
4651 0087c 83 fe 0e cmp esi, 14 ; 0000000eH
\r
4652 0087f 73 22 jae SHORT $LN257@inflate
\r
4654 00881 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4655 00885 0f 84 aa 0a 00
\r
4656 00 je $inf_leave$80408
\r
4657 0088b 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4658 0088e ff 4d fc dec DWORD PTR _have$[ebp]
\r
4659 00891 8b ce mov ecx, esi
\r
4660 00893 d3 e0 shl eax, cl
\r
4662 00896 83 c6 08 add esi, 8
\r
4663 00899 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4664 0089c 03 d8 add ebx, eax
\r
4665 0089e 83 fe 0e cmp esi, 14 ; 0000000eH
\r
4666 008a1 72 de jb SHORT $LL255@inflate
\r
4669 ; 903 : state->nlen = BITS(5) + 257;
\r
4671 008a3 8b cb mov ecx, ebx
\r
4672 008a5 83 e1 1f and ecx, 31 ; 0000001fH
\r
4674 ; 904 : DROPBITS(5);
\r
4676 008a8 c1 eb 05 shr ebx, 5
\r
4677 008ab 81 c1 01 01 00
\r
4678 00 add ecx, 257 ; 00000101H
\r
4680 ; 905 : state->ndist = BITS(5) + 1;
\r
4682 008b1 8b c3 mov eax, ebx
\r
4683 008b3 89 4f 60 mov DWORD PTR [edi+96], ecx
\r
4685 ; 906 : DROPBITS(5);
\r
4687 008b6 c1 eb 05 shr ebx, 5
\r
4689 ; 907 : state->ncode = BITS(4) + 4;
\r
4691 008b9 8b cb mov ecx, ebx
\r
4692 008bb 83 e0 1f and eax, 31 ; 0000001fH
\r
4693 008be 83 e1 0f and ecx, 15 ; 0000000fH
\r
4695 008c2 83 c1 04 add ecx, 4
\r
4697 ; 908 : DROPBITS(4);
\r
4699 008c5 c1 eb 04 shr ebx, 4
\r
4700 008c8 83 ee 0e sub esi, 14 ; 0000000eH
\r
4702 ; 909 : #ifndef PKZIP_BUG_WORKAROUND
\r
4703 ; 910 : if (state->nlen > 286 || state->ndist > 30) {
\r
4705 008cb 81 7f 60 1e 01
\r
4706 00 00 cmp DWORD PTR [edi+96], 286 ; 0000011eH
\r
4707 008d2 89 47 64 mov DWORD PTR [edi+100], eax
\r
4708 008d5 89 4f 5c mov DWORD PTR [edi+92], ecx
\r
4709 008d8 0f 87 e5 00 00
\r
4710 00 ja $LN239@inflate
\r
4711 008de 83 f8 1e cmp eax, 30 ; 0000001eH
\r
4712 008e1 0f 87 dc 00 00
\r
4713 00 ja $LN239@inflate
\r
4717 ; 916 : Tracev((stderr, "inflate: table sizes ok\n"));
\r
4718 ; 917 : state->have = 0;
\r
4720 008e7 c7 47 68 00 00
\r
4721 00 00 mov DWORD PTR [edi+104], 0
\r
4723 ; 918 : state->mode = LENLENS;
\r
4725 008ee c7 07 11 00 00
\r
4726 00 mov DWORD PTR [edi], 17 ; 00000011H
\r
4729 ; 919 : case LENLENS:
\r
4730 ; 920 : while (state->have < state->ncode) {
\r
4732 008f4 8b 4f 68 mov ecx, DWORD PTR [edi+104]
\r
4733 008f7 3b 4f 5c cmp ecx, DWORD PTR [edi+92]
\r
4734 008fa 73 51 jae SHORT $LN527@inflate
\r
4735 008fc 8d 64 24 00 npad 4
\r
4738 ; 921 : NEEDBITS(3);
\r
4740 00900 83 fe 03 cmp esi, 3
\r
4741 00903 73 22 jae SHORT $LN234@inflate
\r
4743 00905 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4744 00909 0f 84 26 0a 00
\r
4745 00 je $inf_leave$80408
\r
4746 0090f 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4747 00912 ff 4d fc dec DWORD PTR _have$[ebp]
\r
4748 00915 8b ce mov ecx, esi
\r
4749 00917 d3 e0 shl eax, cl
\r
4751 0091a 83 c6 08 add esi, 8
\r
4752 0091d 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4753 00920 03 d8 add ebx, eax
\r
4754 00922 83 fe 03 cmp esi, 3
\r
4755 00925 72 de jb SHORT $LL232@inflate
\r
4758 ; 922 : state->lens[order[state->have++]] = (unsigned short)BITS(3);
\r
4760 00927 8b 47 68 mov eax, DWORD PTR [edi+104]
\r
4761 0092a 0f b7 04 45 00
\r
4762 00 00 00 movzx eax, WORD PTR ?order@?1??inflate@@9@9[eax*2]
\r
4763 00932 8b cb mov ecx, ebx
\r
4764 00934 83 e1 07 and ecx, 7
\r
4765 00937 66 89 4c 47 70 mov WORD PTR [edi+eax*2+112], cx
\r
4766 0093c ff 47 68 inc DWORD PTR [edi+104]
\r
4767 0093f 8b 4f 68 mov ecx, DWORD PTR [edi+104]
\r
4769 ; 923 : DROPBITS(3);
\r
4771 00942 c1 eb 03 shr ebx, 3
\r
4772 00945 83 ee 03 sub esi, 3
\r
4773 00948 3b 4f 5c cmp ecx, DWORD PTR [edi+92]
\r
4774 0094b 72 b3 jb SHORT $LL237@inflate
\r
4778 ; 925 : while (state->have < 19)
\r
4780 0094d b8 13 00 00 00 mov eax, 19 ; 00000013H
\r
4781 00952 39 47 68 cmp DWORD PTR [edi+104], eax
\r
4782 00955 73 23 jae SHORT $LN222@inflate
\r
4783 00957 eb 07 8d a4 24
\r
4784 00 00 00 00 npad 9
\r
4787 ; 926 : state->lens[order[state->have++]] = 0;
\r
4789 00960 8b 57 68 mov edx, DWORD PTR [edi+104]
\r
4790 00963 0f b7 0c 55 00
\r
4791 00 00 00 movzx ecx, WORD PTR ?order@?1??inflate@@9@9[edx*2]
\r
4792 0096b 33 d2 xor edx, edx
\r
4793 0096d 66 89 54 4f 70 mov WORD PTR [edi+ecx*2+112], dx
\r
4794 00972 ff 47 68 inc DWORD PTR [edi+104]
\r
4795 00975 39 47 68 cmp DWORD PTR [edi+104], eax
\r
4796 00978 72 e6 jb SHORT $LL223@inflate
\r
4799 ; 927 : state->next = state->codes;
\r
4801 0097a 8d 87 30 05 00
\r
4802 00 lea eax, DWORD PTR [edi+1328]
\r
4803 00980 8d 4f 6c lea ecx, DWORD PTR [edi+108]
\r
4804 00983 89 01 mov DWORD PTR [ecx], eax
\r
4806 ; 928 : state->lencode = (code const FAR *)(state->next);
\r
4808 00985 89 47 4c mov DWORD PTR [edi+76], eax
\r
4810 ; 929 : state->lenbits = 7;
\r
4811 ; 930 : ret = inflate_table(CODES, state->lens, 19, &(state->next),
\r
4812 ; 931 : &(state->lenbits), state->work);
\r
4814 00988 8d 97 f0 02 00
\r
4815 00 lea edx, DWORD PTR [edi+752]
\r
4817 0098f 8d 47 54 lea eax, DWORD PTR [edi+84]
\r
4820 00994 c7 00 07 00 00
\r
4821 00 mov DWORD PTR [eax], 7
\r
4822 0099a 6a 13 push 19 ; 00000013H
\r
4823 0099c 8d 47 70 lea eax, DWORD PTR [edi+112]
\r
4825 009a0 6a 00 push 0
\r
4826 009a2 e8 00 00 00 00 call _inflate_table
\r
4828 ; 934 : state->mode = BAD;
\r
4831 009a7 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
4832 009aa 83 c4 18 add esp, 24 ; 00000018H
\r
4833 009ad 89 45 d8 mov DWORD PTR _ret$[ebp], eax
\r
4834 009b0 85 c0 test eax, eax
\r
4835 009b2 74 1e je SHORT $LN221@inflate
\r
4837 ; 932 : if (ret) {
\r
4838 ; 933 : strm->msg = (char *)"invalid code lengths set";
\r
4840 009b4 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
4841 009b7 c7 41 18 00 00
\r
4842 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BJ@HDEPPGOH@invalid?5code?5lengths?5set?$AA@
\r
4844 ; 934 : state->mode = BAD;
\r
4847 009be e9 0e 09 00 00 jmp $LN786@inflate
\r
4850 ; 911 : strm->msg = (char *)"too many length or distance symbols";
\r
4852 009c3 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
4853 009c6 c7 40 18 00 00
\r
4854 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0CE@GMIGFPBB@too?5many?5length?5or?5distance?5symb@
\r
4856 ; 912 : state->mode = BAD;
\r
4859 009cd e9 ff 08 00 00 jmp $LN786@inflate
\r
4863 ; 937 : Tracev((stderr, "inflate: code lengths ok\n"));
\r
4864 ; 938 : state->have = 0;
\r
4866 009d2 c7 47 68 00 00
\r
4867 00 00 mov DWORD PTR [edi+104], 0
\r
4869 ; 939 : state->mode = CODELENS;
\r
4871 009d9 c7 07 12 00 00
\r
4872 00 mov DWORD PTR [edi], 18 ; 00000012H
\r
4875 ; 940 : case CODELENS:
\r
4876 ; 941 : while (state->have < state->nlen + state->ndist) {
\r
4878 009df 8b 47 64 mov eax, DWORD PTR [edi+100]
\r
4879 009e2 03 47 60 add eax, DWORD PTR [edi+96]
\r
4880 009e5 39 47 68 cmp DWORD PTR [edi+104], eax
\r
4881 009e8 0f 83 e5 01 00
\r
4882 00 jae $LN218@inflate
\r
4883 009ee 8b ff npad 2
\r
4886 ; 942 : for (;;) {
\r
4887 ; 943 : here = state->lencode[BITS(state->lenbits)];
\r
4889 009f0 8b 4f 54 mov ecx, DWORD PTR [edi+84]
\r
4890 009f3 b8 01 00 00 00 mov eax, 1
\r
4891 009f8 d3 e0 shl eax, cl
\r
4892 009fa 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
4894 009fe 23 c3 and eax, ebx
\r
4895 00a00 8b 0c 81 mov ecx, DWORD PTR [ecx+eax*4]
\r
4897 ; 944 : if ((unsigned)(here.bits) <= bits) break;
\r
4899 00a03 8b c1 mov eax, ecx
\r
4900 00a05 c1 e8 08 shr eax, 8
\r
4901 00a08 0f b6 c0 movzx eax, al
\r
4902 00a0b 89 4d f4 mov DWORD PTR _here$[ebp], ecx
\r
4903 00a0e 3b c6 cmp eax, esi
\r
4904 00a10 76 3f jbe SHORT $LN555@inflate
\r
4907 ; 945 : PULLBYTE();
\r
4909 00a12 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4910 00a16 0f 84 19 09 00
\r
4911 00 je $inf_leave$80408
\r
4912 00a1c 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4913 00a1f ff 4d fc dec DWORD PTR _have$[ebp]
\r
4914 00a22 8b ce mov ecx, esi
\r
4915 00a24 d3 e0 shl eax, cl
\r
4916 00a26 8b 4f 54 mov ecx, DWORD PTR [edi+84]
\r
4918 00a2a 83 c6 08 add esi, 8
\r
4919 00a2d 03 d8 add ebx, eax
\r
4920 00a2f b8 01 00 00 00 mov eax, 1
\r
4921 00a34 d3 e0 shl eax, cl
\r
4922 00a36 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
4923 00a39 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4925 00a3d 23 c3 and eax, ebx
\r
4926 00a3f 8b 0c 81 mov ecx, DWORD PTR [ecx+eax*4]
\r
4927 00a42 8b c1 mov eax, ecx
\r
4928 00a44 c1 e8 08 shr eax, 8
\r
4929 00a47 0f b6 c0 movzx eax, al
\r
4930 00a4a 89 4d f4 mov DWORD PTR _here$[ebp], ecx
\r
4931 00a4d 3b c6 cmp eax, esi
\r
4932 00a4f 77 c1 ja SHORT $LL217@inflate
\r
4936 ; 947 : if (here.val < 16) {
\r
4938 00a51 8b c1 mov eax, ecx
\r
4939 00a53 c1 e8 10 shr eax, 16 ; 00000010H
\r
4940 00a56 89 45 d4 mov DWORD PTR tv2303[ebp], eax
\r
4941 00a59 66 83 f8 10 cmp ax, 16 ; 00000010H
\r
4942 00a5d 73 1a jae SHORT $LN782@inflate
\r
4944 ; 948 : DROPBITS(here.bits);
\r
4946 00a5f c1 e9 08 shr ecx, 8
\r
4947 00a62 0f b6 c9 movzx ecx, cl
\r
4948 00a65 d3 eb shr ebx, cl
\r
4949 00a67 2b f1 sub esi, ecx
\r
4951 ; 949 : state->lens[state->have++] = here.val;
\r
4953 00a69 8b 4f 68 mov ecx, DWORD PTR [edi+104]
\r
4954 00a6c 66 89 44 4f 70 mov WORD PTR [edi+ecx*2+112], ax
\r
4955 00a71 ff 47 68 inc DWORD PTR [edi+104]
\r
4960 00a74 e9 4b 01 00 00 jmp $LN733@inflate
\r
4963 ; 952 : if (here.val == 16) {
\r
4965 00a79 75 6f jne SHORT $LN205@inflate
\r
4967 ; 953 : NEEDBITS(here.bits + 2);
\r
4969 00a7b 8b c1 mov eax, ecx
\r
4970 00a7d c1 e8 08 shr eax, 8
\r
4971 00a80 0f b6 c0 movzx eax, al
\r
4972 00a83 83 c0 02 add eax, 2
\r
4973 00a86 3b f0 cmp esi, eax
\r
4974 00a88 73 30 jae SHORT $LN203@inflate
\r
4975 00a8a 8d 9b 00 00 00
\r
4978 00a90 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
4979 00a94 0f 84 9b 08 00
\r
4980 00 je $inf_leave$80408
\r
4981 00a9a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
4982 00a9d ff 4d fc dec DWORD PTR _have$[ebp]
\r
4983 00aa0 8b ce mov ecx, esi
\r
4984 00aa2 d3 e0 shl eax, cl
\r
4985 00aa4 8b 4d f4 mov ecx, DWORD PTR _here$[ebp]
\r
4987 00aa8 83 c6 08 add esi, 8
\r
4988 00aab 03 d8 add ebx, eax
\r
4989 00aad 0f b6 c5 movzx eax, ch
\r
4990 00ab0 83 c0 02 add eax, 2
\r
4991 00ab3 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
4992 00ab6 3b f0 cmp esi, eax
\r
4993 00ab8 72 d6 jb SHORT $LL201@inflate
\r
4996 ; 954 : DROPBITS(here.bits);
\r
4997 ; 955 : if (state->have == 0) {
\r
4999 00aba 8b 47 68 mov eax, DWORD PTR [edi+104]
\r
5000 00abd 0f b6 cd movzx ecx, ch
\r
5001 00ac0 d3 eb shr ebx, cl
\r
5002 00ac2 2b f1 sub esi, ecx
\r
5003 00ac4 85 c0 test eax, eax
\r
5004 00ac6 0f 84 29 01 00
\r
5005 00 je $LN560@inflate
\r
5008 ; 960 : len = state->lens[state->have - 1];
\r
5010 00acc 0f b7 4c 47 6e movzx ecx, WORD PTR [edi+eax*2+110]
\r
5012 ; 961 : copy = 3 + BITS(2);
\r
5014 00ad1 8b c3 mov eax, ebx
\r
5015 00ad3 83 e0 03 and eax, 3
\r
5016 00ad6 83 c0 03 add eax, 3
\r
5018 ; 962 : DROPBITS(2);
\r
5020 00ad9 c1 eb 02 shr ebx, 2
\r
5021 00adc 89 4d e4 mov DWORD PTR _len$[ebp], ecx
\r
5022 00adf 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
5023 00ae2 83 ee 02 sub esi, 2
\r
5026 ; 964 : else if (here.val == 17) {
\r
5028 00ae5 e9 a5 00 00 00 jmp $LN156@inflate
\r
5030 00aea 66 83 7d f6 11 cmp WORD PTR _here$[ebp+2], 17 ; 00000011H
\r
5032 ; 965 : NEEDBITS(here.bits + 3);
\r
5034 00aef 0f b6 cd movzx ecx, ch
\r
5035 00af2 89 4d dc mov DWORD PTR tv2314[ebp], ecx
\r
5036 00af5 75 47 jne SHORT $LN170@inflate
\r
5037 00af7 8d 41 03 lea eax, DWORD PTR [ecx+3]
\r
5038 00afa 3b f0 cmp esi, eax
\r
5039 00afc 73 29 jae SHORT $LN185@inflate
\r
5040 00afe 8b ff npad 2
\r
5042 00b00 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5043 00b04 0f 84 2b 08 00
\r
5044 00 je $inf_leave$80408
\r
5045 00b0a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5046 00b0d ff 4d fc dec DWORD PTR _have$[ebp]
\r
5047 00b10 8b ce mov ecx, esi
\r
5048 00b12 d3 e0 shl eax, cl
\r
5049 00b14 8b 4d dc mov ecx, DWORD PTR tv2314[ebp]
\r
5051 00b18 83 c6 08 add esi, 8
\r
5052 00b1b 03 d8 add ebx, eax
\r
5053 00b1d 8d 41 03 lea eax, DWORD PTR [ecx+3]
\r
5054 00b20 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5055 00b23 3b f0 cmp esi, eax
\r
5056 00b25 72 d9 jb SHORT $LL183@inflate
\r
5059 ; 966 : DROPBITS(here.bits);
\r
5061 00b27 d3 eb shr ebx, cl
\r
5064 ; 968 : copy = 3 + BITS(3);
\r
5066 00b29 8b c3 mov eax, ebx
\r
5067 00b2b 83 e0 07 and eax, 7
\r
5068 00b2e 83 c0 03 add eax, 3
\r
5069 00b31 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
5071 ; 969 : DROPBITS(3);
\r
5073 00b34 c1 eb 03 shr ebx, 3
\r
5074 00b37 b8 fd ff ff ff mov eax, -3 ; fffffffdH
\r
5079 00b3c eb 43 jmp SHORT $LN783@inflate
\r
5082 ; 972 : NEEDBITS(here.bits + 7);
\r
5084 00b3e 8d 41 07 lea eax, DWORD PTR [ecx+7]
\r
5085 00b41 3b f0 cmp esi, eax
\r
5086 00b43 73 27 jae SHORT $LN169@inflate
\r
5088 00b45 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5089 00b49 0f 84 e6 07 00
\r
5090 00 je $inf_leave$80408
\r
5091 00b4f 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5092 00b52 ff 4d fc dec DWORD PTR _have$[ebp]
\r
5093 00b55 8b ce mov ecx, esi
\r
5094 00b57 d3 e0 shl eax, cl
\r
5095 00b59 8b 4d dc mov ecx, DWORD PTR tv2314[ebp]
\r
5097 00b5d 83 c6 08 add esi, 8
\r
5098 00b60 03 d8 add ebx, eax
\r
5099 00b62 8d 41 07 lea eax, DWORD PTR [ecx+7]
\r
5100 00b65 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5101 00b68 3b f0 cmp esi, eax
\r
5102 00b6a 72 d9 jb SHORT $LL167@inflate
\r
5105 ; 973 : DROPBITS(here.bits);
\r
5107 00b6c d3 eb shr ebx, cl
\r
5110 ; 975 : copy = 11 + BITS(7);
\r
5112 00b6e 8b c3 mov eax, ebx
\r
5113 00b70 83 e0 7f and eax, 127 ; 0000007fH
\r
5114 00b73 83 c0 0b add eax, 11 ; 0000000bH
\r
5115 00b76 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
5117 ; 976 : DROPBITS(7);
\r
5119 00b79 c1 eb 07 shr ebx, 7
\r
5120 00b7c b8 f9 ff ff ff mov eax, -7 ; fffffff9H
\r
5122 00b81 2b c1 sub eax, ecx
\r
5123 00b83 03 f0 add esi, eax
\r
5124 00b85 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
5125 00b88 c7 45 e4 00 00
\r
5126 00 00 mov DWORD PTR _len$[ebp], 0
\r
5130 ; 978 : if (state->have + copy > state->nlen + state->ndist) {
\r
5132 00b8f 8b 4f 68 mov ecx, DWORD PTR [edi+104]
\r
5133 00b92 03 c8 add ecx, eax
\r
5134 00b94 8b 47 64 mov eax, DWORD PTR [edi+100]
\r
5135 00b97 03 47 60 add eax, DWORD PTR [edi+96]
\r
5136 00b9a 3b c8 cmp ecx, eax
\r
5137 00b9c 77 66 ja SHORT $LN561@inflate
\r
5139 ; 980 : state->mode = BAD;
\r
5142 ; 983 : while (copy--)
\r
5144 00b9e 83 7d f4 00 cmp DWORD PTR _copy$[ebp], 0
\r
5145 00ba2 74 20 je SHORT $LN733@inflate
\r
5146 00ba4 8b 45 e4 mov eax, DWORD PTR _len$[ebp]
\r
5147 00ba7 eb 07 8d a4 24
\r
5148 00 00 00 00 npad 9
\r
5151 ; 984 : state->lens[state->have++] = (unsigned short)len;
\r
5153 00bb0 8b 4f 68 mov ecx, DWORD PTR [edi+104]
\r
5154 00bb3 ff 4d f4 dec DWORD PTR _copy$[ebp]
\r
5155 00bb6 66 89 44 4f 70 mov WORD PTR [edi+ecx*2+112], ax
\r
5156 00bbb ff 47 68 inc DWORD PTR [edi+104]
\r
5157 00bbe 83 7d f4 00 cmp DWORD PTR _copy$[ebp], 0
\r
5158 00bc2 75 ec jne SHORT $LL154@inflate
\r
5161 ; 940 : case CODELENS:
\r
5162 ; 941 : while (state->have < state->nlen + state->ndist) {
\r
5164 00bc4 8b 47 64 mov eax, DWORD PTR [edi+100]
\r
5165 00bc7 03 47 60 add eax, DWORD PTR [edi+96]
\r
5166 00bca 39 47 68 cmp DWORD PTR [edi+104], eax
\r
5167 00bcd 0f 82 1d fe ff
\r
5168 ff jb $LL219@inflate
\r
5174 ; 988 : /* handle error breaks in while */
\r
5175 ; 989 : if (state->mode == BAD) break;
\r
5177 00bd3 83 3f 1d cmp DWORD PTR [edi], 29 ; 0000001dH
\r
5178 00bd6 0f 84 fb 06 00
\r
5179 00 je $LN490@inflate
\r
5182 ; 991 : /* check for end-of-block code (better have one) */
\r
5183 ; 992 : if (state->lens[256] == 0) {
\r
5185 00bdc 66 83 bf 70 02
\r
5186 00 00 00 cmp WORD PTR [edi+624], 0
\r
5187 00be4 75 2d jne SHORT $LN151@inflate
\r
5189 ; 993 : strm->msg = (char *)"invalid code -- missing end-of-block";
\r
5191 00be6 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
5192 00be9 c7 41 18 00 00
\r
5193 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0CF@DGDMADCD@invalid?5code?5?9?9?5missing?5end?9of?9b@
\r
5195 ; 994 : state->mode = BAD;
\r
5198 00bf0 e9 dc 06 00 00 jmp $LN786@inflate
\r
5201 ; 956 : strm->msg = (char *)"invalid bit length repeat";
\r
5203 00bf5 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
5204 00bf8 c7 41 18 00 00
\r
5205 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BK@BMMPFBBH@invalid?5bit?5length?5repeat?$AA@
\r
5207 ; 957 : state->mode = BAD;
\r
5210 00bff e9 cd 06 00 00 jmp $LN786@inflate
\r
5213 ; 979 : strm->msg = (char *)"invalid bit length repeat";
\r
5215 00c04 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5216 00c07 c7 40 18 00 00
\r
5217 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BK@BMMPFBBH@invalid?5bit?5length?5repeat?$AA@
\r
5222 ; 988 : /* handle error breaks in while */
\r
5223 ; 989 : if (state->mode == BAD) break;
\r
5225 00c0e e9 be 06 00 00 jmp $LN786@inflate
\r
5230 ; 998 : /* build code tables -- note: do not change the lenbits or distbits
\r
5231 ; 999 : values here (9 and 6) without reading the comments in inftrees.h
\r
5232 ; 1000 : concerning the ENOUGH constants, which depend on those values */
\r
5233 ; 1001 : state->next = state->codes;
\r
5235 00c13 8d 87 30 05 00
\r
5236 00 lea eax, DWORD PTR [edi+1328]
\r
5237 00c19 8d 4f 6c lea ecx, DWORD PTR [edi+108]
\r
5238 00c1c 89 01 mov DWORD PTR [ecx], eax
\r
5240 ; 1002 : state->lencode = (code const FAR *)(state->next);
\r
5242 00c1e 89 47 4c mov DWORD PTR [edi+76], eax
\r
5244 ; 1003 : state->lenbits = 9;
\r
5245 ; 1004 : ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
\r
5246 ; 1005 : &(state->lenbits), state->work);
\r
5248 00c21 8d 97 f0 02 00
\r
5249 00 lea edx, DWORD PTR [edi+752]
\r
5251 00c28 8b 57 60 mov edx, DWORD PTR [edi+96]
\r
5252 00c2b 8d 47 54 lea eax, DWORD PTR [edi+84]
\r
5255 00c30 c7 00 09 00 00
\r
5256 00 mov DWORD PTR [eax], 9
\r
5258 00c37 8d 47 70 lea eax, DWORD PTR [edi+112]
\r
5260 00c3b 6a 01 push 1
\r
5261 00c3d e8 00 00 00 00 call _inflate_table
\r
5262 00c42 83 c4 18 add esp, 24 ; 00000018H
\r
5263 00c45 89 45 d8 mov DWORD PTR _ret$[ebp], eax
\r
5265 ; 1006 : if (ret) {
\r
5267 00c48 85 c0 test eax, eax
\r
5268 00c4a 74 12 je SHORT $LN150@inflate
\r
5270 ; 1007 : strm->msg = (char *)"invalid literal/lengths set";
\r
5272 00c4c 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
5274 ; 1008 : state->mode = BAD;
\r
5277 00c4f 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
5278 00c52 c7 41 18 00 00
\r
5279 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BM@IIMGAINC@invalid?5literal?1lengths?5set?$AA@
\r
5280 00c59 e9 73 06 00 00 jmp $LN786@inflate
\r
5284 ; 1011 : state->distcode = (code const FAR *)(state->next);
\r
5286 00c5e 8b 57 6c mov edx, DWORD PTR [edi+108]
\r
5287 00c61 8d 4f 6c lea ecx, DWORD PTR [edi+108]
\r
5288 00c64 89 57 50 mov DWORD PTR [edi+80], edx
\r
5290 ; 1012 : state->distbits = 6;
\r
5291 ; 1013 : ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
\r
5292 ; 1014 : &(state->next), &(state->distbits), state->work);
\r
5294 00c67 8d 97 f0 02 00
\r
5295 00 lea edx, DWORD PTR [edi+752]
\r
5297 00c6e 8d 47 58 lea eax, DWORD PTR [edi+88]
\r
5300 00c73 8b 4f 60 mov ecx, DWORD PTR [edi+96]
\r
5301 00c76 c7 00 06 00 00
\r
5302 00 mov DWORD PTR [eax], 6
\r
5303 00c7c 8b 47 64 mov eax, DWORD PTR [edi+100]
\r
5305 00c80 8d 54 4f 70 lea edx, DWORD PTR [edi+ecx*2+112]
\r
5307 00c85 6a 02 push 2
\r
5308 00c87 e8 00 00 00 00 call _inflate_table
\r
5310 ; 1017 : state->mode = BAD;
\r
5313 00c8c 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
5314 00c8f 83 c4 18 add esp, 24 ; 00000018H
\r
5315 00c92 89 45 d8 mov DWORD PTR _ret$[ebp], eax
\r
5316 00c95 85 c0 test eax, eax
\r
5317 00c97 74 0f je SHORT $LN149@inflate
\r
5319 ; 1015 : if (ret) {
\r
5320 ; 1016 : strm->msg = (char *)"invalid distances set";
\r
5322 00c99 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5323 00c9c c7 40 18 00 00
\r
5324 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BG@GMDFCBGP@invalid?5distances?5set?$AA@
\r
5326 ; 1017 : state->mode = BAD;
\r
5329 00ca3 e9 29 06 00 00 jmp $LN786@inflate
\r
5333 ; 1020 : Tracev((stderr, "inflate: codes ok\n"));
\r
5334 ; 1021 : state->mode = LEN_;
\r
5335 ; 1022 : if (flush == Z_TREES) goto inf_leave;
\r
5337 00ca8 83 7d 0c 06 cmp DWORD PTR _flush$[ebp], 6
\r
5338 00cac c7 07 13 00 00
\r
5339 00 mov DWORD PTR [edi], 19 ; 00000013H
\r
5340 00cb2 0f 84 7d 06 00
\r
5341 00 je $inf_leave$80408
\r
5344 ; 1023 : case LEN_:
\r
5345 ; 1024 : state->mode = LEN;
\r
5347 00cb8 c7 07 14 00 00
\r
5348 00 mov DWORD PTR [edi], 20 ; 00000014H
\r
5351 ; 1025 : case LEN:
\r
5352 ; 1026 : if (have >= 6 && left >= 258) {
\r
5354 00cbe 83 7d fc 06 cmp DWORD PTR _have$[ebp], 6
\r
5355 00cc2 72 6e jb SHORT $LN145@inflate
\r
5356 00cc4 81 7d f0 02 01
\r
5357 00 00 cmp DWORD PTR _left$[ebp], 258 ; 00000102H
\r
5358 00ccb 72 65 jb SHORT $LN145@inflate
\r
5360 ; 1027 : RESTORE();
\r
5362 00ccd 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5363 00cd0 8b 4d e8 mov ecx, DWORD PTR _put$[ebp]
\r
5364 00cd3 8b 55 f0 mov edx, DWORD PTR _left$[ebp]
\r
5365 00cd6 89 48 0c mov DWORD PTR [eax+12], ecx
\r
5366 00cd9 8b 4d f8 mov ecx, DWORD PTR _next$[ebp]
\r
5367 00cdc 89 08 mov DWORD PTR [eax], ecx
\r
5369 ; 1028 : inflate_fast(strm, out);
\r
5371 00cde 8b 4d e0 mov ecx, DWORD PTR _out$[ebp]
\r
5372 00ce1 89 50 10 mov DWORD PTR [eax+16], edx
\r
5373 00ce4 8b 55 fc mov edx, DWORD PTR _have$[ebp]
\r
5375 00ce8 89 50 04 mov DWORD PTR [eax+4], edx
\r
5377 00cec 89 5f 38 mov DWORD PTR [edi+56], ebx
\r
5378 00cef 89 77 3c mov DWORD PTR [edi+60], esi
\r
5379 00cf2 e8 00 00 00 00 call _inflate_fast
\r
5383 00cf7 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5384 00cfa 8b 50 0c mov edx, DWORD PTR [eax+12]
\r
5385 00cfd 8b 48 10 mov ecx, DWORD PTR [eax+16]
\r
5386 00d00 8b 5f 38 mov ebx, DWORD PTR [edi+56]
\r
5387 00d03 8b 77 3c mov esi, DWORD PTR [edi+60]
\r
5388 00d06 89 55 e8 mov DWORD PTR _put$[ebp], edx
\r
5389 00d09 8b 10 mov edx, DWORD PTR [eax]
\r
5390 00d0b 8b 40 04 mov eax, DWORD PTR [eax+4]
\r
5391 00d0e 83 c4 08 add esp, 8
\r
5393 ; 1030 : if (state->mode == TYPE)
\r
5395 00d11 83 3f 0b cmp DWORD PTR [edi], 11 ; 0000000bH
\r
5396 00d14 89 4d f0 mov DWORD PTR _left$[ebp], ecx
\r
5397 00d17 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5398 00d1a 89 45 fc mov DWORD PTR _have$[ebp], eax
\r
5399 00d1d 0f 85 b4 05 00
\r
5400 00 jne $LN490@inflate
\r
5402 ; 1031 : state->back = -1;
\r
5404 00d23 c7 87 c4 1b 00
\r
5405 00 ff ff ff ff mov DWORD PTR [edi+7108], -1
\r
5409 00d2d e9 a5 05 00 00 jmp $LN490@inflate
\r
5413 ; 1034 : state->back = 0;
\r
5414 ; 1035 : for (;;) {
\r
5415 ; 1036 : here = state->lencode[BITS(state->lenbits)];
\r
5417 00d32 8b 4f 54 mov ecx, DWORD PTR [edi+84]
\r
5418 00d35 b8 01 00 00 00 mov eax, 1
\r
5419 00d3a d3 e0 shl eax, cl
\r
5420 00d3c c7 87 c4 1b 00
\r
5421 00 00 00 00 00 mov DWORD PTR [edi+7108], 0
\r
5423 00d47 23 c3 and eax, ebx
\r
5424 00d49 8b c8 mov ecx, eax
\r
5425 00d4b 8b 47 4c mov eax, DWORD PTR [edi+76]
\r
5426 00d4e 8b 04 88 mov eax, DWORD PTR [eax+ecx*4]
\r
5428 ; 1037 : if ((unsigned)(here.bits) <= bits) break;
\r
5430 00d51 8b c8 mov ecx, eax
\r
5431 00d53 c1 e9 08 shr ecx, 8
\r
5432 00d56 0f b6 c9 movzx ecx, cl
\r
5433 00d59 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5434 00d5c 3b ce cmp ecx, esi
\r
5435 00d5e 76 3f jbe SHORT $LN562@inflate
\r
5438 ; 1038 : PULLBYTE();
\r
5440 00d60 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5441 00d64 0f 84 cb 05 00
\r
5442 00 je $inf_leave$80408
\r
5443 00d6a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5444 00d6d ff 4d fc dec DWORD PTR _have$[ebp]
\r
5445 00d70 8b ce mov ecx, esi
\r
5446 00d72 d3 e0 shl eax, cl
\r
5447 00d74 8b 4f 54 mov ecx, DWORD PTR [edi+84]
\r
5449 00d78 83 c6 08 add esi, 8
\r
5450 00d7b 03 d8 add ebx, eax
\r
5451 00d7d b8 01 00 00 00 mov eax, 1
\r
5452 00d82 d3 e0 shl eax, cl
\r
5453 00d84 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
5454 00d87 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5456 00d8b 23 c3 and eax, ebx
\r
5457 00d8d 8b 04 81 mov eax, DWORD PTR [ecx+eax*4]
\r
5458 00d90 8b c8 mov ecx, eax
\r
5459 00d92 c1 e9 08 shr ecx, 8
\r
5460 00d95 0f b6 c9 movzx ecx, cl
\r
5461 00d98 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5462 00d9b 3b ce cmp ecx, esi
\r
5463 00d9d 77 c1 ja SHORT $LL137@inflate
\r
5467 ; 1040 : if (here.op && (here.op & 0xf0) == 0) {
\r
5469 00d9f 84 c0 test al, al
\r
5470 00da1 0f 84 c0 00 00
\r
5471 00 je $LN119@inflate
\r
5472 00da7 a8 f0 test al, 240 ; 000000f0H
\r
5473 00da9 0f 85 b8 00 00
\r
5474 00 jne $LN119@inflate
\r
5476 ; 1041 : last = here;
\r
5477 ; 1042 : for (;;) {
\r
5478 ; 1043 : here = state->lencode[last.val +
\r
5479 ; 1044 : (BITS(last.bits + last.op) >> last.bits)];
\r
5481 00daf 8b c8 mov ecx, eax
\r
5482 00db1 c1 e9 08 shr ecx, 8
\r
5483 00db4 89 4d d4 mov DWORD PTR tv2288[ebp], ecx
\r
5484 00db7 0f b6 c9 movzx ecx, cl
\r
5485 00dba 89 4d e4 mov DWORD PTR tv2289[ebp], ecx
\r
5486 00dbd 0f b6 c8 movzx ecx, al
\r
5487 00dc0 03 4d e4 add ecx, DWORD PTR tv2289[ebp]
\r
5488 00dc3 89 45 dc mov DWORD PTR _last$[ebp], eax
\r
5489 00dc6 b8 01 00 00 00 mov eax, 1
\r
5490 00dcb d3 e0 shl eax, cl
\r
5491 00dcd 8b 4d e4 mov ecx, DWORD PTR tv2289[ebp]
\r
5493 00dd1 23 c3 and eax, ebx
\r
5494 00dd3 d3 e8 shr eax, cl
\r
5495 00dd5 8b 4d f4 mov ecx, DWORD PTR _here$[ebp]
\r
5496 00dd8 c1 e9 10 shr ecx, 16 ; 00000010H
\r
5497 00ddb 03 c1 add eax, ecx
\r
5498 00ddd 8b c8 mov ecx, eax
\r
5499 00ddf 8b 47 4c mov eax, DWORD PTR [edi+76]
\r
5500 00de2 8b 04 88 mov eax, DWORD PTR [eax+ecx*4]
\r
5502 ; 1045 : if ((unsigned)(last.bits + here.bits) <= bits) break;
\r
5504 00de5 0f b6 4d d4 movzx ecx, BYTE PTR tv2288[ebp]
\r
5505 00de9 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5506 00dec c1 e8 08 shr eax, 8
\r
5507 00def 0f b6 c0 movzx eax, al
\r
5508 00df2 03 c1 add eax, ecx
\r
5509 00df4 3b c6 cmp eax, esi
\r
5510 00df6 76 5e jbe SHORT $LN122@inflate
\r
5511 00df8 eb 06 8d 9b 00
\r
5515 ; 1046 : PULLBYTE();
\r
5517 00e00 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5518 00e04 0f 84 2b 05 00
\r
5519 00 je $inf_leave$80408
\r
5520 00e0a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5521 00e0d 8b ce mov ecx, esi
\r
5522 00e0f d3 e0 shl eax, cl
\r
5523 00e11 8b 4d dc mov ecx, DWORD PTR _last$[ebp]
\r
5524 00e14 ff 4d fc dec DWORD PTR _have$[ebp]
\r
5526 00e18 03 d8 add ebx, eax
\r
5527 00e1a 0f b6 c5 movzx eax, ch
\r
5528 00e1d 89 45 e4 mov DWORD PTR tv2387[ebp], eax
\r
5529 00e20 0f b6 c9 movzx ecx, cl
\r
5530 00e23 03 c8 add ecx, eax
\r
5531 00e25 b8 01 00 00 00 mov eax, 1
\r
5532 00e2a d3 e0 shl eax, cl
\r
5533 00e2c 8b 4d e4 mov ecx, DWORD PTR tv2387[ebp]
\r
5534 00e2f 83 c6 08 add esi, 8
\r
5535 00e32 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5537 00e36 23 c3 and eax, ebx
\r
5538 00e38 d3 e8 shr eax, cl
\r
5539 00e3a 0f b7 4d de movzx ecx, WORD PTR _last$[ebp+2]
\r
5540 00e3e 03 c1 add eax, ecx
\r
5541 00e40 8b 4f 4c mov ecx, DWORD PTR [edi+76]
\r
5542 00e43 8b 04 81 mov eax, DWORD PTR [ecx+eax*4]
\r
5543 00e46 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5544 00e49 c1 e8 08 shr eax, 8
\r
5545 00e4c 0f b6 c0 movzx eax, al
\r
5546 00e4f 03 45 e4 add eax, DWORD PTR tv2387[ebp]
\r
5547 00e52 3b c6 cmp eax, esi
\r
5548 00e54 77 aa ja SHORT $LL129@inflate
\r
5552 ; 1048 : DROPBITS(last.bits);
\r
5554 00e56 0f b6 4d dd movzx ecx, BYTE PTR _last$[ebp+1]
\r
5556 ; 1049 : state->back += last.bits;
\r
5558 00e5a 8b 45 f4 mov eax, DWORD PTR _here$[ebp]
\r
5559 00e5d d3 eb shr ebx, cl
\r
5560 00e5f 2b f1 sub esi, ecx
\r
5561 00e61 89 8f c4 1b 00
\r
5562 00 mov DWORD PTR [edi+7108], ecx
\r
5566 ; 1051 : DROPBITS(here.bits);
\r
5568 00e67 8b c8 mov ecx, eax
\r
5569 00e69 c1 e9 08 shr ecx, 8
\r
5570 00e6c 0f b6 c9 movzx ecx, cl
\r
5572 ; 1052 : state->back += here.bits;
\r
5574 00e6f 01 8f c4 1b 00
\r
5575 00 add DWORD PTR [edi+7108], ecx
\r
5576 00e75 d3 eb shr ebx, cl
\r
5577 00e77 2b f1 sub esi, ecx
\r
5578 00e79 89 4d e4 mov DWORD PTR tv2289[ebp], ecx
\r
5580 ; 1053 : state->length = (unsigned)here.val;
\r
5582 00e7c 8b c8 mov ecx, eax
\r
5583 00e7e c1 e9 10 shr ecx, 16 ; 00000010H
\r
5584 00e81 89 4f 40 mov DWORD PTR [edi+64], ecx
\r
5586 ; 1054 : if ((int)(here.op) == 0) {
\r
5588 00e84 84 c0 test al, al
\r
5589 00e86 75 0b jne SHORT $LN116@inflate
\r
5591 ; 1055 : Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
\r
5592 ; 1056 : "inflate: literal '%c'\n" :
\r
5593 ; 1057 : "inflate: literal 0x%02x\n", here.val));
\r
5594 ; 1058 : state->mode = LIT;
\r
5596 00e88 c7 07 19 00 00
\r
5597 00 mov DWORD PTR [edi], 25 ; 00000019H
\r
5601 00e8e e9 44 04 00 00 jmp $LN490@inflate
\r
5605 ; 1061 : if (here.op & 32) {
\r
5607 00e93 a8 20 test al, 32 ; 00000020H
\r
5608 00e95 74 15 je SHORT $LN115@inflate
\r
5610 ; 1062 : Tracevv((stderr, "inflate: end of block\n"));
\r
5611 ; 1063 : state->back = -1;
\r
5613 00e97 c7 87 c4 1b 00
\r
5614 00 ff ff ff ff mov DWORD PTR [edi+7108], -1
\r
5617 ; 1064 : state->mode = TYPE;
\r
5619 00ea1 c7 07 0b 00 00
\r
5620 00 mov DWORD PTR [edi], 11 ; 0000000bH
\r
5624 00ea7 e9 2b 04 00 00 jmp $LN490@inflate
\r
5628 ; 1067 : if (here.op & 64) {
\r
5630 00eac a8 40 test al, 64 ; 00000040H
\r
5631 00eae 74 0f je SHORT $LN114@inflate
\r
5633 ; 1068 : strm->msg = (char *)"invalid literal/length code";
\r
5635 00eb0 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5636 00eb3 c7 40 18 00 00
\r
5637 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BM@FFFLPBBC@invalid?5literal?1length?5code?$AA@
\r
5639 ; 1069 : state->mode = BAD;
\r
5642 00eba e9 12 04 00 00 jmp $LN786@inflate
\r
5646 ; 1072 : state->extra = (unsigned)(here.op) & 15;
\r
5648 00ebf 0f b6 c8 movzx ecx, al
\r
5649 00ec2 83 e1 0f and ecx, 15 ; 0000000fH
\r
5650 00ec5 89 4f 48 mov DWORD PTR [edi+72], ecx
\r
5652 ; 1073 : state->mode = LENEXT;
\r
5654 00ec8 c7 07 15 00 00
\r
5655 00 mov DWORD PTR [edi], 21 ; 00000015H
\r
5658 ; 1074 : case LENEXT:
\r
5659 ; 1075 : if (state->extra) {
\r
5661 00ece 8b 47 48 mov eax, DWORD PTR [edi+72]
\r
5662 00ed1 85 c0 test eax, eax
\r
5663 00ed3 74 47 je SHORT $LN736@inflate
\r
5665 ; 1076 : NEEDBITS(state->extra);
\r
5667 00ed5 3b f0 cmp esi, eax
\r
5668 00ed7 73 29 jae SHORT $LN110@inflate
\r
5669 00ed9 8d a4 24 00 00
\r
5672 00ee0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5673 00ee4 0f 84 4b 04 00
\r
5674 00 je $inf_leave$80408
\r
5675 00eea 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5676 00eed ff 4d fc dec DWORD PTR _have$[ebp]
\r
5677 00ef0 8b ce mov ecx, esi
\r
5678 00ef2 d3 e0 shl eax, cl
\r
5680 00ef5 83 c6 08 add esi, 8
\r
5681 00ef8 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5682 00efb 03 d8 add ebx, eax
\r
5683 00efd 3b 77 48 cmp esi, DWORD PTR [edi+72]
\r
5684 00f00 72 de jb SHORT $LL108@inflate
\r
5687 ; 1077 : state->length += BITS(state->extra);
\r
5689 00f02 8b 4f 48 mov ecx, DWORD PTR [edi+72]
\r
5690 00f05 b8 01 00 00 00 mov eax, 1
\r
5691 00f0a d3 e0 shl eax, cl
\r
5693 ; 1078 : DROPBITS(state->extra);
\r
5695 00f0c 2b f1 sub esi, ecx
\r
5697 00f0f 23 c3 and eax, ebx
\r
5698 00f11 01 47 40 add DWORD PTR [edi+64], eax
\r
5699 00f14 d3 eb shr ebx, cl
\r
5701 ; 1079 : state->back += state->extra;
\r
5703 00f16 01 8f c4 1b 00
\r
5704 00 add DWORD PTR [edi+7108], ecx
\r
5708 ; 1081 : Tracevv((stderr, "inflate: length %u\n", state->length));
\r
5709 ; 1082 : state->was = state->length;
\r
5711 00f1c 8b 4f 40 mov ecx, DWORD PTR [edi+64]
\r
5712 00f1f 89 8f c8 1b 00
\r
5713 00 mov DWORD PTR [edi+7112], ecx
\r
5715 ; 1083 : state->mode = DIST;
\r
5717 00f25 c7 07 16 00 00
\r
5718 00 mov DWORD PTR [edi], 22 ; 00000016H
\r
5721 ; 1084 : case DIST:
\r
5722 ; 1085 : for (;;) {
\r
5723 ; 1086 : here = state->distcode[BITS(state->distbits)];
\r
5725 00f2b 8b 4f 58 mov ecx, DWORD PTR [edi+88]
\r
5726 00f2e b8 01 00 00 00 mov eax, 1
\r
5727 00f33 d3 e0 shl eax, cl
\r
5729 00f36 23 c3 and eax, ebx
\r
5730 00f38 8b c8 mov ecx, eax
\r
5731 00f3a 8b 47 50 mov eax, DWORD PTR [edi+80]
\r
5732 00f3d 8b 04 88 mov eax, DWORD PTR [eax+ecx*4]
\r
5734 ; 1087 : if ((unsigned)(here.bits) <= bits) break;
\r
5736 00f40 8b c8 mov ecx, eax
\r
5737 00f42 c1 e9 08 shr ecx, 8
\r
5738 00f45 0f b6 c9 movzx ecx, cl
\r
5739 00f48 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5740 00f4b 3b ce cmp ecx, esi
\r
5741 00f4d 76 40 jbe SHORT $LN567@inflate
\r
5745 ; 1088 : PULLBYTE();
\r
5747 00f50 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5748 00f54 0f 84 db 03 00
\r
5749 00 je $inf_leave$80408
\r
5750 00f5a 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5751 00f5d ff 4d fc dec DWORD PTR _have$[ebp]
\r
5752 00f60 8b ce mov ecx, esi
\r
5753 00f62 d3 e0 shl eax, cl
\r
5754 00f64 8b 4f 58 mov ecx, DWORD PTR [edi+88]
\r
5756 00f68 83 c6 08 add esi, 8
\r
5757 00f6b 03 d8 add ebx, eax
\r
5758 00f6d b8 01 00 00 00 mov eax, 1
\r
5759 00f72 d3 e0 shl eax, cl
\r
5760 00f74 8b 4f 50 mov ecx, DWORD PTR [edi+80]
\r
5761 00f77 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5763 00f7b 23 c3 and eax, ebx
\r
5764 00f7d 8b 04 81 mov eax, DWORD PTR [ecx+eax*4]
\r
5765 00f80 8b c8 mov ecx, eax
\r
5766 00f82 c1 e9 08 shr ecx, 8
\r
5767 00f85 0f b6 c9 movzx ecx, cl
\r
5768 00f88 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5769 00f8b 3b ce cmp ecx, esi
\r
5770 00f8d 77 c1 ja SHORT $LL98@inflate
\r
5774 ; 1090 : if ((here.op & 0xf0) == 0) {
\r
5776 00f8f a8 f0 test al, 240 ; 000000f0H
\r
5777 00f91 0f 85 b0 00 00
\r
5778 00 jne $LN80@inflate
\r
5780 ; 1091 : last = here;
\r
5781 ; 1092 : for (;;) {
\r
5782 ; 1093 : here = state->distcode[last.val +
\r
5783 ; 1094 : (BITS(last.bits + last.op) >> last.bits)];
\r
5785 00f97 8b c8 mov ecx, eax
\r
5786 00f99 c1 e9 08 shr ecx, 8
\r
5787 00f9c 89 4d d4 mov DWORD PTR tv2288[ebp], ecx
\r
5788 00f9f 0f b6 c9 movzx ecx, cl
\r
5789 00fa2 89 4d e4 mov DWORD PTR tv2289[ebp], ecx
\r
5790 00fa5 0f b6 c8 movzx ecx, al
\r
5791 00fa8 03 4d e4 add ecx, DWORD PTR tv2289[ebp]
\r
5792 00fab 89 45 dc mov DWORD PTR _last$[ebp], eax
\r
5793 00fae b8 01 00 00 00 mov eax, 1
\r
5794 00fb3 d3 e0 shl eax, cl
\r
5795 00fb5 8b 4d e4 mov ecx, DWORD PTR tv2289[ebp]
\r
5797 00fb9 23 c3 and eax, ebx
\r
5798 00fbb d3 e8 shr eax, cl
\r
5799 00fbd 8b 4d f4 mov ecx, DWORD PTR _here$[ebp]
\r
5800 00fc0 c1 e9 10 shr ecx, 16 ; 00000010H
\r
5801 00fc3 03 c1 add eax, ecx
\r
5802 00fc5 8b c8 mov ecx, eax
\r
5803 00fc7 8b 47 50 mov eax, DWORD PTR [edi+80]
\r
5804 00fca 8b 04 88 mov eax, DWORD PTR [eax+ecx*4]
\r
5806 ; 1095 : if ((unsigned)(last.bits + here.bits) <= bits) break;
\r
5808 00fcd 0f b6 4d d4 movzx ecx, BYTE PTR tv2288[ebp]
\r
5809 00fd1 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5810 00fd4 c1 e8 08 shr eax, 8
\r
5811 00fd7 0f b6 c0 movzx eax, al
\r
5812 00fda 03 c1 add eax, ecx
\r
5813 00fdc 3b c6 cmp eax, esi
\r
5814 00fde 76 56 jbe SHORT $LN83@inflate
\r
5817 ; 1096 : PULLBYTE();
\r
5819 00fe0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5820 00fe4 0f 84 4b 03 00
\r
5821 00 je $inf_leave$80408
\r
5822 00fea 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5823 00fed 8b ce mov ecx, esi
\r
5824 00fef d3 e0 shl eax, cl
\r
5825 00ff1 8b 4d dc mov ecx, DWORD PTR _last$[ebp]
\r
5826 00ff4 ff 4d fc dec DWORD PTR _have$[ebp]
\r
5828 00ff8 03 d8 add ebx, eax
\r
5829 00ffa 0f b6 c5 movzx eax, ch
\r
5830 00ffd 89 45 e4 mov DWORD PTR tv2387[ebp], eax
\r
5831 01000 0f b6 c9 movzx ecx, cl
\r
5832 01003 03 c8 add ecx, eax
\r
5833 01005 b8 01 00 00 00 mov eax, 1
\r
5834 0100a d3 e0 shl eax, cl
\r
5835 0100c 8b 4d e4 mov ecx, DWORD PTR tv2387[ebp]
\r
5836 0100f 83 c6 08 add esi, 8
\r
5837 01012 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5839 01016 23 c3 and eax, ebx
\r
5840 01018 d3 e8 shr eax, cl
\r
5841 0101a 0f b7 4d de movzx ecx, WORD PTR _last$[ebp+2]
\r
5842 0101e 03 c1 add eax, ecx
\r
5843 01020 8b 4f 50 mov ecx, DWORD PTR [edi+80]
\r
5844 01023 8b 04 81 mov eax, DWORD PTR [ecx+eax*4]
\r
5845 01026 89 45 f4 mov DWORD PTR _here$[ebp], eax
\r
5846 01029 c1 e8 08 shr eax, 8
\r
5847 0102c 0f b6 c0 movzx eax, al
\r
5848 0102f 03 45 e4 add eax, DWORD PTR tv2387[ebp]
\r
5849 01032 3b c6 cmp eax, esi
\r
5850 01034 77 aa ja SHORT $LL90@inflate
\r
5854 ; 1098 : DROPBITS(last.bits);
\r
5856 01036 0f b6 4d dd movzx ecx, BYTE PTR _last$[ebp+1]
\r
5858 ; 1099 : state->back += last.bits;
\r
5860 0103a 8b 45 f4 mov eax, DWORD PTR _here$[ebp]
\r
5861 0103d d3 eb shr ebx, cl
\r
5862 0103f 2b f1 sub esi, ecx
\r
5863 01041 01 8f c4 1b 00
\r
5864 00 add DWORD PTR [edi+7108], ecx
\r
5868 ; 1101 : DROPBITS(here.bits);
\r
5870 01047 8b c8 mov ecx, eax
\r
5871 01049 c1 e9 08 shr ecx, 8
\r
5872 0104c 0f b6 c9 movzx ecx, cl
\r
5874 ; 1102 : state->back += here.bits;
\r
5876 0104f 01 8f c4 1b 00
\r
5877 00 add DWORD PTR [edi+7108], ecx
\r
5878 01055 d3 eb shr ebx, cl
\r
5879 01057 2b f1 sub esi, ecx
\r
5880 01059 89 4d e4 mov DWORD PTR tv2289[ebp], ecx
\r
5882 ; 1103 : if (here.op & 64) {
\r
5884 0105c a8 40 test al, 64 ; 00000040H
\r
5885 0105e 74 0f je SHORT $LN77@inflate
\r
5887 ; 1104 : strm->msg = (char *)"invalid distance code";
\r
5889 01060 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
5890 01063 c7 40 18 00 00
\r
5891 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BG@LBKINIKP@invalid?5distance?5code?$AA@
\r
5893 ; 1105 : state->mode = BAD;
\r
5896 0106a e9 62 02 00 00 jmp $LN786@inflate
\r
5900 ; 1108 : state->offset = (unsigned)here.val;
\r
5902 0106f 8b c8 mov ecx, eax
\r
5904 ; 1109 : state->extra = (unsigned)(here.op) & 15;
\r
5906 01071 0f b6 c0 movzx eax, al
\r
5907 01074 c1 e9 10 shr ecx, 16 ; 00000010H
\r
5908 01077 83 e0 0f and eax, 15 ; 0000000fH
\r
5909 0107a 89 4f 44 mov DWORD PTR [edi+68], ecx
\r
5910 0107d 89 47 48 mov DWORD PTR [edi+72], eax
\r
5912 ; 1110 : state->mode = DISTEXT;
\r
5914 01080 c7 07 17 00 00
\r
5915 00 mov DWORD PTR [edi], 23 ; 00000017H
\r
5918 ; 1111 : case DISTEXT:
\r
5919 ; 1112 : if (state->extra) {
\r
5921 01086 8b 47 48 mov eax, DWORD PTR [edi+72]
\r
5922 01089 85 c0 test eax, eax
\r
5923 0108b 74 40 je SHORT $LN75@inflate
\r
5925 ; 1113 : NEEDBITS(state->extra);
\r
5927 0108d 3b f0 cmp esi, eax
\r
5928 0108f 73 22 jae SHORT $LN73@inflate
\r
5930 01091 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
5931 01095 0f 84 9a 02 00
\r
5932 00 je $inf_leave$80408
\r
5933 0109b 0f b6 02 movzx eax, BYTE PTR [edx]
\r
5934 0109e ff 4d fc dec DWORD PTR _have$[ebp]
\r
5935 010a1 8b ce mov ecx, esi
\r
5936 010a3 d3 e0 shl eax, cl
\r
5938 010a6 83 c6 08 add esi, 8
\r
5939 010a9 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
5940 010ac 03 d8 add ebx, eax
\r
5941 010ae 3b 77 48 cmp esi, DWORD PTR [edi+72]
\r
5942 010b1 72 de jb SHORT $LL71@inflate
\r
5945 ; 1114 : state->offset += BITS(state->extra);
\r
5947 010b3 8b 4f 48 mov ecx, DWORD PTR [edi+72]
\r
5948 010b6 b8 01 00 00 00 mov eax, 1
\r
5949 010bb d3 e0 shl eax, cl
\r
5951 ; 1115 : DROPBITS(state->extra);
\r
5953 010bd 2b f1 sub esi, ecx
\r
5955 010c0 23 c3 and eax, ebx
\r
5956 010c2 01 47 44 add DWORD PTR [edi+68], eax
\r
5957 010c5 d3 eb shr ebx, cl
\r
5959 ; 1116 : state->back += state->extra;
\r
5961 010c7 01 8f c4 1b 00
\r
5962 00 add DWORD PTR [edi+7108], ecx
\r
5966 ; 1118 : #ifdef INFLATE_STRICT
\r
5967 ; 1119 : if (state->offset > state->dmax) {
\r
5968 ; 1120 : strm->msg = (char *)"invalid distance too far back";
\r
5969 ; 1121 : state->mode = BAD;
\r
5973 ; 1125 : Tracevv((stderr, "inflate: distance %u\n", state->offset));
\r
5974 ; 1126 : state->mode = MATCH;
\r
5976 010cd c7 07 18 00 00
\r
5977 00 mov DWORD PTR [edi], 24 ; 00000018H
\r
5980 ; 1127 : case MATCH:
\r
5981 ; 1128 : if (left == 0) goto inf_leave;
\r
5983 010d3 83 7d f0 00 cmp DWORD PTR _left$[ebp], 0
\r
5984 010d7 0f 84 58 02 00
\r
5985 00 je $inf_leave$80408
\r
5987 ; 1129 : copy = out - left;
\r
5989 010dd 8b 4d e0 mov ecx, DWORD PTR _out$[ebp]
\r
5990 010e0 2b 4d f0 sub ecx, DWORD PTR _left$[ebp]
\r
5992 ; 1130 : if (state->offset > copy) { /* copy from window */
\r
5994 010e3 8b 47 44 mov eax, DWORD PTR [edi+68]
\r
5995 010e6 3b c1 cmp eax, ecx
\r
5996 010e8 76 54 jbe SHORT $LN60@inflate
\r
5998 ; 1131 : copy = state->offset - copy;
\r
6000 010ea 2b c1 sub eax, ecx
\r
6001 010ec 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
6003 ; 1132 : if (copy > state->whave) {
\r
6005 010ef 3b 47 2c cmp eax, DWORD PTR [edi+44]
\r
6006 010f2 76 18 jbe SHORT $LN58@inflate
\r
6008 ; 1133 : if (state->sane) {
\r
6010 010f4 83 bf c0 1b 00
\r
6011 00 00 cmp DWORD PTR [edi+7104], 0
\r
6012 010fb 74 0f je SHORT $LN58@inflate
\r
6014 ; 1134 : strm->msg = (char *)"invalid distance too far back";
\r
6016 010fd 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6017 01100 c7 41 18 00 00
\r
6018 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BO@ECPMAOGG@invalid?5distance?5too?5far?5back?$AA@
\r
6020 ; 1135 : state->mode = BAD;
\r
6023 01107 e9 c5 01 00 00 jmp $LN786@inflate
\r
6027 ; 1138 : #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
\r
6028 ; 1139 : Trace((stderr, "inflate.c too far\n"));
\r
6029 ; 1140 : copy -= state->whave;
\r
6030 ; 1141 : if (copy > state->length) copy = state->length;
\r
6031 ; 1142 : if (copy > left) copy = left;
\r
6032 ; 1143 : left -= copy;
\r
6033 ; 1144 : state->length -= copy;
\r
6035 ; 1146 : *put++ = 0;
\r
6036 ; 1147 : } while (--copy);
\r
6037 ; 1148 : if (state->length == 0) state->mode = LEN;
\r
6041 ; 1152 : if (copy > state->wnext) {
\r
6043 0110c 8b 4f 30 mov ecx, DWORD PTR [edi+48]
\r
6044 0110f 3b c1 cmp eax, ecx
\r
6045 01111 76 0f jbe SHORT $LN57@inflate
\r
6047 ; 1153 : copy -= state->wnext;
\r
6049 01113 2b c1 sub eax, ecx
\r
6051 ; 1154 : from = state->window + (state->wsize - copy);
\r
6053 01115 8b 4f 34 mov ecx, DWORD PTR [edi+52]
\r
6054 01118 03 4f 28 add ecx, DWORD PTR [edi+40]
\r
6055 0111b 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
6056 0111e 2b c8 sub ecx, eax
\r
6061 01120 eb 0b jmp SHORT $LN784@inflate
\r
6064 ; 1157 : from = state->window + (state->wnext - copy);
\r
6066 01122 8b 4f 34 mov ecx, DWORD PTR [edi+52]
\r
6067 01125 2b c8 sub ecx, eax
\r
6068 01127 03 4f 30 add ecx, DWORD PTR [edi+48]
\r
6069 0112a 8b 45 f4 mov eax, DWORD PTR _copy$[ebp]
\r
6071 0112d 89 4d d4 mov DWORD PTR _from$[ebp], ecx
\r
6073 ; 1158 : if (copy > state->length) copy = state->length;
\r
6075 01130 8b 4f 40 mov ecx, DWORD PTR [edi+64]
\r
6076 01133 89 4d dc mov DWORD PTR tv2131[ebp], ecx
\r
6077 01136 3b c1 cmp eax, ecx
\r
6078 01138 76 15 jbe SHORT $LN54@inflate
\r
6079 0113a 8b c1 mov eax, ecx
\r
6082 ; 1160 : else { /* copy from output */
\r
6084 0113c eb 0e jmp SHORT $LN785@inflate
\r
6087 ; 1161 : from = put - state->offset;
\r
6089 0113e 8b 4d e8 mov ecx, DWORD PTR _put$[ebp]
\r
6090 01141 2b c8 sub ecx, eax
\r
6092 ; 1162 : copy = state->length;
\r
6094 01143 8b 47 40 mov eax, DWORD PTR [edi+64]
\r
6095 01146 89 4d d4 mov DWORD PTR _from$[ebp], ecx
\r
6096 01149 89 45 dc mov DWORD PTR tv2131[ebp], eax
\r
6098 0114c 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
6102 ; 1164 : if (copy > left) copy = left;
\r
6104 0114f 8b 4d f0 mov ecx, DWORD PTR _left$[ebp]
\r
6105 01152 3b c1 cmp eax, ecx
\r
6106 01154 76 05 jbe SHORT $LN53@inflate
\r
6107 01156 8b c1 mov eax, ecx
\r
6108 01158 89 45 f4 mov DWORD PTR _copy$[ebp], eax
\r
6111 ; 1165 : left -= copy;
\r
6113 0115b 2b c8 sub ecx, eax
\r
6114 0115d 89 4d f0 mov DWORD PTR _left$[ebp], ecx
\r
6116 ; 1166 : state->length -= copy;
\r
6118 01160 8b 4d dc mov ecx, DWORD PTR tv2131[ebp]
\r
6119 01163 2b c8 sub ecx, eax
\r
6121 ; 1169 : } while (--copy);
\r
6123 01165 8b 45 e8 mov eax, DWORD PTR _put$[ebp]
\r
6124 01168 89 4f 40 mov DWORD PTR [edi+64], ecx
\r
6125 0116b 8b 4d d4 mov ecx, DWORD PTR _from$[ebp]
\r
6126 0116e 2b 4d e8 sub ecx, DWORD PTR _put$[ebp]
\r
6127 01171 89 4d d4 mov DWORD PTR tv3076[ebp], ecx
\r
6128 01174 eb 03 jmp SHORT $LN52@inflate
\r
6130 01176 8b 4d d4 mov ecx, DWORD PTR tv3076[ebp]
\r
6134 ; 1168 : *put++ = *from++;
\r
6136 01179 8a 0c 01 mov cl, BYTE PTR [ecx+eax]
\r
6137 0117c 8b 45 e8 mov eax, DWORD PTR _put$[ebp]
\r
6138 0117f 88 08 mov BYTE PTR [eax], cl
\r
6141 ; 1169 : } while (--copy);
\r
6143 01182 ff 4d f4 dec DWORD PTR _copy$[ebp]
\r
6144 01185 89 45 e8 mov DWORD PTR _put$[ebp], eax
\r
6145 01188 75 ec jne SHORT $LL739@inflate
\r
6147 ; 1170 : if (state->length == 0) state->mode = LEN;
\r
6149 0118a 83 7f 40 00 cmp DWORD PTR [edi+64], 0
\r
6150 0118e 0f 85 43 01 00
\r
6151 00 jne $LN490@inflate
\r
6152 01194 c7 07 14 00 00
\r
6153 00 mov DWORD PTR [edi], 20 ; 00000014H
\r
6157 0119a e9 38 01 00 00 jmp $LN490@inflate
\r
6160 ; 1172 : case LIT:
\r
6161 ; 1173 : if (left == 0) goto inf_leave;
\r
6163 0119f 83 7d f0 00 cmp DWORD PTR _left$[ebp], 0
\r
6164 011a3 0f 84 8c 01 00
\r
6165 00 je $inf_leave$80408
\r
6167 ; 1174 : *put++ = (unsigned char)(state->length);
\r
6169 011a9 8b 45 e8 mov eax, DWORD PTR _put$[ebp]
\r
6170 011ac 8a 4f 40 mov cl, BYTE PTR [edi+64]
\r
6171 011af 88 08 mov BYTE PTR [eax], cl
\r
6176 011b2 ff 4d f0 dec DWORD PTR _left$[ebp]
\r
6177 011b5 89 45 e8 mov DWORD PTR _put$[ebp], eax
\r
6179 ; 1176 : state->mode = LEN;
\r
6181 011b8 c7 07 14 00 00
\r
6182 00 mov DWORD PTR [edi], 20 ; 00000014H
\r
6186 011be e9 14 01 00 00 jmp $LN490@inflate
\r
6189 ; 1178 : case CHECK:
\r
6190 ; 1179 : if (state->wrap) {
\r
6192 011c3 83 7f 08 00 cmp DWORD PTR [edi+8], 0
\r
6193 011c7 0f 84 ac 00 00
\r
6194 00 je $LN31@inflate
\r
6196 ; 1180 : NEEDBITS(32);
\r
6198 011cd 83 fe 20 cmp esi, 32 ; 00000020H
\r
6199 011d0 73 22 jae SHORT $LN43@inflate
\r
6201 011d2 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
6202 011d6 0f 84 59 01 00
\r
6203 00 je $inf_leave$80408
\r
6204 011dc 0f b6 02 movzx eax, BYTE PTR [edx]
\r
6205 011df ff 4d fc dec DWORD PTR _have$[ebp]
\r
6206 011e2 8b ce mov ecx, esi
\r
6207 011e4 d3 e0 shl eax, cl
\r
6209 011e7 83 c6 08 add esi, 8
\r
6210 011ea 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
6211 011ed 03 d8 add ebx, eax
\r
6212 011ef 83 fe 20 cmp esi, 32 ; 00000020H
\r
6213 011f2 72 de jb SHORT $LL41@inflate
\r
6216 ; 1181 : out -= left;
\r
6218 011f4 8b 45 e0 mov eax, DWORD PTR _out$[ebp]
\r
6219 011f7 2b 45 f0 sub eax, DWORD PTR _left$[ebp]
\r
6221 ; 1182 : strm->total_out += out;
\r
6223 011fa 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6224 011fd 01 41 14 add DWORD PTR [ecx+20], eax
\r
6226 ; 1183 : state->total += out;
\r
6228 01200 01 47 1c add DWORD PTR [edi+28], eax
\r
6229 01203 89 45 e0 mov DWORD PTR _out$[ebp], eax
\r
6233 01206 85 c0 test eax, eax
\r
6234 01208 74 29 je SHORT $LN35@inflate
\r
6236 ; 1185 : strm->adler = state->check =
\r
6237 ; 1186 : UPDATE(state->check, put - out, out);
\r
6239 0120a 8b 4d e8 mov ecx, DWORD PTR _put$[ebp]
\r
6240 0120d 8b 57 18 mov edx, DWORD PTR [edi+24]
\r
6242 01211 2b c8 sub ecx, eax
\r
6243 01213 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6246 01219 74 07 je SHORT $LN504@inflate
\r
6247 0121b e8 00 00 00 00 call _crc32@12
\r
6248 01220 eb 05 jmp SHORT $LN505@inflate
\r
6250 01222 e8 00 00 00 00 call _adler32@12
\r
6252 01227 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6253 0122a 8b 55 f8 mov edx, DWORD PTR _next$[ebp]
\r
6254 0122d 89 47 18 mov DWORD PTR [edi+24], eax
\r
6255 01230 89 41 30 mov DWORD PTR [ecx+48], eax
\r
6258 ; 1187 : out = left;
\r
6260 ; 1189 : #ifdef GUNZIP
\r
6261 ; 1190 : state->flags ? hold :
\r
6263 ; 1192 : REVERSE(hold)) != state->check) {
\r
6265 01233 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6266 01237 8b 45 f0 mov eax, DWORD PTR _left$[ebp]
\r
6267 0123a 89 45 e0 mov DWORD PTR _out$[ebp], eax
\r
6268 0123d 8b c3 mov eax, ebx
\r
6269 0123f 75 23 jne SHORT $LN507@inflate
\r
6270 01241 25 00 ff 00 00 and eax, 65280 ; 0000ff00H
\r
6271 01246 8b cb mov ecx, ebx
\r
6272 01248 c1 e1 10 shl ecx, 16 ; 00000010H
\r
6273 0124b 03 c1 add eax, ecx
\r
6274 0124d 8b cb mov ecx, ebx
\r
6275 0124f c1 e9 08 shr ecx, 8
\r
6276 01252 81 e1 00 ff 00
\r
6277 00 and ecx, 65280 ; 0000ff00H
\r
6278 01258 c1 e0 08 shl eax, 8
\r
6279 0125b 03 c1 add eax, ecx
\r
6280 0125d 8b cb mov ecx, ebx
\r
6281 0125f c1 e9 18 shr ecx, 24 ; 00000018H
\r
6282 01262 03 c1 add eax, ecx
\r
6284 01264 3b 47 18 cmp eax, DWORD PTR [edi+24]
\r
6285 01267 74 0c je SHORT $LN33@inflate
\r
6287 ; 1193 : strm->msg = (char *)"incorrect data check";
\r
6289 01269 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
6290 0126c c7 40 18 00 00
\r
6291 00 00 mov DWORD PTR [eax+24], OFFSET ??_C@_0BF@MEIGEHBE@incorrect?5data?5check?$AA@
\r
6293 ; 1194 : state->mode = BAD;
\r
6296 01273 eb 5c jmp SHORT $LN786@inflate
\r
6300 ; 1197 : INITBITS();
\r
6302 01275 33 db xor ebx, ebx
\r
6303 01277 33 f6 xor esi, esi
\r
6306 ; 1198 : Tracev((stderr, "inflate: check matches trailer\n"));
\r
6308 ; 1200 : #ifdef GUNZIP
\r
6309 ; 1201 : state->mode = LENGTH;
\r
6311 01279 c7 07 1b 00 00
\r
6312 00 mov DWORD PTR [edi], 27 ; 0000001bH
\r
6315 ; 1202 : case LENGTH:
\r
6316 ; 1203 : if (state->wrap && state->flags) {
\r
6318 0127f 83 7f 08 00 cmp DWORD PTR [edi+8], 0
\r
6319 01283 0f 84 96 00 00
\r
6320 00 je $LN16@inflate
\r
6321 01289 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6322 0128d 0f 84 8c 00 00
\r
6323 00 je $LN16@inflate
\r
6325 ; 1204 : NEEDBITS(32);
\r
6327 01293 83 fe 20 cmp esi, 32 ; 00000020H
\r
6328 01296 73 2a jae SHORT $LN27@inflate
\r
6329 01298 eb 06 8d 9b 00
\r
6332 012a0 83 7d fc 00 cmp DWORD PTR _have$[ebp], 0
\r
6333 012a4 0f 84 8b 00 00
\r
6334 00 je $inf_leave$80408
\r
6335 012aa 0f b6 02 movzx eax, BYTE PTR [edx]
\r
6336 012ad ff 4d fc dec DWORD PTR _have$[ebp]
\r
6337 012b0 8b ce mov ecx, esi
\r
6338 012b2 d3 e0 shl eax, cl
\r
6340 012b5 83 c6 08 add esi, 8
\r
6341 012b8 89 55 f8 mov DWORD PTR _next$[ebp], edx
\r
6342 012bb 03 d8 add ebx, eax
\r
6343 012bd 83 fe 20 cmp esi, 32 ; 00000020H
\r
6344 012c0 72 de jb SHORT $LL25@inflate
\r
6347 ; 1205 : if (hold != (state->total & 0xffffffffUL)) {
\r
6349 012c2 3b 5f 1c cmp ebx, DWORD PTR [edi+28]
\r
6350 012c5 74 54 je SHORT $LN18@inflate
\r
6352 ; 1206 : strm->msg = (char *)"incorrect length check";
\r
6354 012c7 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6355 012ca c7 41 18 00 00
\r
6356 00 00 mov DWORD PTR [ecx+24], OFFSET ??_C@_0BH@FGKKJGOC@incorrect?5length?5check?$AA@
\r
6359 ; 1207 : state->mode = BAD;
\r
6361 012d1 c7 07 1d 00 00
\r
6362 00 mov DWORD PTR [edi], 29 ; 0000001dH
\r
6365 ; 640 : out = left;
\r
6366 ; 641 : ret = Z_OK;
\r
6368 ; 643 : switch (state->mode) {
\r
6370 012d7 8b 07 mov eax, DWORD PTR [edi]
\r
6371 012d9 83 f8 1e cmp eax, 30 ; 0000001eH
\r
6372 012dc 0f 86 96 ed ff
\r
6373 ff jbe $LL493@inflate
\r
6376 ; 1220 : goto inf_leave;
\r
6377 ; 1221 : case MEM:
\r
6378 ; 1222 : return Z_MEM_ERROR;
\r
6379 ; 1223 : case SYNC:
\r
6381 ; 1225 : return Z_STREAM_ERROR;
\r
6383 012e2 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6389 ; 1255 : return ret;
\r
6392 012ea 8b e5 mov esp, ebp
\r
6394 012ed c2 08 00 ret 8
\r
6397 ; 825 : RESTORE();
\r
6399 012f0 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
6400 012f3 8b 4d e8 mov ecx, DWORD PTR _put$[ebp]
\r
6401 012f6 89 48 0c mov DWORD PTR [eax+12], ecx
\r
6402 012f9 8b 4d f0 mov ecx, DWORD PTR _left$[ebp]
\r
6403 012fc 89 10 mov DWORD PTR [eax], edx
\r
6404 012fe 8b 55 fc mov edx, DWORD PTR _have$[ebp]
\r
6405 01301 89 48 10 mov DWORD PTR [eax+16], ecx
\r
6406 01304 89 50 04 mov DWORD PTR [eax+4], edx
\r
6407 01307 89 77 3c mov DWORD PTR [edi+60], esi
\r
6409 0130b 89 5f 38 mov DWORD PTR [edi+56], ebx
\r
6412 ; 826 : return Z_NEED_DICT;
\r
6414 0130f b8 02 00 00 00 mov eax, 2
\r
6417 ; 1255 : return ret;
\r
6420 01315 8b e5 mov esp, ebp
\r
6422 01318 c2 08 00 ret 8
\r
6427 ; 1210 : INITBITS();
\r
6429 0131b 33 db xor ebx, ebx
\r
6430 0131d 33 f6 xor esi, esi
\r
6433 ; 1211 : Tracev((stderr, "inflate: length matches trailer\n"));
\r
6436 ; 1214 : state->mode = DONE;
\r
6438 0131f c7 07 1c 00 00
\r
6439 00 mov DWORD PTR [edi], 28 ; 0000001cH
\r
6442 ; 1215 : case DONE:
\r
6443 ; 1216 : ret = Z_STREAM_END;
\r
6445 01325 c7 45 d8 01 00
\r
6446 00 00 mov DWORD PTR _ret$[ebp], 1
\r
6448 ; 1217 : goto inf_leave;
\r
6450 0132c eb 07 jmp SHORT $inf_leave$80408
\r
6453 ; 1218 : case BAD:
\r
6454 ; 1219 : ret = Z_DATA_ERROR;
\r
6456 0132e c7 45 d8 fd ff
\r
6457 ff ff mov DWORD PTR _ret$[ebp], -3 ; fffffffdH
\r
6463 ; 1229 : Return from inflate(), updating the total counts and the check value.
\r
6464 ; 1230 : If there was no progress during the inflate() call, return a buffer
\r
6465 ; 1231 : error. Call updatewindow() to create and/or update the window state.
\r
6466 ; 1232 : Note: a memory error from inflate() is non-recoverable.
\r
6468 ; 1234 : inf_leave:
\r
6469 ; 1235 : RESTORE();
\r
6471 01335 8b 45 08 mov eax, DWORD PTR _strm$[ebp]
\r
6472 01338 8b 4d e8 mov ecx, DWORD PTR _put$[ebp]
\r
6473 0133b 89 48 0c mov DWORD PTR [eax+12], ecx
\r
6474 0133e 8b 4d f0 mov ecx, DWORD PTR _left$[ebp]
\r
6475 01341 89 10 mov DWORD PTR [eax], edx
\r
6476 01343 8b 55 fc mov edx, DWORD PTR _have$[ebp]
\r
6477 01346 89 48 10 mov DWORD PTR [eax+16], ecx
\r
6478 01349 89 50 04 mov DWORD PTR [eax+4], edx
\r
6480 ; 1236 : if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
\r
6481 ; 1237 : (state->mode < CHECK || flush != Z_FINISH)))
\r
6483 0134c 83 7f 28 00 cmp DWORD PTR [edi+40], 0
\r
6484 01350 89 5f 38 mov DWORD PTR [edi+56], ebx
\r
6485 01353 89 77 3c mov DWORD PTR [edi+60], esi
\r
6486 01356 75 1a jne SHORT $LN6@inflate
\r
6487 01358 8b 4d e0 mov ecx, DWORD PTR _out$[ebp]
\r
6488 0135b 3b 48 10 cmp ecx, DWORD PTR [eax+16]
\r
6489 0135e 74 35 je SHORT $LN704@inflate
\r
6490 01360 8b 07 mov eax, DWORD PTR [edi]
\r
6491 01362 83 f8 1d cmp eax, 29 ; 0000001dH
\r
6492 01365 7d 2e jge SHORT $LN704@inflate
\r
6493 01367 83 f8 1a cmp eax, 26 ; 0000001aH
\r
6494 0136a 7c 06 jl SHORT $LN6@inflate
\r
6495 0136c 83 7d 0c 04 cmp DWORD PTR _flush$[ebp], 4
\r
6496 01370 74 23 je SHORT $LN704@inflate
\r
6499 ; 1238 : if (updatewindow(strm, out)) {
\r
6501 01372 8b 45 e0 mov eax, DWORD PTR _out$[ebp]
\r
6502 01375 8b 5d 08 mov ebx, DWORD PTR _strm$[ebp]
\r
6503 01378 e8 00 00 00 00 call _updatewindow
\r
6504 0137d 85 c0 test eax, eax
\r
6505 0137f 74 14 je SHORT $LN704@inflate
\r
6507 ; 1239 : state->mode = MEM;
\r
6509 01381 c7 07 1e 00 00
\r
6510 00 mov DWORD PTR [edi], 30 ; 0000001eH
\r
6515 ; 1240 : return Z_MEM_ERROR;
\r
6517 01389 b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
6520 ; 1255 : return ret;
\r
6523 0138f 8b e5 mov esp, ebp
\r
6525 01392 c2 08 00 ret 8
\r
6529 ; 1242 : in -= strm->avail_in;
\r
6531 01395 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
6532 01398 8b 45 d0 mov eax, DWORD PTR _in$[ebp]
\r
6533 0139b 2b 46 04 sub eax, DWORD PTR [esi+4]
\r
6535 ; 1243 : out -= strm->avail_out;
\r
6537 0139e 8b 5d e0 mov ebx, DWORD PTR _out$[ebp]
\r
6538 013a1 2b 5e 10 sub ebx, DWORD PTR [esi+16]
\r
6540 ; 1244 : strm->total_in += in;
\r
6542 013a4 01 46 08 add DWORD PTR [esi+8], eax
\r
6544 ; 1245 : strm->total_out += out;
\r
6546 013a7 01 5e 14 add DWORD PTR [esi+20], ebx
\r
6548 ; 1246 : state->total += out;
\r
6550 013aa 01 5f 1c add DWORD PTR [edi+28], ebx
\r
6552 ; 1247 : if (state->wrap && out)
\r
6554 013ad 83 7f 08 00 cmp DWORD PTR [edi+8], 0
\r
6555 013b1 89 45 d0 mov DWORD PTR _in$[ebp], eax
\r
6556 013b4 74 31 je SHORT $LN4@inflate
\r
6557 013b6 85 db test ebx, ebx
\r
6558 013b8 74 2d je SHORT $LN4@inflate
\r
6560 ; 1248 : strm->adler = state->check =
\r
6561 ; 1249 : UPDATE(state->check, strm->next_out - out, out);
\r
6563 013ba 83 7f 10 00 cmp DWORD PTR [edi+16], 0
\r
6565 013bf 74 11 je SHORT $LN508@inflate
\r
6566 013c1 8b 56 0c mov edx, DWORD PTR [esi+12]
\r
6567 013c4 8b 47 18 mov eax, DWORD PTR [edi+24]
\r
6568 013c7 2b d3 sub edx, ebx
\r
6571 013cb e8 00 00 00 00 call _crc32@12
\r
6572 013d0 eb 0f jmp SHORT $LN509@inflate
\r
6574 013d2 8b 4e 0c mov ecx, DWORD PTR [esi+12]
\r
6575 013d5 8b 57 18 mov edx, DWORD PTR [edi+24]
\r
6576 013d8 2b cb sub ecx, ebx
\r
6579 013dc e8 00 00 00 00 call _adler32@12
\r
6581 013e1 89 47 18 mov DWORD PTR [edi+24], eax
\r
6582 013e4 89 46 30 mov DWORD PTR [esi+48], eax
\r
6585 ; 1250 : strm->data_type = state->bits + (state->last ? 64 : 0) +
\r
6586 ; 1251 : (state->mode == TYPE ? 128 : 0) +
\r
6587 ; 1252 : (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
\r
6589 013e7 8b 07 mov eax, DWORD PTR [edi]
\r
6590 013e9 83 f8 13 cmp eax, 19 ; 00000013H
\r
6591 013ec 74 0c je SHORT $LN510@inflate
\r
6592 013ee c7 45 08 00 00
\r
6593 00 00 mov DWORD PTR tv1321[ebp], 0
\r
6594 013f5 83 f8 0e cmp eax, 14 ; 0000000eH
\r
6595 013f8 75 07 jne SHORT $LN511@inflate
\r
6597 013fa c7 45 08 00 01
\r
6598 00 00 mov DWORD PTR tv1321[ebp], 256 ; 00000100H
\r
6600 01401 8b 4f 04 mov ecx, DWORD PTR [edi+4]
\r
6601 01404 f7 d9 neg ecx
\r
6602 01406 1b c9 sbb ecx, ecx
\r
6603 01408 33 d2 xor edx, edx
\r
6604 0140a 83 e1 40 and ecx, 64 ; 00000040H
\r
6605 0140d 83 f8 0b cmp eax, 11 ; 0000000bH
\r
6606 01410 0f 95 c2 setne dl
\r
6607 01413 03 4d 08 add ecx, DWORD PTR tv1321[ebp]
\r
6609 01417 81 e2 80 00 00
\r
6610 00 and edx, 128 ; 00000080H
\r
6611 0141d 03 d1 add edx, ecx
\r
6612 0141f 03 57 3c add edx, DWORD PTR [edi+60]
\r
6614 ; 1253 : if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
\r
6616 01422 83 7d d0 00 cmp DWORD PTR _in$[ebp], 0
\r
6617 01426 89 56 2c mov DWORD PTR [esi+44], edx
\r
6618 01429 75 04 jne SHORT $LN1@inflate
\r
6619 0142b 85 db test ebx, ebx
\r
6620 0142d 74 06 je SHORT $LN2@inflate
\r
6622 0142f 83 7d 0c 04 cmp DWORD PTR _flush$[ebp], 4
\r
6623 01433 75 19 jne SHORT $LN705@inflate
\r
6625 01435 8b 45 d8 mov eax, DWORD PTR _ret$[ebp]
\r
6626 01438 85 c0 test eax, eax
\r
6627 0143a 0f 85 a7 fe ff
\r
6628 ff jne $LN780@inflate
\r
6630 ; 1254 : ret = Z_BUF_ERROR;
\r
6634 01442 b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
6637 ; 1255 : return ret;
\r
6640 01448 8b e5 mov esp, ebp
\r
6642 0144b c2 08 00 ret 8
\r
6645 ; 1254 : ret = Z_BUF_ERROR;
\r
6647 0144e 8b 45 d8 mov eax, DWORD PTR _ret$[ebp]
\r
6652 ; 1255 : return ret;
\r
6655 01454 8b e5 mov esp, ebp
\r
6657 01457 c2 08 00 ret 8
\r
6660 ; 634 : return Z_STREAM_ERROR;
\r
6662 0145a b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6665 ; 1255 : return ret;
\r
6668 01460 8b e5 mov esp, ebp
\r
6670 01463 c2 08 00 ret 8
\r
6671 01466 8b ff npad 2
\r
6673 01468 00 00 00 00 DD $LN489@inflate
\r
6674 0146c 00 00 00 00 DD $LN457@inflate
\r
6675 01470 00 00 00 00 DD $LN437@inflate
\r
6676 01474 00 00 00 00 DD $LN419@inflate
\r
6677 01478 00 00 00 00 DD $LN713@inflate
\r
6678 0147c 00 00 00 00 DD $LN715@inflate
\r
6679 01480 00 00 00 00 DD $LN716@inflate
\r
6680 01484 00 00 00 00 DD $LN720@inflate
\r
6681 01488 00 00 00 00 DD $LN724@inflate
\r
6682 0148c 00 00 00 00 DD $LN333@inflate
\r
6683 01490 00 00 00 00 DD $LN726@inflate
\r
6684 01494 00 00 00 00 DD $LN316@inflate
\r
6685 01498 00 00 00 00 DD $LN315@inflate
\r
6686 0149c 00 00 00 00 DD $LN282@inflate
\r
6687 014a0 00 00 00 00 DD $LN266@inflate
\r
6688 014a4 00 00 00 00 DD $LN264@inflate
\r
6689 014a8 00 00 00 00 DD $LN258@inflate
\r
6690 014ac 00 00 00 00 DD $LN730@inflate
\r
6691 014b0 00 00 00 00 DD $LN528@inflate
\r
6692 014b4 00 00 00 00 DD $LN148@inflate
\r
6693 014b8 00 00 00 00 DD $LN146@inflate
\r
6694 014bc 00 00 00 00 DD $LN699@inflate
\r
6695 014c0 00 00 00 00 DD $LN700@inflate
\r
6696 014c4 00 00 00 00 DD $LN701@inflate
\r
6697 014c8 00 00 00 00 DD $LN702@inflate
\r
6698 014cc 00 00 00 00 DD $LN48@inflate
\r
6699 014d0 00 00 00 00 DD $LN46@inflate
\r
6700 014d4 00 00 00 00 DD $LN742@inflate
\r
6701 014d8 00 00 00 00 DD $LN747@inflate
\r
6702 014dc 00 00 00 00 DD $LN14@inflate
\r
6703 014e0 00 00 00 00 DD $LN13@inflate
\r
6705 014e4 00 00 00 00 DD $LN294@inflate
\r
6706 014e8 00 00 00 00 DD $LN293@inflate
\r
6707 014ec 00 00 00 00 DD $LN288@inflate
\r
6708 014f0 00 00 00 00 DD $LN287@inflate
\r
6711 PUBLIC _inflateReset@4
\r
6712 ; Function compile flags: /Ogtp
\r
6713 ; COMDAT _inflateReset@4
\r
6715 _strm$ = 8 ; size = 4
\r
6716 _inflateReset@4 PROC ; COMDAT
\r
6721 00001 8b ec mov ebp, esp
\r
6723 ; 131 : struct inflate_state FAR *state;
\r
6725 ; 133 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6727 00003 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6728 00006 33 d2 xor edx, edx
\r
6729 00008 3b ca cmp ecx, edx
\r
6730 0000a 74 1a je SHORT $LN1@inflateRes@2
\r
6731 0000c 8b 41 1c mov eax, DWORD PTR [ecx+28]
\r
6732 0000f 3b c2 cmp eax, edx
\r
6733 00011 74 13 je SHORT $LN1@inflateRes@2
\r
6735 ; 134 : state = (struct inflate_state FAR *)strm->state;
\r
6736 ; 135 : state->wsize = 0;
\r
6737 ; 136 : state->whave = 0;
\r
6738 ; 137 : state->wnext = 0;
\r
6739 ; 138 : return inflateResetKeep(strm);
\r
6742 00014 89 50 28 mov DWORD PTR [eax+40], edx
\r
6743 00017 89 50 2c mov DWORD PTR [eax+44], edx
\r
6744 0001a 89 50 30 mov DWORD PTR [eax+48], edx
\r
6745 0001d e8 00 00 00 00 call _inflateResetKeep@4
\r
6750 00023 c2 04 00 ret 4
\r
6751 $LN1@inflateRes@2:
\r
6753 ; 131 : struct inflate_state FAR *state;
\r
6755 ; 133 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6757 00026 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6762 0002c c2 04 00 ret 4
\r
6763 _inflateReset@4 ENDP
\r
6764 PUBLIC _inflateSync@4
\r
6765 ; Function compile flags: /Ogtp
\r
6766 ; COMDAT _inflateSync@4
\r
6768 _out$ = 8 ; size = 4
\r
6769 _buf$ = 8 ; size = 4
\r
6770 _strm$ = 8 ; size = 4
\r
6771 _inflateSync@4 PROC ; COMDAT
\r
6776 00001 8b ec mov ebp, esp
\r
6779 ; 1369 : unsigned len; /* number of bytes to look at or looked at */
\r
6780 ; 1370 : unsigned long in, out; /* temporary to save total_in and total_out */
\r
6781 ; 1371 : unsigned char buf[4]; /* to restore bit buffer to byte string */
\r
6782 ; 1372 : struct inflate_state FAR *state;
\r
6784 ; 1374 : /* check parameters */
\r
6785 ; 1375 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6787 00004 8b 5d 08 mov ebx, DWORD PTR _strm$[ebp]
\r
6789 00008 85 db test ebx, ebx
\r
6790 0000a 0f 84 d2 00 00
\r
6791 00 je $LN6@inflateSyn@2
\r
6792 00010 8b 7b 1c mov edi, DWORD PTR [ebx+28]
\r
6793 00013 85 ff test edi, edi
\r
6794 00015 0f 84 c7 00 00
\r
6795 00 je $LN6@inflateSyn@2
\r
6797 ; 1376 : state = (struct inflate_state FAR *)strm->state;
\r
6798 ; 1377 : if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
\r
6800 0001b 83 7b 04 00 cmp DWORD PTR [ebx+4], 0
\r
6801 0001f 75 11 jne SHORT $LN5@inflateSyn@2
\r
6802 00021 83 7f 3c 08 cmp DWORD PTR [edi+60], 8
\r
6803 00025 73 0b jae SHORT $LN5@inflateSyn@2
\r
6805 00028 b8 fb ff ff ff mov eax, -5 ; fffffffbH
\r
6811 0002f c2 04 00 ret 4
\r
6812 $LN5@inflateSyn@2:
\r
6815 ; 1379 : /* if first time, start search in bit buffer */
\r
6816 ; 1380 : if (state->mode != SYNC) {
\r
6818 00032 83 3f 1f cmp DWORD PTR [edi], 31 ; 0000001fH
\r
6820 00036 74 57 je SHORT $LN4@inflateSyn@2
\r
6822 ; 1381 : state->mode = SYNC;
\r
6823 ; 1382 : state->hold <<= state->bits & 7;
\r
6825 00038 8b 47 3c mov eax, DWORD PTR [edi+60]
\r
6826 0003b 8b c8 mov ecx, eax
\r
6827 0003d 83 e1 07 and ecx, 7
\r
6828 00040 d3 67 38 shl DWORD PTR [edi+56], cl
\r
6830 ; 1383 : state->bits -= state->bits & 7;
\r
6832 00043 2b c1 sub eax, ecx
\r
6836 00045 33 c9 xor ecx, ecx
\r
6837 00047 c7 07 1f 00 00
\r
6838 00 mov DWORD PTR [edi], 31 ; 0000001fH
\r
6839 0004d 89 47 3c mov DWORD PTR [edi+60], eax
\r
6841 ; 1385 : while (state->bits >= 8) {
\r
6843 00050 83 f8 08 cmp eax, 8
\r
6844 00053 72 24 jb SHORT $LN2@inflateSyn@2
\r
6845 00055 8b 77 38 mov esi, DWORD PTR [edi+56]
\r
6846 00058 eb 06 8d 9b 00
\r
6848 $LL3@inflateSyn@2:
\r
6850 ; 1386 : buf[len++] = (unsigned char)(state->hold);
\r
6852 00060 8a 57 38 mov dl, BYTE PTR [edi+56]
\r
6854 ; 1387 : state->hold >>= 8;
\r
6855 ; 1388 : state->bits -= 8;
\r
6857 00063 83 e8 08 sub eax, 8
\r
6858 00066 88 54 0d 08 mov BYTE PTR _buf$[ebp+ecx], dl
\r
6859 0006a c1 ee 08 shr esi, 8
\r
6861 0006e 89 77 38 mov DWORD PTR [edi+56], esi
\r
6862 00071 89 47 3c mov DWORD PTR [edi+60], eax
\r
6863 00074 83 f8 08 cmp eax, 8
\r
6864 00077 73 e7 jae SHORT $LL3@inflateSyn@2
\r
6865 $LN2@inflateSyn@2:
\r
6868 ; 1390 : state->have = 0;
\r
6870 00079 8d 47 68 lea eax, DWORD PTR [edi+104]
\r
6872 ; 1391 : syncsearch(&(state->have), buf, len);
\r
6876 0007e 8d 75 08 lea esi, DWORD PTR _buf$[ebp]
\r
6877 00081 c7 00 00 00 00
\r
6878 00 mov DWORD PTR [eax], 0
\r
6879 00087 e8 00 00 00 00 call _syncsearch
\r
6880 0008c 83 c4 08 add esp, 8
\r
6881 $LN4@inflateSyn@2:
\r
6885 ; 1394 : /* search available input */
\r
6886 ; 1395 : len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
\r
6888 0008f 8b 4b 04 mov ecx, DWORD PTR [ebx+4]
\r
6889 00092 8b 33 mov esi, DWORD PTR [ebx]
\r
6890 00094 8d 47 68 lea eax, DWORD PTR [edi+104]
\r
6893 00099 e8 00 00 00 00 call _syncsearch
\r
6895 ; 1396 : strm->avail_in -= len;
\r
6896 ; 1397 : strm->next_in += len;
\r
6897 ; 1398 : strm->total_in += len;
\r
6899 0009e 01 43 08 add DWORD PTR [ebx+8], eax
\r
6900 000a1 29 43 04 sub DWORD PTR [ebx+4], eax
\r
6901 000a4 01 03 add DWORD PTR [ebx], eax
\r
6902 000a6 8b 73 08 mov esi, DWORD PTR [ebx+8]
\r
6903 000a9 83 c4 08 add esp, 8
\r
6906 ; 1400 : /* return no joy or set up to restart inflate() on a new block */
\r
6907 ; 1401 : if (state->have != 4) return Z_DATA_ERROR;
\r
6909 000ac 83 7f 68 04 cmp DWORD PTR [edi+104], 4
\r
6910 000b0 74 0c je SHORT $LN1@inflateSyn@2
\r
6913 000b4 b8 fd ff ff ff mov eax, -3 ; fffffffdH
\r
6919 000bb c2 04 00 ret 4
\r
6920 $LN1@inflateSyn@2:
\r
6922 ; 1402 : in = strm->total_in; out = strm->total_out;
\r
6924 000be 8b 53 14 mov edx, DWORD PTR [ebx+20]
\r
6926 ; 1403 : inflateReset(strm);
\r
6929 000c2 89 55 08 mov DWORD PTR _out$[ebp], edx
\r
6930 000c5 e8 00 00 00 00 call _inflateReset@4
\r
6932 ; 1404 : strm->total_in = in; strm->total_out = out;
\r
6934 000ca 8b 45 08 mov eax, DWORD PTR _out$[ebp]
\r
6935 000cd 89 73 08 mov DWORD PTR [ebx+8], esi
\r
6936 000d0 89 43 14 mov DWORD PTR [ebx+20], eax
\r
6939 ; 1405 : state->mode = TYPE;
\r
6941 000d4 c7 07 0b 00 00
\r
6942 00 mov DWORD PTR [edi], 11 ; 0000000bH
\r
6945 ; 1406 : return Z_OK;
\r
6947 000db 33 c0 xor eax, eax
\r
6953 000df c2 04 00 ret 4
\r
6954 $LN6@inflateSyn@2:
\r
6957 ; 1369 : unsigned len; /* number of bytes to look at or looked at */
\r
6958 ; 1370 : unsigned long in, out; /* temporary to save total_in and total_out */
\r
6959 ; 1371 : unsigned char buf[4]; /* to restore bit buffer to byte string */
\r
6960 ; 1372 : struct inflate_state FAR *state;
\r
6962 ; 1374 : /* check parameters */
\r
6963 ; 1375 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6965 000e3 b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
6971 000ea c2 04 00 ret 4
\r
6972 _inflateSync@4 ENDP
\r
6974 PUBLIC _inflateReset2@8
\r
6975 ; Function compile flags: /Ogtp
\r
6976 ; COMDAT _inflateReset2@8
\r
6978 _strm$ = 8 ; size = 4
\r
6979 _windowBits$ = 12 ; size = 4
\r
6980 _inflateReset2@8 PROC ; COMDAT
\r
6985 00001 8b ec mov ebp, esp
\r
6988 ; 146 : struct inflate_state FAR *state;
\r
6990 ; 148 : /* get the state */
\r
6991 ; 149 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
6993 00003 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
6995 00007 85 c9 test ecx, ecx
\r
6996 00009 74 74 je SHORT $LN7@inflateRes@3
\r
6997 0000b 8b 79 1c mov edi, DWORD PTR [ecx+28]
\r
6998 0000e 85 ff test edi, edi
\r
6999 00010 74 6d je SHORT $LN7@inflateRes@3
\r
7001 ; 150 : state = (struct inflate_state FAR *)strm->state;
\r
7003 ; 152 : /* extract wrap request from windowBits parameter */
\r
7004 ; 153 : if (windowBits < 0) {
\r
7008 00014 8b 75 0c mov esi, DWORD PTR _windowBits$[ebp]
\r
7009 00017 85 f6 test esi, esi
\r
7010 00019 79 06 jns SHORT $LN6@inflateRes@3
\r
7014 0001b 33 db xor ebx, ebx
\r
7016 ; 155 : windowBits = -windowBits;
\r
7018 0001d f7 de neg esi
\r
7023 0001f eb 0e jmp SHORT $LN4@inflateRes@3
\r
7024 $LN6@inflateRes@3:
\r
7026 ; 158 : wrap = (windowBits >> 4) + 1;
\r
7028 00021 8b de mov ebx, esi
\r
7029 00023 c1 fb 04 sar ebx, 4
\r
7032 ; 159 : #ifdef GUNZIP
\r
7033 ; 160 : if (windowBits < 48)
\r
7035 00027 83 fe 30 cmp esi, 48 ; 00000030H
\r
7036 0002a 7d 03 jge SHORT $LN4@inflateRes@3
\r
7038 ; 161 : windowBits &= 15;
\r
7040 0002c 83 e6 0f and esi, 15 ; 0000000fH
\r
7041 $LN4@inflateRes@3:
\r
7046 ; 165 : /* set number of window bits, free window if different */
\r
7047 ; 166 : if (windowBits && (windowBits < 8 || windowBits > 15))
\r
7049 0002f 85 f6 test esi, esi
\r
7050 00031 74 16 je SHORT $LN3@inflateRes@3
\r
7051 00033 83 fe 08 cmp esi, 8
\r
7052 00036 7c 05 jl SHORT $LN2@inflateRes@3
\r
7053 00038 83 fe 0f cmp esi, 15 ; 0000000fH
\r
7054 0003b 7e 0c jle SHORT $LN3@inflateRes@3
\r
7055 $LN2@inflateRes@3:
\r
7059 ; 167 : return Z_STREAM_ERROR;
\r
7061 0003f b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
7067 00046 c2 08 00 ret 8
\r
7068 $LN3@inflateRes@3:
\r
7070 ; 168 : if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
\r
7072 00049 8b 47 34 mov eax, DWORD PTR [edi+52]
\r
7073 0004c 85 c0 test eax, eax
\r
7074 0004e 74 1c je SHORT $LN1@inflateRes@3
\r
7075 00050 39 77 24 cmp DWORD PTR [edi+36], esi
\r
7076 00053 74 17 je SHORT $LN1@inflateRes@3
\r
7078 ; 169 : ZFREE(strm, state->window);
\r
7081 00056 8b 41 28 mov eax, DWORD PTR [ecx+40]
\r
7082 00059 8b 49 24 mov ecx, DWORD PTR [ecx+36]
\r
7084 0005d ff d1 call ecx
\r
7086 ; 170 : state->window = Z_NULL;
\r
7088 0005f 8b 4d 08 mov ecx, DWORD PTR _strm$[ebp]
\r
7089 00062 83 c4 08 add esp, 8
\r
7090 00065 c7 47 34 00 00
\r
7091 00 00 mov DWORD PTR [edi+52], 0
\r
7092 $LN1@inflateRes@3:
\r
7096 ; 173 : /* update state and reset the rest of it */
\r
7097 ; 174 : state->wrap = wrap;
\r
7098 ; 175 : state->wbits = (unsigned)windowBits;
\r
7099 ; 176 : return inflateReset(strm);
\r
7102 0006d 89 5f 08 mov DWORD PTR [edi+8], ebx
\r
7103 00070 89 77 24 mov DWORD PTR [edi+36], esi
\r
7104 00073 e8 00 00 00 00 call _inflateReset@4
\r
7112 0007c c2 08 00 ret 8
\r
7113 $LN7@inflateRes@3:
\r
7116 ; 146 : struct inflate_state FAR *state;
\r
7118 ; 148 : /* get the state */
\r
7119 ; 149 : if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
\r
7121 0007f b8 fe ff ff ff mov eax, -2 ; fffffffeH
\r
7127 00086 c2 08 00 ret 8
\r
7128 _inflateReset2@8 ENDP
\r
7129 PUBLIC _inflateInit2_@16
\r
7130 ; Function compile flags: /Ogtp
\r
7131 ; COMDAT _inflateInit2_@16
\r
7133 _strm$ = 8 ; size = 4
\r
7134 _windowBits$ = 12 ; size = 4
\r
7135 _version$ = 16 ; size = 4
\r
7136 _stream_size$ = 20 ; size = 4
\r
7137 _inflateInit2_@16 PROC ; COMDAT
\r
7142 00001 8b ec mov ebp, esp
\r
7145 ; 186 : struct inflate_state FAR *state;
\r
7147 ; 188 : if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
\r
7148 ; 189 : stream_size != (int)(sizeof(z_stream)))
\r
7150 00003 8b 45 10 mov eax, DWORD PTR _version$[ebp]
\r
7152 00007 33 db xor ebx, ebx
\r
7153 00009 3b c3 cmp eax, ebx
\r
7154 0000b 0f 84 9b 00 00
\r
7155 00 je $LN6@inflateIni
\r
7156 00011 80 38 31 cmp BYTE PTR [eax], 49 ; 00000031H
\r
7157 00014 0f 85 92 00 00
\r
7158 00 jne $LN6@inflateIni
\r
7159 0001a 83 7d 14 38 cmp DWORD PTR _stream_size$[ebp], 56 ; 00000038H
\r
7160 0001e 0f 85 88 00 00
\r
7161 00 jne $LN6@inflateIni
\r
7163 ; 191 : if (strm == Z_NULL) return Z_STREAM_ERROR;
\r
7166 00025 8b 75 08 mov esi, DWORD PTR _strm$[ebp]
\r
7167 00028 3b f3 cmp esi, ebx
\r
7168 0002a 75 09 jne SHORT $LN5@inflateIni
\r
7170 0002d 8d 43 fe lea eax, DWORD PTR [ebx-2]
\r
7176 00032 c2 10 00 ret 16 ; 00000010H
\r
7179 ; 192 : strm->msg = Z_NULL; /* in case we return an error */
\r
7181 00035 89 5e 18 mov DWORD PTR [esi+24], ebx
\r
7183 ; 193 : if (strm->zalloc == (alloc_func)0) {
\r
7185 00038 39 5e 20 cmp DWORD PTR [esi+32], ebx
\r
7186 0003b 75 0a jne SHORT $LN4@inflateIni
\r
7188 ; 194 : #ifdef Z_SOLO
\r
7189 ; 195 : return Z_STREAM_ERROR;
\r
7191 ; 197 : strm->zalloc = zcalloc;
\r
7193 0003d c7 46 20 00 00
\r
7194 00 00 mov DWORD PTR [esi+32], OFFSET _zcalloc
\r
7196 ; 198 : strm->opaque = (voidpf)0;
\r
7198 00044 89 5e 28 mov DWORD PTR [esi+40], ebx
\r
7203 ; 201 : if (strm->zfree == (free_func)0)
\r
7205 00047 39 5e 24 cmp DWORD PTR [esi+36], ebx
\r
7206 0004a 75 07 jne SHORT $LN3@inflateIni
\r
7208 ; 202 : #ifdef Z_SOLO
\r
7209 ; 203 : return Z_STREAM_ERROR;
\r
7211 ; 205 : strm->zfree = zcfree;
\r
7213 0004c c7 46 24 00 00
\r
7214 00 00 mov DWORD PTR [esi+36], OFFSET _zcfree
\r
7218 ; 207 : state = (struct inflate_state FAR *)
\r
7219 ; 208 : ZALLOC(strm, 1, sizeof(struct inflate_state));
\r
7221 00053 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
7222 00056 8b 4e 20 mov ecx, DWORD PTR [esi+32]
\r
7224 0005a 68 cc 1b 00 00 push 7116 ; 00001bccH
\r
7225 0005f 6a 01 push 1
\r
7227 00062 ff d1 call ecx
\r
7228 00064 8b f8 mov edi, eax
\r
7229 00066 83 c4 0c add esp, 12 ; 0000000cH
\r
7231 ; 209 : if (state == Z_NULL) return Z_MEM_ERROR;
\r
7233 00069 3b fb cmp edi, ebx
\r
7234 0006b 75 0c jne SHORT $LN2@inflateIni
\r
7237 0006f b8 fc ff ff ff mov eax, -4 ; fffffffcH
\r
7243 00076 c2 10 00 ret 16 ; 00000010H
\r
7246 ; 210 : Tracev((stderr, "inflate: allocated\n"));
\r
7247 ; 211 : strm->state = (struct internal_state FAR *)state;
\r
7248 ; 212 : state->window = Z_NULL;
\r
7249 ; 213 : ret = inflateReset2(strm, windowBits);
\r
7251 00079 8b 55 0c mov edx, DWORD PTR _windowBits$[ebp]
\r
7253 0007d 89 7e 1c mov DWORD PTR [esi+28], edi
\r
7255 00081 89 5f 34 mov DWORD PTR [edi+52], ebx
\r
7256 00084 e8 00 00 00 00 call _inflateReset2@8
\r
7257 00089 8b d8 mov ebx, eax
\r
7259 ; 214 : if (ret != Z_OK) {
\r
7261 0008b 85 db test ebx, ebx
\r
7262 0008d 74 14 je SHORT $LN1@inflateIni
\r
7264 ; 215 : ZFREE(strm, state);
\r
7266 0008f 8b 46 28 mov eax, DWORD PTR [esi+40]
\r
7267 00092 8b 4e 24 mov ecx, DWORD PTR [esi+36]
\r
7270 00097 ff d1 call ecx
\r
7271 00099 83 c4 08 add esp, 8
\r
7273 ; 216 : strm->state = Z_NULL;
\r
7275 0009c c7 46 1c 00 00
\r
7276 00 00 mov DWORD PTR [esi+28], 0
\r
7280 ; 218 : return ret;
\r
7284 000a5 8b c3 mov eax, ebx
\r
7290 000a9 c2 10 00 ret 16 ; 00000010H
\r
7293 ; 190 : return Z_VERSION_ERROR;
\r
7295 000ac b8 fa ff ff ff mov eax, -6 ; fffffffaH
\r
7301 000b3 c2 10 00 ret 16 ; 00000010H
\r
7302 _inflateInit2_@16 ENDP
\r
7303 PUBLIC _inflateInit_@12
\r
7304 ; Function compile flags: /Ogtp
\r
7305 ; COMDAT _inflateInit_@12
\r
7307 _strm$ = 8 ; size = 4
\r
7308 _version$ = 12 ; size = 4
\r
7309 _stream_size$ = 16 ; size = 4
\r
7310 _inflateInit_@12 PROC ; COMDAT
\r
7315 00001 8b ec mov ebp, esp
\r
7317 ; 226 : return inflateInit2_(strm, DEF_WBITS, version, stream_size);
\r
7319 00003 8b 45 10 mov eax, DWORD PTR _stream_size$[ebp]
\r
7320 00006 8b 4d 0c mov ecx, DWORD PTR _version$[ebp]
\r
7321 00009 8b 55 08 mov edx, DWORD PTR _strm$[ebp]
\r
7324 0000e 6a 0f push 15 ; 0000000fH
\r
7326 00011 e8 00 00 00 00 call _inflateInit2_@16
\r
7331 00017 c2 0c 00 ret 12 ; 0000000cH
\r
7332 _inflateInit_@12 ENDP
\r
Code Review / simantics / sysdyn.git / blob