1 ; Listing generated by Microsoft (R) Optimizing Compiler Version 16.00.30319.01
\r
3 TITLE C:\Workspaces\Sysdyn\org.simantics.fmu\FMUSolution\zlib-1.2.6\trees.c
\r
12 PUBLIC __length_code
\r
13 _static_l_desc DD FLAT:_static_ltree
\r
14 DD FLAT:_extra_lbits
\r
18 _static_d_desc DD FLAT:_static_dtree
\r
19 DD FLAT:_extra_dbits
\r
23 _static_bl_desc DD 00H
\r
24 DD FLAT:_extra_blbits
\r
109 _extra_blbits DD 00H
\r
129 _static_ltree DW 0cH
\r
705 _static_dtree DW 00H
\r
1277 __length_code DB 00H
\r
1533 _base_length DD 00H
\r
1593 ; Function compile flags: /Ogtp
\r
1594 ; File c:\workspaces\sysdyn\org.simantics.fmu\fmusolution\zlib-1.2.6\trees.c
\r
1595 ; COMDAT _bi_windup
\r
1597 _bi_windup PROC ; COMDAT
\r
1600 ; 1187 : if (s->bi_valid > 8) {
\r
1602 00000 8b 88 bc 16 00
\r
1603 00 mov ecx, DWORD PTR [eax+5820]
\r
1605 00007 83 f9 08 cmp ecx, 8
\r
1606 0000a 7e 22 jle SHORT $LN3@bi_windup
\r
1608 ; 1188 : put_short(s, s->bi_buf);
\r
1610 0000c 0f b6 98 b8 16
\r
1611 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
1612 00013 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
1613 00016 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
1614 00019 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1615 0001c ff 40 14 inc DWORD PTR [eax+20]
\r
1616 0001f 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
1617 00022 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
1618 00025 0f b6 98 b9 16
\r
1619 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
1620 0002c eb 10 jmp SHORT $LN6@bi_windup
\r
1623 ; 1189 : } else if (s->bi_valid > 0) {
\r
1625 0002e 85 c9 test ecx, ecx
\r
1626 00030 7e 12 jle SHORT $LN1@bi_windup
\r
1628 ; 1190 : put_byte(s, (Byte)s->bi_buf);
\r
1630 00032 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
1631 00035 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
1632 00038 8a 98 b8 16 00
\r
1633 00 mov bl, BYTE PTR [eax+5816]
\r
1635 0003e 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1636 00041 ff 40 14 inc DWORD PTR [eax+20]
\r
1640 ; 1192 : s->bi_buf = 0;
\r
1642 00044 33 c9 xor ecx, ecx
\r
1643 00046 66 89 88 b8 16
\r
1644 00 00 mov WORD PTR [eax+5816], cx
\r
1646 ; 1193 : s->bi_valid = 0;
\r
1648 0004d 89 88 bc 16 00
\r
1649 00 mov DWORD PTR [eax+5820], ecx
\r
1652 ; 1194 : #ifdef DEBUG
\r
1653 ; 1195 : s->bits_sent = (s->bits_sent+7) & ~7;
\r
1659 ; Function compile flags: /Ogtp
\r
1661 ; COMDAT _bi_flush
\r
1663 _bi_flush PROC ; COMDAT
\r
1666 ; 1170 : if (s->bi_valid == 16) {
\r
1668 00000 8b 88 bc 16 00
\r
1669 00 mov ecx, DWORD PTR [eax+5820]
\r
1671 00007 83 f9 10 cmp ecx, 16 ; 00000010H
\r
1672 0000a 75 37 jne SHORT $LN3@bi_flush
\r
1674 ; 1171 : put_short(s, s->bi_buf);
\r
1676 0000c 0f b6 98 b8 16
\r
1677 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
1678 00013 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
1679 00016 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
1680 00019 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1681 0001c ff 40 14 inc DWORD PTR [eax+20]
\r
1682 0001f 0f b6 98 b9 16
\r
1683 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
1684 00026 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
1685 00029 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
1686 0002c 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1687 0002f ff 40 14 inc DWORD PTR [eax+20]
\r
1689 ; 1172 : s->bi_buf = 0;
\r
1691 00032 33 c9 xor ecx, ecx
\r
1692 00034 66 89 88 b8 16
\r
1693 00 00 mov WORD PTR [eax+5816], cx
\r
1695 ; 1173 : s->bi_valid = 0;
\r
1697 0003b 89 88 bc 16 00
\r
1698 00 mov DWORD PTR [eax+5820], ecx
\r
1707 ; 1174 : } else if (s->bi_valid >= 8) {
\r
1709 00043 83 f9 08 cmp ecx, 8
\r
1710 00046 7c 27 jl SHORT $LN1@bi_flush
\r
1712 ; 1175 : put_byte(s, (Byte)s->bi_buf);
\r
1714 00048 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
1715 0004b 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
1716 0004e 8a 98 b8 16 00
\r
1717 00 mov bl, BYTE PTR [eax+5816]
\r
1718 00054 88 1c 0a mov BYTE PTR [edx+ecx], bl
\r
1720 ; 1176 : s->bi_buf >>= 8;
\r
1722 00057 0f b6 90 b9 16
\r
1723 00 00 movzx edx, BYTE PTR [eax+5817]
\r
1724 0005e ff 40 14 inc DWORD PTR [eax+20]
\r
1726 ; 1177 : s->bi_valid -= 8;
\r
1728 00061 83 80 bc 16 00
\r
1729 00 f8 add DWORD PTR [eax+5820], -8 ; fffffff8H
\r
1730 00068 66 89 90 b8 16
\r
1731 00 00 mov WORD PTR [eax+5816], dx
\r
1740 ; Function compile flags: /Ogtp
\r
1742 ; COMDAT _bi_reverse
\r
1744 _bi_reverse PROC ; COMDAT
\r
1748 ; 1156 : register unsigned res = 0;
\r
1750 00000 33 c0 xor eax, eax
\r
1755 ; 1158 : res |= code & 1;
\r
1757 00003 8b f1 mov esi, ecx
\r
1758 00005 83 e6 01 and esi, 1
\r
1759 00008 0b c6 or eax, esi
\r
1761 ; 1159 : code >>= 1, res <<= 1;
\r
1762 ; 1160 : } while (--len > 0);
\r
1765 0000b d1 e9 shr ecx, 1
\r
1766 0000d 03 c0 add eax, eax
\r
1767 0000f 85 d2 test edx, edx
\r
1768 00011 7f f0 jg SHORT $LL3@bi_reverse
\r
1770 ; 1161 : return res >> 1;
\r
1772 00013 d1 e8 shr eax, 1
\r
1779 ; Function compile flags: /Ogtp
\r
1781 ; COMDAT _detect_data_type
\r
1783 _detect_data_type PROC ; COMDAT
\r
1786 ; 1121 : /* black_mask is the bit mask of black-listed bytes
\r
1787 ; 1122 : * set bits 0..6, 14..25, and 28..31
\r
1788 ; 1123 : * 0xf3ffc07f = binary 11110011111111111100000001111111
\r
1790 ; 1125 : unsigned long black_mask = 0xf3ffc07fUL;
\r
1792 00000 ba 7f c0 ff f3 mov edx, -201342849 ; f3ffc07fH
\r
1796 ; 1128 : /* Check for non-textual ("black-listed") bytes. */
\r
1797 ; 1129 : for (n = 0; n <= 31; n++, black_mask >>= 1)
\r
1799 00005 33 c0 xor eax, eax
\r
1800 00007 8d 8e 94 00 00
\r
1801 00 lea ecx, DWORD PTR [esi+148]
\r
1802 0000d 8d 49 00 npad 3
\r
1805 ; 1130 : if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
\r
1807 00010 f6 c2 01 test dl, 1
\r
1808 00013 74 06 je SHORT $LN9@detect_dat
\r
1809 00015 66 83 39 00 cmp WORD PTR [ecx], 0
\r
1810 00019 75 46 jne SHORT $LN15@detect_dat
\r
1815 ; 1128 : /* Check for non-textual ("black-listed") bytes. */
\r
1816 ; 1129 : for (n = 0; n <= 31; n++, black_mask >>= 1)
\r
1819 0001c 83 c1 04 add ecx, 4
\r
1820 0001f d1 ea shr edx, 1
\r
1821 00021 83 f8 1f cmp eax, 31 ; 0000001fH
\r
1822 00024 7e ea jle SHORT $LL10@detect_dat
\r
1824 ; 1131 : return Z_BINARY;
\r
1826 ; 1133 : /* Check for textual ("white-listed") bytes. */
\r
1827 ; 1134 : if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
\r
1828 ; 1135 : || s->dyn_ltree[13].Freq != 0)
\r
1830 00026 66 83 be b8 00
\r
1831 00 00 00 cmp WORD PTR [esi+184], 0
\r
1832 0002e 75 34 jne SHORT $LN5@detect_dat
\r
1833 00030 66 83 be bc 00
\r
1834 00 00 00 cmp WORD PTR [esi+188], 0
\r
1835 00038 75 2a jne SHORT $LN5@detect_dat
\r
1836 0003a 66 83 be c8 00
\r
1837 00 00 00 cmp WORD PTR [esi+200], 0
\r
1838 00042 75 20 jne SHORT $LN5@detect_dat
\r
1840 ; 1137 : for (n = 32; n < LITERALS; n++)
\r
1842 00044 b8 20 00 00 00 mov eax, 32 ; 00000020H
\r
1843 00049 8d 8e 14 01 00
\r
1844 00 lea ecx, DWORD PTR [esi+276]
\r
1848 ; 1138 : if (s->dyn_ltree[n].Freq != 0)
\r
1850 00050 66 83 39 00 cmp WORD PTR [ecx], 0
\r
1851 00054 75 0e jne SHORT $LN5@detect_dat
\r
1853 ; 1137 : for (n = 32; n < LITERALS; n++)
\r
1856 00057 83 c1 04 add ecx, 4
\r
1857 0005a 3d 00 01 00 00 cmp eax, 256 ; 00000100H
\r
1858 0005f 7c ef jl SHORT $LL4@detect_dat
\r
1861 ; 1139 : return Z_TEXT;
\r
1863 ; 1141 : /* There are no "black-listed" or "white-listed" bytes:
\r
1864 ; 1142 : * this stream either is empty or has tolerated ("gray-listed") bytes only.
\r
1866 ; 1144 : return Z_BINARY;
\r
1868 00061 33 c0 xor eax, eax
\r
1875 ; 1136 : return Z_TEXT;
\r
1877 00064 b8 01 00 00 00 mov eax, 1
\r
1882 _detect_data_type ENDP
\r
1883 ; Function compile flags: /Ogtp
\r
1885 ; COMDAT _compress_block
\r
1887 _len$80874 = -16 ; size = 4
\r
1888 _extra$ = -16 ; size = 4
\r
1889 _val$80854 = -16 ; size = 4
\r
1890 _lx$ = -12 ; size = 4
\r
1891 _len$80851 = -8 ; size = 4
\r
1892 _dist$ = -4 ; size = 4
\r
1893 _ltree$ = 8 ; size = 4
\r
1894 _dtree$ = 12 ; size = 4
\r
1895 _compress_block PROC ; COMDAT
\r
1901 00001 8b ec mov ebp, esp
\r
1902 00003 83 ec 10 sub esp, 16 ; 00000010H
\r
1904 00007 8b 5d 08 mov ebx, DWORD PTR _ltree$[ebp]
\r
1906 ; 1063 : unsigned dist; /* distance of matched string */
\r
1907 ; 1064 : int lc; /* match length or unmatched char (if dist == 0) */
\r
1908 ; 1065 : unsigned lx = 0; /* running index in l_buf */
\r
1910 0000a 33 c9 xor ecx, ecx
\r
1914 ; 1066 : unsigned code; /* the code to send */
\r
1915 ; 1067 : int extra; /* number of extra bits to send */
\r
1917 ; 1069 : if (s->last_lit != 0) do {
\r
1919 0000e 39 88 a0 16 00
\r
1920 00 cmp DWORD PTR [eax+5792], ecx
\r
1921 00014 0f 84 bb 00 00
\r
1922 00 je $LN17@compress_b
\r
1923 0001a eb 07 jmp SHORT $LN19@compress_b
\r
1924 0001c 8d 64 24 00 npad 4
\r
1926 00020 8b 4d f4 mov ecx, DWORD PTR _lx$[ebp]
\r
1929 ; 1070 : dist = s->d_buf[lx];
\r
1931 00023 8b 90 a4 16 00
\r
1932 00 mov edx, DWORD PTR [eax+5796]
\r
1933 00029 0f b7 14 4a movzx edx, WORD PTR [edx+ecx*2]
\r
1935 ; 1071 : lc = s->l_buf[lx++];
\r
1937 0002d 8b b0 98 16 00
\r
1938 00 mov esi, DWORD PTR [eax+5784]
\r
1939 00033 0f b6 34 31 movzx esi, BYTE PTR [ecx+esi]
\r
1941 00038 89 4d f4 mov DWORD PTR _lx$[ebp], ecx
\r
1943 ; 1072 : if (dist == 0) {
\r
1944 ; 1073 : send_code(s, lc, ltree); /* send a literal byte */
\r
1946 0003b 8b 88 bc 16 00
\r
1947 00 mov ecx, DWORD PTR [eax+5820]
\r
1948 00041 89 55 fc mov DWORD PTR _dist$[ebp], edx
\r
1949 00044 85 d2 test edx, edx
\r
1950 00046 0f 85 04 01 00
\r
1951 00 jne $LN16@compress_b
\r
1952 0004c 0f b7 7c b3 02 movzx edi, WORD PTR [ebx+esi*4+2]
\r
1953 00051 ba 10 00 00 00 mov edx, 16 ; 00000010H
\r
1954 00056 2b d7 sub edx, edi
\r
1955 00058 3b ca cmp ecx, edx
\r
1956 0005a 7e 54 jle SHORT $LN15@compress_b
\r
1957 0005c 0f b7 34 b3 movzx esi, WORD PTR [ebx+esi*4]
\r
1958 00060 66 8b d6 mov dx, si
\r
1959 00063 66 d3 e2 shl dx, cl
\r
1960 00066 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
1961 00069 66 09 90 b8 16
\r
1962 00 00 or WORD PTR [eax+5816], dx
\r
1963 00070 0f b6 98 b8 16
\r
1964 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
1965 00077 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
1966 0007a 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1967 0007d ff 40 14 inc DWORD PTR [eax+20]
\r
1968 00080 0f b6 98 b9 16
\r
1969 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
1970 00087 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
1971 0008a 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
1972 0008d 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
1973 00090 8b 90 bc 16 00
\r
1974 00 mov edx, DWORD PTR [eax+5820]
\r
1975 00096 ff 40 14 inc DWORD PTR [eax+20]
\r
1976 00099 8b 5d 08 mov ebx, DWORD PTR _ltree$[ebp]
\r
1977 0009c b1 10 mov cl, 16 ; 00000010H
\r
1978 0009e 2a ca sub cl, dl
\r
1979 000a0 66 d3 ee shr si, cl
\r
1980 000a3 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
\r
1981 000a7 66 89 b0 b8 16
\r
1982 00 00 mov WORD PTR [eax+5816], si
\r
1983 000ae eb 10 jmp SHORT $LN28@compress_b
\r
1985 000b0 66 8b 14 b3 mov dx, WORD PTR [ebx+esi*4]
\r
1988 ; 1092 : send_bits(s, dist, extra); /* send the extra distance bits */
\r
1990 000b4 66 d3 e2 shl dx, cl
\r
1991 000b7 66 09 90 b8 16
\r
1992 00 00 or WORD PTR [eax+5816], dx
\r
1993 000be 03 cf add ecx, edi
\r
1995 000c0 89 88 bc 16 00
\r
1996 00 mov DWORD PTR [eax+5820], ecx
\r
2000 ; 1094 : } /* literal or match pair ? */
\r
2002 ; 1096 : /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
\r
2003 ; 1097 : Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
\r
2004 ; 1098 : "pendingBuf overflow");
\r
2006 ; 1100 : } while (lx < s->last_lit);
\r
2008 000c6 8b 4d f4 mov ecx, DWORD PTR _lx$[ebp]
\r
2009 000c9 3b 88 a0 16 00
\r
2010 00 cmp ecx, DWORD PTR [eax+5792]
\r
2011 000cf 0f 82 4b ff ff
\r
2012 ff jb $LL26@compress_b
\r
2016 ; 1102 : send_code(s, END_BLOCK, ltree);
\r
2018 000d5 0f b7 bb 02 04
\r
2019 00 00 movzx edi, WORD PTR [ebx+1026]
\r
2020 000dc 8b 88 bc 16 00
\r
2021 00 mov ecx, DWORD PTR [eax+5820]
\r
2022 000e2 ba 10 00 00 00 mov edx, 16 ; 00000010H
\r
2023 000e7 2b d7 sub edx, edi
\r
2024 000e9 3b ca cmp ecx, edx
\r
2025 000eb 0f 8e c3 02 00
\r
2026 00 jle $LN2@compress_b
\r
2027 000f1 0f b7 b3 00 04
\r
2028 00 00 movzx esi, WORD PTR [ebx+1024]
\r
2029 000f8 66 8b d6 mov dx, si
\r
2030 000fb 66 d3 e2 shl dx, cl
\r
2031 000fe 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2032 00101 66 09 90 b8 16
\r
2033 00 00 or WORD PTR [eax+5816], dx
\r
2034 00108 0f b6 98 b8 16
\r
2035 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2036 0010f 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2037 00112 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2038 00115 ff 40 14 inc DWORD PTR [eax+20]
\r
2039 00118 0f b6 98 b9 16
\r
2040 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2041 0011f 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2042 00122 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2043 00125 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2044 00128 8b 90 bc 16 00
\r
2045 00 mov edx, DWORD PTR [eax+5820]
\r
2046 0012e ff 40 14 inc DWORD PTR [eax+20]
\r
2047 00131 b1 10 mov cl, 16 ; 00000010H
\r
2048 00133 2a ca sub cl, dl
\r
2049 00135 66 d3 ee shr si, cl
\r
2050 00138 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
\r
2052 0013d 89 88 bc 16 00
\r
2053 00 mov DWORD PTR [eax+5820], ecx
\r
2054 00143 66 89 b0 b8 16
\r
2055 00 00 mov WORD PTR [eax+5816], si
\r
2061 0014c 8b e5 mov esp, ebp
\r
2066 ; 1074 : Tracecv(isgraph(lc), (stderr," '%c' ", lc));
\r
2068 ; 1076 : /* Here, lc is the match length - MIN_MATCH */
\r
2069 ; 1077 : code = _length_code[lc];
\r
2071 00150 0f b6 be 00 00
\r
2072 00 00 movzx edi, BYTE PTR __length_code[esi]
\r
2074 ; 1078 : send_code(s, code+LITERALS+1, ltree); /* send the length code */
\r
2076 00157 0f b7 94 bb 06
\r
2077 04 00 00 movzx edx, WORD PTR [ebx+edi*4+1030]
\r
2078 0015f bb 10 00 00 00 mov ebx, 16 ; 00000010H
\r
2079 00164 2b da sub ebx, edx
\r
2080 00166 89 55 f8 mov DWORD PTR _len$80851[ebp], edx
\r
2081 00169 8b 55 08 mov edx, DWORD PTR _ltree$[ebp]
\r
2082 0016c 3b cb cmp ecx, ebx
\r
2083 0016e 7e 61 jle SHORT $LN12@compress_b
\r
2084 00170 0f b7 94 ba 04
\r
2085 04 00 00 movzx edx, WORD PTR [edx+edi*4+1028]
\r
2086 00178 89 55 f0 mov DWORD PTR _val$80854[ebp], edx
\r
2087 0017b 66 d3 e2 shl dx, cl
\r
2088 0017e 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2089 00181 66 09 90 b8 16
\r
2090 00 00 or WORD PTR [eax+5816], dx
\r
2091 00188 0f b6 98 b8 16
\r
2092 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2093 0018f 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2094 00192 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2095 00195 ff 40 14 inc DWORD PTR [eax+20]
\r
2096 00198 0f b6 98 b9 16
\r
2097 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2098 0019f 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2099 001a2 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2100 001a5 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2101 001a8 8b 90 bc 16 00
\r
2102 00 mov edx, DWORD PTR [eax+5820]
\r
2103 001ae 8b 5d f0 mov ebx, DWORD PTR _val$80854[ebp]
\r
2104 001b1 ff 40 14 inc DWORD PTR [eax+20]
\r
2105 001b4 b1 10 mov cl, 16 ; 00000010H
\r
2106 001b6 2a ca sub cl, dl
\r
2107 001b8 66 d3 eb shr bx, cl
\r
2108 001bb 8b 4d f8 mov ecx, DWORD PTR _len$80851[ebp]
\r
2109 001be 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2110 001c2 89 90 bc 16 00
\r
2111 00 mov DWORD PTR [eax+5820], edx
\r
2112 001c8 66 89 98 b8 16
\r
2113 00 00 mov WORD PTR [eax+5816], bx
\r
2114 001cf eb 1b jmp SHORT $LN29@compress_b
\r
2116 001d1 66 8b 94 ba 04
\r
2117 04 00 00 mov dx, WORD PTR [edx+edi*4+1028]
\r
2118 001d9 66 d3 e2 shl dx, cl
\r
2119 001dc 66 09 90 b8 16
\r
2120 00 00 or WORD PTR [eax+5816], dx
\r
2121 001e3 03 4d f8 add ecx, DWORD PTR _len$80851[ebp]
\r
2122 001e6 89 88 bc 16 00
\r
2123 00 mov DWORD PTR [eax+5820], ecx
\r
2126 ; 1079 : extra = extra_lbits[code];
\r
2128 001ec 8b 1c bd 00 00
\r
2129 00 00 mov ebx, DWORD PTR _extra_lbits[edi*4]
\r
2130 001f3 8b 55 fc mov edx, DWORD PTR _dist$[ebp]
\r
2131 001f6 89 5d f0 mov DWORD PTR _extra$[ebp], ebx
\r
2133 ; 1080 : if (extra != 0) {
\r
2135 001f9 85 db test ebx, ebx
\r
2136 001fb 74 7a je SHORT $LN8@compress_b
\r
2138 ; 1081 : lc -= base_length[code];
\r
2140 001fd 2b 34 bd 00 00
\r
2141 00 00 sub esi, DWORD PTR _base_length[edi*4]
\r
2143 ; 1082 : send_bits(s, lc, extra); /* send the extra length bits */
\r
2145 00204 8b 88 bc 16 00
\r
2146 00 mov ecx, DWORD PTR [eax+5820]
\r
2147 0020a bf 10 00 00 00 mov edi, 16 ; 00000010H
\r
2148 0020f 2b fb sub edi, ebx
\r
2149 00211 3b cf cmp ecx, edi
\r
2150 00213 7e 50 jle SHORT $LN9@compress_b
\r
2151 00215 66 8b fe mov di, si
\r
2152 00218 66 d3 e7 shl di, cl
\r
2153 0021b 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2154 0021e 66 09 b8 b8 16
\r
2155 00 00 or WORD PTR [eax+5816], di
\r
2156 00225 0f b6 98 b8 16
\r
2157 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2158 0022c 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2159 0022f 88 1c 39 mov BYTE PTR [ecx+edi], bl
\r
2160 00232 ff 40 14 inc DWORD PTR [eax+20]
\r
2161 00235 0f b6 98 b9 16
\r
2162 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2163 0023c 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2164 0023f 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2165 00242 88 1c 0f mov BYTE PTR [edi+ecx], bl
\r
2166 00245 8b 98 bc 16 00
\r
2167 00 mov ebx, DWORD PTR [eax+5820]
\r
2168 0024b ff 40 14 inc DWORD PTR [eax+20]
\r
2169 0024e b1 10 mov cl, 16 ; 00000010H
\r
2170 00250 2a cb sub cl, bl
\r
2171 00252 66 d3 ee shr si, cl
\r
2172 00255 8b 4d f0 mov ecx, DWORD PTR _extra$[ebp]
\r
2173 00258 8d 4c 0b f0 lea ecx, DWORD PTR [ebx+ecx-16]
\r
2174 0025c 66 89 b0 b8 16
\r
2175 00 00 mov WORD PTR [eax+5816], si
\r
2176 00263 eb 0c jmp SHORT $LN30@compress_b
\r
2178 00265 66 d3 e6 shl si, cl
\r
2179 00268 66 09 b0 b8 16
\r
2180 00 00 or WORD PTR [eax+5816], si
\r
2181 0026f 03 cb add ecx, ebx
\r
2183 00271 89 88 bc 16 00
\r
2184 00 mov DWORD PTR [eax+5820], ecx
\r
2188 ; 1084 : dist--; /* dist is now the match distance - 1 */
\r
2191 00278 89 55 fc mov DWORD PTR _dist$[ebp], edx
\r
2193 ; 1085 : code = d_code(dist);
\r
2195 0027b 81 fa 00 01 00
\r
2196 00 cmp edx, 256 ; 00000100H
\r
2197 00281 73 09 jae SHORT $LN23@compress_b
\r
2198 00283 0f b6 b2 00 00
\r
2199 00 00 movzx esi, BYTE PTR __dist_code[edx]
\r
2200 0028a eb 0c jmp SHORT $LN24@compress_b
\r
2202 0028c 8b ca mov ecx, edx
\r
2203 0028e c1 e9 07 shr ecx, 7
\r
2204 00291 0f b6 b1 00 01
\r
2205 00 00 movzx esi, BYTE PTR __dist_code[ecx+256]
\r
2208 ; 1086 : Assert (code < D_CODES, "bad d_code");
\r
2210 ; 1088 : send_code(s, code, dtree); /* send the distance code */
\r
2212 00298 8b 4d 0c mov ecx, DWORD PTR _dtree$[ebp]
\r
2213 0029b 0f b7 7c b1 02 movzx edi, WORD PTR [ecx+esi*4+2]
\r
2214 002a0 8b 88 bc 16 00
\r
2215 00 mov ecx, DWORD PTR [eax+5820]
\r
2216 002a6 bb 10 00 00 00 mov ebx, 16 ; 00000010H
\r
2217 002ab 2b df sub ebx, edi
\r
2218 002ad 89 7d f0 mov DWORD PTR _len$80874[ebp], edi
\r
2219 002b0 3b cb cmp ecx, ebx
\r
2220 002b2 7e 60 jle SHORT $LN7@compress_b
\r
2221 002b4 8b 55 0c mov edx, DWORD PTR _dtree$[ebp]
\r
2222 002b7 0f b7 3c b2 movzx edi, WORD PTR [edx+esi*4]
\r
2223 002bb 66 8b d7 mov dx, di
\r
2224 002be 66 d3 e2 shl dx, cl
\r
2225 002c1 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2226 002c4 66 09 90 b8 16
\r
2227 00 00 or WORD PTR [eax+5816], dx
\r
2228 002cb 0f b6 98 b8 16
\r
2229 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2230 002d2 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2231 002d5 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2232 002d8 ff 40 14 inc DWORD PTR [eax+20]
\r
2233 002db 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2234 002de 0f b6 98 b9 16
\r
2235 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2236 002e5 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2237 002e8 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2238 002eb 8b 90 bc 16 00
\r
2239 00 mov edx, DWORD PTR [eax+5820]
\r
2240 002f1 ff 40 14 inc DWORD PTR [eax+20]
\r
2241 002f4 b1 10 mov cl, 16 ; 00000010H
\r
2242 002f6 2a ca sub cl, dl
\r
2243 002f8 66 d3 ef shr di, cl
\r
2244 002fb 8b 4d f0 mov ecx, DWORD PTR _len$80874[ebp]
\r
2245 002fe 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2246 00302 89 90 bc 16 00
\r
2247 00 mov DWORD PTR [eax+5820], edx
\r
2248 00308 8b 55 fc mov edx, DWORD PTR _dist$[ebp]
\r
2249 0030b 66 89 b8 b8 16
\r
2250 00 00 mov WORD PTR [eax+5816], di
\r
2251 00312 eb 19 jmp SHORT $LN31@compress_b
\r
2253 00314 8b 5d 0c mov ebx, DWORD PTR _dtree$[ebp]
\r
2254 00317 66 8b 1c b3 mov bx, WORD PTR [ebx+esi*4]
\r
2255 0031b 66 d3 e3 shl bx, cl
\r
2256 0031e 66 09 98 b8 16
\r
2257 00 00 or WORD PTR [eax+5816], bx
\r
2258 00325 03 cf add ecx, edi
\r
2259 00327 89 88 bc 16 00
\r
2260 00 mov DWORD PTR [eax+5820], ecx
\r
2263 ; 1089 : extra = extra_dbits[code];
\r
2265 0032d 8b 3c b5 00 00
\r
2266 00 00 mov edi, DWORD PTR _extra_dbits[esi*4]
\r
2267 00334 8b 5d 08 mov ebx, DWORD PTR _ltree$[ebp]
\r
2269 ; 1090 : if (extra != 0) {
\r
2271 00337 85 ff test edi, edi
\r
2272 00339 0f 84 87 fd ff
\r
2273 ff je $LN18@compress_b
\r
2275 ; 1091 : dist -= base_dist[code];
\r
2277 0033f 2b 14 b5 00 00
\r
2278 00 00 sub edx, DWORD PTR _base_dist[esi*4]
\r
2280 ; 1092 : send_bits(s, dist, extra); /* send the extra distance bits */
\r
2282 00346 8b 88 bc 16 00
\r
2283 00 mov ecx, DWORD PTR [eax+5820]
\r
2284 0034c be 10 00 00 00 mov esi, 16 ; 00000010H
\r
2285 00351 2b f7 sub esi, edi
\r
2286 00353 3b ce cmp ecx, esi
\r
2287 00355 0f 8e 59 fd ff
\r
2288 ff jle $LN4@compress_b
\r
2289 0035b 66 8b f2 mov si, dx
\r
2290 0035e 66 d3 e6 shl si, cl
\r
2291 00361 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2292 00364 66 09 b0 b8 16
\r
2293 00 00 or WORD PTR [eax+5816], si
\r
2294 0036b 0f b6 98 b8 16
\r
2295 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2296 00372 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
2297 00375 88 1c 31 mov BYTE PTR [ecx+esi], bl
\r
2298 00378 ff 40 14 inc DWORD PTR [eax+20]
\r
2299 0037b 0f b6 98 b9 16
\r
2300 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2301 00382 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
2302 00385 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2303 00388 88 1c 0e mov BYTE PTR [esi+ecx], bl
\r
2304 0038b 8b 98 bc 16 00
\r
2305 00 mov ebx, DWORD PTR [eax+5820]
\r
2306 00391 ff 40 14 inc DWORD PTR [eax+20]
\r
2307 00394 b1 10 mov cl, 16 ; 00000010H
\r
2308 00396 2a cb sub cl, bl
\r
2309 00398 66 d3 ea shr dx, cl
\r
2310 0039b 66 89 90 b8 16
\r
2311 00 00 mov WORD PTR [eax+5816], dx
\r
2312 003a2 8d 54 3b f0 lea edx, DWORD PTR [ebx+edi-16]
\r
2313 003a6 8b 5d 08 mov ebx, DWORD PTR _ltree$[ebp]
\r
2314 003a9 89 90 bc 16 00
\r
2315 00 mov DWORD PTR [eax+5820], edx
\r
2316 003af e9 12 fd ff ff jmp $LN18@compress_b
\r
2320 ; 1102 : send_code(s, END_BLOCK, ltree);
\r
2322 003b4 66 8b 93 00 04
\r
2323 00 00 mov dx, WORD PTR [ebx+1024]
\r
2324 003bb 66 d3 e2 shl dx, cl
\r
2325 003be 66 09 90 b8 16
\r
2326 00 00 or WORD PTR [eax+5816], dx
\r
2327 003c5 03 cf add ecx, edi
\r
2330 003c9 89 88 bc 16 00
\r
2331 00 mov DWORD PTR [eax+5820], ecx
\r
2336 003d0 8b e5 mov esp, ebp
\r
2339 _compress_block ENDP
\r
2342 ; Function compile flags: /Ogtp
\r
2343 ; COMDAT __tr_align
\r
2345 __tr_align PROC ; COMDAT
\r
2348 ; 895 : send_bits(s, STATIC_TREES<<1, 3);
\r
2350 00000 8b 88 bc 16 00
\r
2351 00 mov ecx, DWORD PTR [eax+5820]
\r
2352 00006 ba 02 00 00 00 mov edx, 2
\r
2353 0000b 66 d3 e2 shl dx, cl
\r
2356 00010 be 01 00 00 00 mov esi, 1
\r
2357 00015 66 09 90 b8 16
\r
2358 00 00 or WORD PTR [eax+5816], dx
\r
2359 0001c 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
2360 0001f 7e 4c jle SHORT $LN4@tr_align
\r
2361 00021 0f b6 98 b8 16
\r
2362 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2363 00028 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2364 0002b 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2365 0002e 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2366 00031 01 70 14 add DWORD PTR [eax+20], esi
\r
2367 00034 0f b6 98 b9 16
\r
2368 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2369 0003b 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2370 0003e 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2371 00041 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2372 00044 8b 90 bc 16 00
\r
2373 00 mov edx, DWORD PTR [eax+5820]
\r
2374 0004a 01 70 14 add DWORD PTR [eax+20], esi
\r
2376 0004e b1 10 mov cl, 16 ; 00000010H
\r
2377 00050 2a ca sub cl, dl
\r
2378 00052 bf 02 00 00 00 mov edi, 2
\r
2379 00057 66 d3 ef shr di, cl
\r
2380 0005a 83 c2 f3 add edx, -13 ; fffffff3H
\r
2381 0005d 89 90 bc 16 00
\r
2382 00 mov DWORD PTR [eax+5820], edx
\r
2383 00063 66 89 b8 b8 16
\r
2384 00 00 mov WORD PTR [eax+5816], di
\r
2386 0006b eb 09 jmp SHORT $LN3@tr_align
\r
2388 0006d 83 c1 03 add ecx, 3
\r
2389 00070 89 88 bc 16 00
\r
2390 00 mov DWORD PTR [eax+5820], ecx
\r
2393 ; 896 : send_code(s, END_BLOCK, static_ltree);
\r
2395 00076 8b 88 bc 16 00
\r
2396 00 mov ecx, DWORD PTR [eax+5820]
\r
2397 0007c 33 d2 xor edx, edx
\r
2398 0007e 66 d3 e2 shl dx, cl
\r
2399 00081 66 09 90 b8 16
\r
2400 00 00 or WORD PTR [eax+5816], dx
\r
2401 00088 83 f9 09 cmp ecx, 9
\r
2402 0008b 7e 4c jle SHORT $LN2@tr_align
\r
2403 0008d 0f b6 98 b8 16
\r
2404 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2405 00094 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2406 00097 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2407 0009a 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2408 0009d 01 70 14 add DWORD PTR [eax+20], esi
\r
2409 000a0 0f b6 98 b9 16
\r
2410 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2411 000a7 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2412 000aa 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2413 000ad 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2414 000b0 01 70 14 add DWORD PTR [eax+20], esi
\r
2415 000b3 8b 90 bc 16 00
\r
2416 00 mov edx, DWORD PTR [eax+5820]
\r
2417 000b9 b1 10 mov cl, 16 ; 00000010H
\r
2418 000bb 33 f6 xor esi, esi
\r
2419 000bd 2a ca sub cl, dl
\r
2420 000bf 66 d3 ee shr si, cl
\r
2421 000c2 83 c2 f7 add edx, -9 ; fffffff7H
\r
2422 000c5 89 90 bc 16 00
\r
2423 00 mov DWORD PTR [eax+5820], edx
\r
2424 000cb 66 89 b0 b8 16
\r
2425 00 00 mov WORD PTR [eax+5816], si
\r
2429 ; 897 : #ifdef DEBUG
\r
2430 ; 898 : s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
\r
2432 ; 900 : bi_flush(s);
\r
2434 000d4 e9 00 00 00 00 jmp _bi_flush
\r
2437 ; 896 : send_code(s, END_BLOCK, static_ltree);
\r
2439 000d9 83 c1 07 add ecx, 7
\r
2441 000dd 89 88 bc 16 00
\r
2442 00 mov DWORD PTR [eax+5820], ecx
\r
2445 ; 897 : #ifdef DEBUG
\r
2446 ; 898 : s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
\r
2448 ; 900 : bi_flush(s);
\r
2450 000e4 e9 00 00 00 00 jmp _bi_flush
\r
2453 PUBLIC __tr_flush_bits
\r
2454 ; Function compile flags: /Ogtp
\r
2455 ; COMDAT __tr_flush_bits
\r
2457 __tr_flush_bits PROC ; COMDAT
\r
2460 ; 885 : bi_flush(s);
\r
2462 00000 e9 00 00 00 00 jmp _bi_flush
\r
2463 __tr_flush_bits ENDP
\r
2464 ; Function compile flags: /Ogtp
\r
2466 ; COMDAT _send_tree
\r
2468 tv1014 = -28 ; size = 4
\r
2469 tv1013 = -28 ; size = 4
\r
2470 tv1012 = -28 ; size = 4
\r
2471 tv1011 = -28 ; size = 4
\r
2472 tv1010 = -28 ; size = 4
\r
2473 tv1009 = -28 ; size = 4
\r
2474 tv1008 = -28 ; size = 4
\r
2475 _curlen$ = -28 ; size = 4
\r
2476 tv589 = -24 ; size = 4
\r
2477 _val$80642 = -20 ; size = 4
\r
2478 _val$80631 = -20 ; size = 4
\r
2479 _val$80619 = -20 ; size = 4
\r
2480 _val$80608 = -20 ; size = 4
\r
2481 _val$80595 = -20 ; size = 4
\r
2482 _val$80584 = -20 ; size = 4
\r
2483 _val$80573 = -20 ; size = 4
\r
2484 _prevlen$ = -20 ; size = 4
\r
2485 tv1196 = -16 ; size = 4
\r
2486 _nextlen$ = -12 ; size = 4
\r
2487 _len$80628 = -8 ; size = 4
\r
2488 _len$80605 = -8 ; size = 4
\r
2489 _len$80581 = -8 ; size = 4
\r
2490 _len$80570 = -8 ; size = 4
\r
2491 _min_count$ = -8 ; size = 4
\r
2492 _count$ = -4 ; size = 4
\r
2493 _send_tree PROC ; COMDAT
\r
2496 ; _max_code$ = ecx
\r
2501 00001 8b ec mov ebp, esp
\r
2502 00003 83 ec 1c sub esp, 28 ; 0000001cH
\r
2505 00008 8b f2 mov esi, edx
\r
2507 ; 755 : int n; /* iterates over all tree elements */
\r
2508 ; 756 : int prevlen = -1; /* last emitted length */
\r
2509 ; 757 : int curlen; /* length of current code */
\r
2510 ; 758 : int nextlen = tree[0].Len; /* length of next code */
\r
2512 0000a 0f b7 5e 02 movzx ebx, WORD PTR [esi+2]
\r
2514 ; 759 : int count = 0; /* repeat count of the current code */
\r
2516 0000e 33 d2 xor edx, edx
\r
2518 00011 8b f9 mov edi, ecx
\r
2519 00013 c7 45 ec ff ff
\r
2520 ff ff mov DWORD PTR _prevlen$[ebp], -1
\r
2521 0001a 89 5d f4 mov DWORD PTR _nextlen$[ebp], ebx
\r
2523 ; 760 : int max_count = 7; /* max repeat count */
\r
2525 0001d 8d 4a 07 lea ecx, DWORD PTR [edx+7]
\r
2527 ; 761 : int min_count = 4; /* min repeat count */
\r
2529 00020 c7 45 f8 04 00
\r
2530 00 00 mov DWORD PTR _min_count$[ebp], 4
\r
2533 ; 763 : /* tree[max_code+1].Len = -1; */ /* guard already set */
\r
2534 ; 764 : if (nextlen == 0) max_count = 138, min_count = 3;
\r
2536 00027 85 db test ebx, ebx
\r
2537 00029 75 0c jne SHORT $LN36@send_tree
\r
2538 0002b b9 8a 00 00 00 mov ecx, 138 ; 0000008aH
\r
2539 00030 c7 45 f8 03 00
\r
2540 00 00 mov DWORD PTR _min_count$[ebp], 3
\r
2544 ; 766 : for (n = 0; n <= max_code; n++) {
\r
2546 00037 85 ff test edi, edi
\r
2547 00039 0f 88 35 05 00
\r
2548 00 js $LN33@send_tree
\r
2549 0003f 83 c6 06 add esi, 6
\r
2551 00043 89 75 f0 mov DWORD PTR tv1196[ebp], esi
\r
2552 00046 89 7d e8 mov DWORD PTR tv589[ebp], edi
\r
2553 00049 bb 01 00 00 00 mov ebx, 1
\r
2554 0004e 8b ff npad 2
\r
2557 ; 767 : curlen = nextlen; nextlen = tree[n+1].Len;
\r
2559 00050 8b 7d f0 mov edi, DWORD PTR tv1196[ebp]
\r
2560 00053 0f b7 3f movzx edi, WORD PTR [edi]
\r
2561 00056 8b 75 f4 mov esi, DWORD PTR _nextlen$[ebp]
\r
2563 ; 768 : if (++count < max_count && curlen == nextlen) {
\r
2565 00059 03 d3 add edx, ebx
\r
2566 0005b 89 75 e4 mov DWORD PTR _curlen$[ebp], esi
\r
2567 0005e 89 7d f4 mov DWORD PTR _nextlen$[ebp], edi
\r
2568 00061 89 55 fc mov DWORD PTR _count$[ebp], edx
\r
2569 00064 3b d1 cmp edx, ecx
\r
2570 00066 7d 08 jge SHORT $LN32@send_tree
\r
2571 00068 3b f7 cmp esi, edi
\r
2572 0006a 0f 84 f7 04 00
\r
2573 00 je $LN34@send_tree
\r
2577 ; 770 : } else if (count < min_count) {
\r
2579 00070 3b 55 f8 cmp edx, DWORD PTR _min_count$[ebp]
\r
2580 00073 0f 8d a5 00 00
\r
2581 00 jge $LN30@send_tree
\r
2582 00079 8d a4 24 00 00
\r
2586 ; 771 : do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
\r
2588 00080 0f b7 bc b0 7e
\r
2589 0a 00 00 movzx edi, WORD PTR [eax+esi*4+2686]
\r
2590 00088 8b 88 bc 16 00
\r
2591 00 mov ecx, DWORD PTR [eax+5820]
\r
2592 0008e ba 10 00 00 00 mov edx, 16 ; 00000010H
\r
2593 00093 2b d7 sub edx, edi
\r
2594 00095 3b ca cmp ecx, edx
\r
2595 00097 7e 5d jle SHORT $LN26@send_tree
\r
2596 00099 0f b7 b4 b0 7c
\r
2597 0a 00 00 movzx esi, WORD PTR [eax+esi*4+2684]
\r
2598 000a1 66 8b d6 mov dx, si
\r
2599 000a4 66 d3 e2 shl dx, cl
\r
2600 000a7 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2601 000aa 66 09 90 b8 16
\r
2602 00 00 or WORD PTR [eax+5816], dx
\r
2603 000b1 0f b6 98 b8 16
\r
2604 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
2605 000b8 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2606 000bb 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2607 000be ff 40 14 inc DWORD PTR [eax+20]
\r
2608 000c1 0f b6 98 b9 16
\r
2609 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
2610 000c8 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
2611 000cb 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
2612 000ce 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
2613 000d1 8b 90 bc 16 00
\r
2614 00 mov edx, DWORD PTR [eax+5820]
\r
2615 000d7 b1 10 mov cl, 16 ; 00000010H
\r
2616 000d9 bb 01 00 00 00 mov ebx, 1
\r
2617 000de 01 58 14 add DWORD PTR [eax+20], ebx
\r
2618 000e1 2a ca sub cl, dl
\r
2619 000e3 66 d3 ee shr si, cl
\r
2620 000e6 8d 4c 3a f0 lea ecx, DWORD PTR [edx+edi-16]
\r
2621 000ea 66 89 b0 b8 16
\r
2622 00 00 mov WORD PTR [eax+5816], si
\r
2623 000f1 8b 75 e4 mov esi, DWORD PTR _curlen$[ebp]
\r
2624 000f4 eb 14 jmp SHORT $LN44@send_tree
\r
2626 000f6 66 8b 94 b0 7c
\r
2627 0a 00 00 mov dx, WORD PTR [eax+esi*4+2684]
\r
2628 000fe 66 d3 e2 shl dx, cl
\r
2629 00101 66 09 90 b8 16
\r
2630 00 00 or WORD PTR [eax+5816], dx
\r
2631 00108 03 cf add ecx, edi
\r
2633 0010a 29 5d fc sub DWORD PTR _count$[ebp], ebx
\r
2634 0010d 89 88 bc 16 00
\r
2635 00 mov DWORD PTR [eax+5820], ecx
\r
2636 00113 0f 85 67 ff ff
\r
2637 ff jne $LL29@send_tree
\r
2640 ; 773 : } else if (curlen != 0) {
\r
2642 00119 e9 11 04 00 00 jmp $LN5@send_tree
\r
2644 0011e 85 f6 test esi, esi
\r
2645 00120 0f 84 cb 01 00
\r
2646 00 je $LN23@send_tree
\r
2648 ; 774 : if (curlen != prevlen) {
\r
2650 00126 3b 75 ec cmp esi, DWORD PTR _prevlen$[ebp]
\r
2651 00129 0f 84 aa 00 00
\r
2652 00 je $LN42@send_tree
\r
2654 ; 775 : send_code(s, curlen, s->bl_tree); count--;
\r
2656 0012f 0f b7 8c b0 7e
\r
2657 0a 00 00 movzx ecx, WORD PTR [eax+esi*4+2686]
\r
2658 00137 bf 10 00 00 00 mov edi, 16 ; 00000010H
\r
2659 0013c 2b f9 sub edi, ecx
\r
2660 0013e 89 4d f8 mov DWORD PTR _len$80570[ebp], ecx
\r
2661 00141 8b 88 bc 16 00
\r
2662 00 mov ecx, DWORD PTR [eax+5820]
\r
2663 00147 3b cf cmp ecx, edi
\r
2664 00149 7e 68 jle SHORT $LN21@send_tree
\r
2665 0014b 0f b7 94 b0 7c
\r
2666 0a 00 00 movzx edx, WORD PTR [eax+esi*4+2684]
\r
2667 00153 89 55 ec mov DWORD PTR _val$80573[ebp], edx
\r
2668 00156 66 d3 e2 shl dx, cl
\r
2669 00159 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2670 0015c 89 45 e4 mov DWORD PTR tv1014[ebp], eax
\r
2671 0015f 66 09 90 b8 16
\r
2672 00 00 or WORD PTR [eax+5816], dx
\r
2673 00166 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2674 00169 8a 80 b8 16 00
\r
2675 00 mov al, BYTE PTR [eax+5816]
\r
2676 0016f 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2677 00172 8b 45 e4 mov eax, DWORD PTR tv1014[ebp]
\r
2678 00175 01 58 14 add DWORD PTR [eax+20], ebx
\r
2679 00178 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2680 0017b 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2681 0017e 8a 90 b9 16 00
\r
2682 00 mov dl, BYTE PTR [eax+5817]
\r
2683 00184 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2684 00187 8b 90 bc 16 00
\r
2685 00 mov edx, DWORD PTR [eax+5820]
\r
2686 0018d 8b 7d ec mov edi, DWORD PTR _val$80573[ebp]
\r
2687 00190 01 58 14 add DWORD PTR [eax+20], ebx
\r
2688 00193 b1 10 mov cl, 16 ; 00000010H
\r
2689 00195 2a ca sub cl, dl
\r
2690 00197 66 d3 ef shr di, cl
\r
2691 0019a 8b 4d f8 mov ecx, DWORD PTR _len$80570[ebp]
\r
2692 0019d 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2693 001a1 89 90 bc 16 00
\r
2694 00 mov DWORD PTR [eax+5820], edx
\r
2695 001a7 8b 55 fc mov edx, DWORD PTR _count$[ebp]
\r
2696 001aa 66 89 b8 b8 16
\r
2697 00 00 mov WORD PTR [eax+5816], di
\r
2698 001b1 eb 21 jmp SHORT $LN20@send_tree
\r
2700 001b3 66 8b bc b0 7c
\r
2701 0a 00 00 mov di, WORD PTR [eax+esi*4+2684]
\r
2702 001bb 66 d3 e7 shl di, cl
\r
2703 001be 8b 88 bc 16 00
\r
2704 00 mov ecx, DWORD PTR [eax+5820]
\r
2705 001c4 66 09 b8 b8 16
\r
2706 00 00 or WORD PTR [eax+5816], di
\r
2707 001cb 03 4d f8 add ecx, DWORD PTR _len$80570[ebp]
\r
2708 001ce 89 88 bc 16 00
\r
2709 00 mov DWORD PTR [eax+5820], ecx
\r
2711 001d4 2b d3 sub edx, ebx
\r
2712 001d6 89 55 fc mov DWORD PTR _count$[ebp], edx
\r
2716 ; 777 : Assert(count >= 3 && count <= 6, " 3_6?");
\r
2717 ; 778 : send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
\r
2719 001d9 0f b7 88 be 0a
\r
2720 00 00 movzx ecx, WORD PTR [eax+2750]
\r
2721 001e0 bf 10 00 00 00 mov edi, 16 ; 00000010H
\r
2722 001e5 2b f9 sub edi, ecx
\r
2723 001e7 89 4d f8 mov DWORD PTR _len$80581[ebp], ecx
\r
2724 001ea 8b 88 bc 16 00
\r
2725 00 mov ecx, DWORD PTR [eax+5820]
\r
2726 001f0 3b cf cmp ecx, edi
\r
2727 001f2 7e 67 jle SHORT $LN19@send_tree
\r
2728 001f4 0f b7 90 bc 0a
\r
2729 00 00 movzx edx, WORD PTR [eax+2748]
\r
2730 001fb 89 55 ec mov DWORD PTR _val$80584[ebp], edx
\r
2731 001fe 66 d3 e2 shl dx, cl
\r
2732 00201 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2733 00204 89 45 e4 mov DWORD PTR tv1013[ebp], eax
\r
2734 00207 66 09 90 b8 16
\r
2735 00 00 or WORD PTR [eax+5816], dx
\r
2736 0020e 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2737 00211 8a 80 b8 16 00
\r
2738 00 mov al, BYTE PTR [eax+5816]
\r
2739 00217 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2740 0021a 8b 45 e4 mov eax, DWORD PTR tv1013[ebp]
\r
2741 0021d 01 58 14 add DWORD PTR [eax+20], ebx
\r
2742 00220 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2743 00223 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2744 00226 8a 90 b9 16 00
\r
2745 00 mov dl, BYTE PTR [eax+5817]
\r
2746 0022c 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2747 0022f 8b 90 bc 16 00
\r
2748 00 mov edx, DWORD PTR [eax+5820]
\r
2749 00235 8b 7d ec mov edi, DWORD PTR _val$80584[ebp]
\r
2750 00238 01 58 14 add DWORD PTR [eax+20], ebx
\r
2751 0023b b1 10 mov cl, 16 ; 00000010H
\r
2752 0023d 2a ca sub cl, dl
\r
2753 0023f 66 d3 ef shr di, cl
\r
2754 00242 8b 4d f8 mov ecx, DWORD PTR _len$80581[ebp]
\r
2755 00245 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2756 00249 89 90 bc 16 00
\r
2757 00 mov DWORD PTR [eax+5820], edx
\r
2758 0024f 8b 55 fc mov edx, DWORD PTR _count$[ebp]
\r
2759 00252 66 89 b8 b8 16
\r
2760 00 00 mov WORD PTR [eax+5816], di
\r
2761 00259 eb 1a jmp SHORT $LN18@send_tree
\r
2763 0025b 66 8b b8 bc 0a
\r
2764 00 00 mov di, WORD PTR [eax+2748]
\r
2765 00262 66 d3 e7 shl di, cl
\r
2766 00265 66 09 b8 b8 16
\r
2767 00 00 or WORD PTR [eax+5816], di
\r
2768 0026c 03 4d f8 add ecx, DWORD PTR _len$80581[ebp]
\r
2769 0026f 89 88 bc 16 00
\r
2770 00 mov DWORD PTR [eax+5820], ecx
\r
2772 00275 8b 88 bc 16 00
\r
2773 00 mov ecx, DWORD PTR [eax+5820]
\r
2774 0027b 83 c2 fd add edx, -3 ; fffffffdH
\r
2775 0027e 83 f9 0e cmp ecx, 14 ; 0000000eH
\r
2776 00281 7e 5c jle SHORT $LN17@send_tree
\r
2777 00283 89 55 ec mov DWORD PTR _val$80595[ebp], edx
\r
2778 00286 66 d3 e2 shl dx, cl
\r
2779 00289 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2780 0028c 89 45 e4 mov DWORD PTR tv1012[ebp], eax
\r
2781 0028f 66 09 90 b8 16
\r
2782 00 00 or WORD PTR [eax+5816], dx
\r
2783 00296 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2784 00299 8a 80 b8 16 00
\r
2785 00 mov al, BYTE PTR [eax+5816]
\r
2786 0029f 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2787 002a2 8b 45 e4 mov eax, DWORD PTR tv1012[ebp]
\r
2788 002a5 01 58 14 add DWORD PTR [eax+20], ebx
\r
2789 002a8 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2790 002ab 8a 90 b9 16 00
\r
2791 00 mov dl, BYTE PTR [eax+5817]
\r
2792 002b1 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2793 002b4 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2794 002b7 8b 90 bc 16 00
\r
2795 00 mov edx, DWORD PTR [eax+5820]
\r
2796 002bd 8b 7d ec mov edi, DWORD PTR _val$80595[ebp]
\r
2797 002c0 01 58 14 add DWORD PTR [eax+20], ebx
\r
2798 002c3 b1 10 mov cl, 16 ; 00000010H
\r
2799 002c5 2a ca sub cl, dl
\r
2800 002c7 66 d3 ef shr di, cl
\r
2801 002ca 83 c2 f2 add edx, -14 ; fffffff2H
\r
2802 002cd 89 90 bc 16 00
\r
2803 00 mov DWORD PTR [eax+5820], edx
\r
2804 002d3 66 89 b8 b8 16
\r
2805 00 00 mov WORD PTR [eax+5816], di
\r
2806 002da e9 50 02 00 00 jmp $LN5@send_tree
\r
2808 002df 66 d3 e2 shl dx, cl
\r
2809 002e2 66 09 90 b8 16
\r
2810 00 00 or WORD PTR [eax+5816], dx
\r
2811 002e9 83 c1 02 add ecx, 2
\r
2812 002ec e9 38 02 00 00 jmp $LN45@send_tree
\r
2816 ; 780 : } else if (count <= 10) {
\r
2817 ; 781 : send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
\r
2819 002f1 bf 10 00 00 00 mov edi, 16 ; 00000010H
\r
2820 002f6 83 fa 0a cmp edx, 10 ; 0000000aH
\r
2821 002f9 0f 8f 19 01 00
\r
2822 00 jg $LN14@send_tree
\r
2823 002ff 0f b7 88 c2 0a
\r
2824 00 00 movzx ecx, WORD PTR [eax+2754]
\r
2825 00306 2b f9 sub edi, ecx
\r
2826 00308 89 4d f8 mov DWORD PTR _len$80605[ebp], ecx
\r
2827 0030b 8b 88 bc 16 00
\r
2828 00 mov ecx, DWORD PTR [eax+5820]
\r
2829 00311 3b cf cmp ecx, edi
\r
2830 00313 7e 67 jle SHORT $LN13@send_tree
\r
2831 00315 0f b7 90 c0 0a
\r
2832 00 00 movzx edx, WORD PTR [eax+2752]
\r
2833 0031c 89 55 ec mov DWORD PTR _val$80608[ebp], edx
\r
2834 0031f 66 d3 e2 shl dx, cl
\r
2835 00322 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2836 00325 89 45 e4 mov DWORD PTR tv1011[ebp], eax
\r
2837 00328 66 09 90 b8 16
\r
2838 00 00 or WORD PTR [eax+5816], dx
\r
2839 0032f 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2840 00332 8a 80 b8 16 00
\r
2841 00 mov al, BYTE PTR [eax+5816]
\r
2842 00338 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2843 0033b 8b 45 e4 mov eax, DWORD PTR tv1011[ebp]
\r
2844 0033e 01 58 14 add DWORD PTR [eax+20], ebx
\r
2845 00341 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2846 00344 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2847 00347 8a 90 b9 16 00
\r
2848 00 mov dl, BYTE PTR [eax+5817]
\r
2849 0034d 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2850 00350 8b 90 bc 16 00
\r
2851 00 mov edx, DWORD PTR [eax+5820]
\r
2852 00356 8b 7d ec mov edi, DWORD PTR _val$80608[ebp]
\r
2853 00359 01 58 14 add DWORD PTR [eax+20], ebx
\r
2854 0035c b1 10 mov cl, 16 ; 00000010H
\r
2855 0035e 2a ca sub cl, dl
\r
2856 00360 66 d3 ef shr di, cl
\r
2857 00363 8b 4d f8 mov ecx, DWORD PTR _len$80605[ebp]
\r
2858 00366 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2859 0036a 89 90 bc 16 00
\r
2860 00 mov DWORD PTR [eax+5820], edx
\r
2861 00370 8b 55 fc mov edx, DWORD PTR _count$[ebp]
\r
2862 00373 66 89 b8 b8 16
\r
2863 00 00 mov WORD PTR [eax+5816], di
\r
2864 0037a eb 20 jmp SHORT $LN12@send_tree
\r
2866 0037c 66 8b b8 c0 0a
\r
2867 00 00 mov di, WORD PTR [eax+2752]
\r
2868 00383 66 d3 e7 shl di, cl
\r
2869 00386 8b 88 bc 16 00
\r
2870 00 mov ecx, DWORD PTR [eax+5820]
\r
2871 0038c 66 09 b8 b8 16
\r
2872 00 00 or WORD PTR [eax+5816], di
\r
2873 00393 03 4d f8 add ecx, DWORD PTR _len$80605[ebp]
\r
2874 00396 89 88 bc 16 00
\r
2875 00 mov DWORD PTR [eax+5820], ecx
\r
2877 0039c 8b 88 bc 16 00
\r
2878 00 mov ecx, DWORD PTR [eax+5820]
\r
2879 003a2 83 c2 fd add edx, -3 ; fffffffdH
\r
2880 003a5 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
2881 003a8 7e 5c jle SHORT $LN11@send_tree
\r
2882 003aa 89 55 ec mov DWORD PTR _val$80619[ebp], edx
\r
2883 003ad 66 d3 e2 shl dx, cl
\r
2884 003b0 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2885 003b3 89 45 e4 mov DWORD PTR tv1010[ebp], eax
\r
2886 003b6 66 09 90 b8 16
\r
2887 00 00 or WORD PTR [eax+5816], dx
\r
2888 003bd 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2889 003c0 8a 80 b8 16 00
\r
2890 00 mov al, BYTE PTR [eax+5816]
\r
2891 003c6 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2892 003c9 8b 45 e4 mov eax, DWORD PTR tv1010[ebp]
\r
2893 003cc 01 58 14 add DWORD PTR [eax+20], ebx
\r
2894 003cf 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2895 003d2 8a 90 b9 16 00
\r
2896 00 mov dl, BYTE PTR [eax+5817]
\r
2897 003d8 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2898 003db 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2899 003de 8b 90 bc 16 00
\r
2900 00 mov edx, DWORD PTR [eax+5820]
\r
2901 003e4 8b 7d ec mov edi, DWORD PTR _val$80619[ebp]
\r
2902 003e7 01 58 14 add DWORD PTR [eax+20], ebx
\r
2903 003ea b1 10 mov cl, 16 ; 00000010H
\r
2904 003ec 2a ca sub cl, dl
\r
2905 003ee 66 d3 ef shr di, cl
\r
2906 003f1 83 c2 f3 add edx, -13 ; fffffff3H
\r
2907 003f4 89 90 bc 16 00
\r
2908 00 mov DWORD PTR [eax+5820], edx
\r
2909 003fa 66 89 b8 b8 16
\r
2910 00 00 mov WORD PTR [eax+5816], di
\r
2911 00401 e9 29 01 00 00 jmp $LN5@send_tree
\r
2913 00406 66 d3 e2 shl dx, cl
\r
2914 00409 66 09 90 b8 16
\r
2915 00 00 or WORD PTR [eax+5816], dx
\r
2916 00410 83 c1 03 add ecx, 3
\r
2921 00413 e9 11 01 00 00 jmp $LN45@send_tree
\r
2924 ; 784 : send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
\r
2926 00418 0f b7 88 c6 0a
\r
2927 00 00 movzx ecx, WORD PTR [eax+2758]
\r
2928 0041f 2b f9 sub edi, ecx
\r
2929 00421 89 4d f8 mov DWORD PTR _len$80628[ebp], ecx
\r
2930 00424 8b 88 bc 16 00
\r
2931 00 mov ecx, DWORD PTR [eax+5820]
\r
2932 0042a 3b cf cmp ecx, edi
\r
2933 0042c 7e 67 jle SHORT $LN8@send_tree
\r
2934 0042e 0f b7 90 c4 0a
\r
2935 00 00 movzx edx, WORD PTR [eax+2756]
\r
2936 00435 89 55 ec mov DWORD PTR _val$80631[ebp], edx
\r
2937 00438 66 d3 e2 shl dx, cl
\r
2938 0043b 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2939 0043e 89 45 e4 mov DWORD PTR tv1009[ebp], eax
\r
2940 00441 66 09 90 b8 16
\r
2941 00 00 or WORD PTR [eax+5816], dx
\r
2942 00448 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2943 0044b 8a 80 b8 16 00
\r
2944 00 mov al, BYTE PTR [eax+5816]
\r
2945 00451 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2946 00454 8b 45 e4 mov eax, DWORD PTR tv1009[ebp]
\r
2947 00457 01 58 14 add DWORD PTR [eax+20], ebx
\r
2948 0045a 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2949 0045d 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2950 00460 8a 90 b9 16 00
\r
2951 00 mov dl, BYTE PTR [eax+5817]
\r
2952 00466 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
2953 00469 8b 90 bc 16 00
\r
2954 00 mov edx, DWORD PTR [eax+5820]
\r
2955 0046f 8b 7d ec mov edi, DWORD PTR _val$80631[ebp]
\r
2956 00472 01 58 14 add DWORD PTR [eax+20], ebx
\r
2957 00475 b1 10 mov cl, 16 ; 00000010H
\r
2958 00477 2a ca sub cl, dl
\r
2959 00479 66 d3 ef shr di, cl
\r
2960 0047c 8b 4d f8 mov ecx, DWORD PTR _len$80628[ebp]
\r
2961 0047f 8d 54 0a f0 lea edx, DWORD PTR [edx+ecx-16]
\r
2962 00483 89 90 bc 16 00
\r
2963 00 mov DWORD PTR [eax+5820], edx
\r
2964 00489 8b 55 fc mov edx, DWORD PTR _count$[ebp]
\r
2965 0048c 66 89 b8 b8 16
\r
2966 00 00 mov WORD PTR [eax+5816], di
\r
2967 00493 eb 20 jmp SHORT $LN7@send_tree
\r
2969 00495 66 8b b8 c4 0a
\r
2970 00 00 mov di, WORD PTR [eax+2756]
\r
2971 0049c 66 d3 e7 shl di, cl
\r
2972 0049f 8b 88 bc 16 00
\r
2973 00 mov ecx, DWORD PTR [eax+5820]
\r
2974 004a5 66 09 b8 b8 16
\r
2975 00 00 or WORD PTR [eax+5816], di
\r
2976 004ac 03 4d f8 add ecx, DWORD PTR _len$80628[ebp]
\r
2977 004af 89 88 bc 16 00
\r
2978 00 mov DWORD PTR [eax+5820], ecx
\r
2980 004b5 8b 88 bc 16 00
\r
2981 00 mov ecx, DWORD PTR [eax+5820]
\r
2982 004bb 83 c2 f5 add edx, -11 ; fffffff5H
\r
2983 004be 83 f9 09 cmp ecx, 9
\r
2984 004c1 7e 59 jle SHORT $LN6@send_tree
\r
2985 004c3 89 55 ec mov DWORD PTR _val$80642[ebp], edx
\r
2986 004c6 66 d3 e2 shl dx, cl
\r
2987 004c9 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
2988 004cc 89 45 e4 mov DWORD PTR tv1008[ebp], eax
\r
2989 004cf 66 09 90 b8 16
\r
2990 00 00 or WORD PTR [eax+5816], dx
\r
2991 004d6 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
2992 004d9 8a 80 b8 16 00
\r
2993 00 mov al, BYTE PTR [eax+5816]
\r
2994 004df 88 04 11 mov BYTE PTR [ecx+edx], al
\r
2995 004e2 8b 45 e4 mov eax, DWORD PTR tv1008[ebp]
\r
2996 004e5 01 58 14 add DWORD PTR [eax+20], ebx
\r
2997 004e8 8b 78 14 mov edi, DWORD PTR [eax+20]
\r
2998 004eb 8a 90 b9 16 00
\r
2999 00 mov dl, BYTE PTR [eax+5817]
\r
3000 004f1 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
3001 004f4 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
3002 004f7 8b 90 bc 16 00
\r
3003 00 mov edx, DWORD PTR [eax+5820]
\r
3004 004fd 8b 7d ec mov edi, DWORD PTR _val$80642[ebp]
\r
3005 00500 01 58 14 add DWORD PTR [eax+20], ebx
\r
3006 00503 b1 10 mov cl, 16 ; 00000010H
\r
3007 00505 2a ca sub cl, dl
\r
3008 00507 66 d3 ef shr di, cl
\r
3009 0050a 83 c2 f7 add edx, -9 ; fffffff7H
\r
3010 0050d 89 90 bc 16 00
\r
3011 00 mov DWORD PTR [eax+5820], edx
\r
3012 00513 66 89 b8 b8 16
\r
3013 00 00 mov WORD PTR [eax+5816], di
\r
3014 0051a eb 13 jmp SHORT $LN5@send_tree
\r
3016 0051c 66 d3 e2 shl dx, cl
\r
3017 0051f 66 09 90 b8 16
\r
3018 00 00 or WORD PTR [eax+5816], dx
\r
3019 00526 83 c1 07 add ecx, 7
\r
3021 00529 89 88 bc 16 00
\r
3022 00 mov DWORD PTR [eax+5820], ecx
\r
3026 ; 786 : count = 0; prevlen = curlen;
\r
3027 ; 787 : if (nextlen == 0) {
\r
3029 0052f 8b 4d f4 mov ecx, DWORD PTR _nextlen$[ebp]
\r
3030 00532 33 d2 xor edx, edx
\r
3031 00534 89 75 ec mov DWORD PTR _prevlen$[ebp], esi
\r
3032 00537 85 c9 test ecx, ecx
\r
3033 00539 75 0e jne SHORT $LN4@send_tree
\r
3035 ; 788 : max_count = 138, min_count = 3;
\r
3037 0053b b9 8a 00 00 00 mov ecx, 138 ; 0000008aH
\r
3038 00540 c7 45 f8 03 00
\r
3039 00 00 mov DWORD PTR _min_count$[ebp], 3
\r
3040 00547 eb 1e jmp SHORT $LN34@send_tree
\r
3043 ; 789 : } else if (curlen == nextlen) {
\r
3045 00549 3b f1 cmp esi, ecx
\r
3046 0054b 75 0e jne SHORT $LN2@send_tree
\r
3048 ; 790 : max_count = 6, min_count = 3;
\r
3050 0054d b9 06 00 00 00 mov ecx, 6
\r
3051 00552 c7 45 f8 03 00
\r
3052 00 00 mov DWORD PTR _min_count$[ebp], 3
\r
3056 00559 eb 0c jmp SHORT $LN34@send_tree
\r
3059 ; 792 : max_count = 7, min_count = 4;
\r
3061 0055b b9 07 00 00 00 mov ecx, 7
\r
3062 00560 c7 45 f8 04 00
\r
3063 00 00 mov DWORD PTR _min_count$[ebp], 4
\r
3067 ; 766 : for (n = 0; n <= max_code; n++) {
\r
3069 00567 83 45 f0 04 add DWORD PTR tv1196[ebp], 4
\r
3070 0056b 29 5d e8 sub DWORD PTR tv589[ebp], ebx
\r
3071 0056e 0f 85 dc fa ff
\r
3072 ff jne $LL35@send_tree
\r
3082 00577 8b e5 mov esp, ebp
\r
3086 ; Function compile flags: /Ogtp
\r
3088 ; COMDAT _scan_tree
\r
3090 _nextlen$ = -16 ; size = 4
\r
3091 tv84 = -12 ; size = 4
\r
3092 _prevlen$ = -8 ; size = 4
\r
3093 tv295 = -4 ; size = 4
\r
3094 _s$ = 8 ; size = 4
\r
3095 _scan_tree PROC ; COMDAT
\r
3097 ; _max_code$ = eax
\r
3102 00001 8b ec mov ebp, esp
\r
3103 00003 83 ec 10 sub esp, 16 ; 00000010H
\r
3107 00009 8b f9 mov edi, ecx
\r
3108 0000b 8b d8 mov ebx, eax
\r
3110 ; 710 : int n; /* iterates over all tree elements */
\r
3111 ; 711 : int prevlen = -1; /* last emitted length */
\r
3112 ; 712 : int curlen; /* length of current code */
\r
3113 ; 713 : int nextlen = tree[0].Len; /* length of next code */
\r
3115 0000d 0f b7 47 02 movzx eax, WORD PTR [edi+2]
\r
3117 ; 714 : int count = 0; /* repeat count of the current code */
\r
3119 00011 33 d2 xor edx, edx
\r
3120 00013 c7 45 f8 ff ff
\r
3121 ff ff mov DWORD PTR _prevlen$[ebp], -1
\r
3122 0001a 89 45 f0 mov DWORD PTR _nextlen$[ebp], eax
\r
3124 ; 715 : int max_count = 7; /* max repeat count */
\r
3126 0001d 8d 4a 07 lea ecx, DWORD PTR [edx+7]
\r
3128 ; 716 : int min_count = 4; /* min repeat count */
\r
3130 00020 8d 72 04 lea esi, DWORD PTR [edx+4]
\r
3133 ; 718 : if (nextlen == 0) max_count = 138, min_count = 3;
\r
3135 00023 85 c0 test eax, eax
\r
3136 00025 75 08 jne SHORT $LN17@scan_tree
\r
3137 00027 b9 8a 00 00 00 mov ecx, 138 ; 0000008aH
\r
3138 0002c 8d 70 03 lea esi, DWORD PTR [eax+3]
\r
3141 ; 719 : tree[max_code+1].Len = (ush)0xffff; /* guard */
\r
3143 0002f b8 ff ff 00 00 mov eax, 65535 ; 0000ffffH
\r
3144 00034 66 89 44 9f 06 mov WORD PTR [edi+ebx*4+6], ax
\r
3147 ; 721 : for (n = 0; n <= max_code; n++) {
\r
3149 00039 85 db test ebx, ebx
\r
3150 0003b 0f 88 90 00 00
\r
3151 00 js $LN14@scan_tree
\r
3153 ; 719 : tree[max_code+1].Len = (ush)0xffff; /* guard */
\r
3155 00041 83 c7 06 add edi, 6
\r
3157 00045 89 7d fc mov DWORD PTR tv295[ebp], edi
\r
3158 00048 8b 7d 08 mov edi, DWORD PTR _s$[ebp]
\r
3159 0004b 89 5d f4 mov DWORD PTR tv84[ebp], ebx
\r
3160 0004e 8b 5d f0 mov ebx, DWORD PTR _nextlen$[ebp]
\r
3163 ; 722 : curlen = nextlen; nextlen = tree[n+1].Len;
\r
3165 00051 8b c3 mov eax, ebx
\r
3166 00053 8b 5d fc mov ebx, DWORD PTR tv295[ebp]
\r
3167 00056 0f b7 1b movzx ebx, WORD PTR [ebx]
\r
3169 ; 723 : if (++count < max_count && curlen == nextlen) {
\r
3172 0005a 3b d1 cmp edx, ecx
\r
3173 0005c 7d 04 jge SHORT $LN13@scan_tree
\r
3174 0005e 3b c3 cmp eax, ebx
\r
3175 00060 74 66 je SHORT $LN15@scan_tree
\r
3179 ; 725 : } else if (count < min_count) {
\r
3181 00062 3b d6 cmp edx, esi
\r
3182 00064 7d 0a jge SHORT $LN11@scan_tree
\r
3184 ; 726 : s->bl_tree[curlen].Freq += count;
\r
3186 00066 66 01 94 87 7c
\r
3187 0a 00 00 add WORD PTR [edi+eax*4+2684], dx
\r
3188 0006e eb 2f jmp SHORT $LN5@scan_tree
\r
3191 ; 727 : } else if (curlen != 0) {
\r
3193 00070 85 c0 test eax, eax
\r
3194 00072 74 16 je SHORT $LN9@scan_tree
\r
3196 ; 728 : if (curlen != prevlen) s->bl_tree[curlen].Freq++;
\r
3198 00074 3b 45 f8 cmp eax, DWORD PTR _prevlen$[ebp]
\r
3199 00077 74 08 je SHORT $LN23@scan_tree
\r
3200 00079 66 ff 84 87 7c
\r
3201 0a 00 00 inc WORD PTR [edi+eax*4+2684]
\r
3204 ; 729 : s->bl_tree[REP_3_6].Freq++;
\r
3206 00081 66 ff 87 bc 0a
\r
3207 00 00 inc WORD PTR [edi+2748]
\r
3208 00088 eb 15 jmp SHORT $LN5@scan_tree
\r
3211 ; 730 : } else if (count <= 10) {
\r
3213 0008a 83 fa 0a cmp edx, 10 ; 0000000aH
\r
3214 0008d 7f 09 jg SHORT $LN6@scan_tree
\r
3216 ; 731 : s->bl_tree[REPZ_3_10].Freq++;
\r
3218 0008f 66 ff 87 c0 0a
\r
3219 00 00 inc WORD PTR [edi+2752]
\r
3223 00096 eb 07 jmp SHORT $LN5@scan_tree
\r
3226 ; 733 : s->bl_tree[REPZ_11_138].Freq++;
\r
3228 00098 66 ff 87 c4 0a
\r
3229 00 00 inc WORD PTR [edi+2756]
\r
3233 ; 735 : count = 0; prevlen = curlen;
\r
3235 0009f 33 d2 xor edx, edx
\r
3236 000a1 89 45 f8 mov DWORD PTR _prevlen$[ebp], eax
\r
3238 ; 736 : if (nextlen == 0) {
\r
3240 000a4 85 db test ebx, ebx
\r
3241 000a6 75 0a jne SHORT $LN4@scan_tree
\r
3243 ; 737 : max_count = 138, min_count = 3;
\r
3245 000a8 b9 8a 00 00 00 mov ecx, 138 ; 0000008aH
\r
3246 000ad 8d 72 03 lea esi, DWORD PTR [edx+3]
\r
3247 000b0 eb 16 jmp SHORT $LN15@scan_tree
\r
3250 ; 738 : } else if (curlen == nextlen) {
\r
3252 000b2 3b c3 cmp eax, ebx
\r
3253 000b4 75 0a jne SHORT $LN2@scan_tree
\r
3255 ; 739 : max_count = 6, min_count = 3;
\r
3257 000b6 b9 06 00 00 00 mov ecx, 6
\r
3258 000bb 8d 71 fd lea esi, DWORD PTR [ecx-3]
\r
3262 000be eb 08 jmp SHORT $LN15@scan_tree
\r
3265 ; 741 : max_count = 7, min_count = 4;
\r
3267 000c0 b9 07 00 00 00 mov ecx, 7
\r
3268 000c5 8d 71 fd lea esi, DWORD PTR [ecx-3]
\r
3272 ; 721 : for (n = 0; n <= max_code; n++) {
\r
3274 000c8 83 45 fc 04 add DWORD PTR tv295[ebp], 4
\r
3275 000cc ff 4d f4 dec DWORD PTR tv84[ebp]
\r
3276 000cf 75 80 jne SHORT $LL16@scan_tree
\r
3286 000d4 8b e5 mov esp, ebp
\r
3290 ; Function compile flags: /Ogtp
\r
3292 ; COMDAT _gen_codes
\r
3294 _next_code$ = -32 ; size = 32
\r
3295 _gen_codes PROC ; COMDAT
\r
3297 ; _max_code$ = ebx
\r
3298 ; _bl_count$ = edx
\r
3303 00001 8b ec mov ebp, esp
\r
3304 00003 83 ec 20 sub esp, 32 ; 00000020H
\r
3307 ; 580 : ush next_code[MAX_BITS+1]; /* next code value for each bit length */
\r
3308 ; 581 : ush code = 0; /* running code value */
\r
3309 ; 582 : int bits; /* bit index */
\r
3310 ; 583 : int n; /* code index */
\r
3312 ; 585 : /* The distribution counts are first used to generate the code values
\r
3313 ; 586 : * without bit reversal.
\r
3315 ; 588 : for (bits = 1; bits <= MAX_BITS; bits++) {
\r
3317 00007 8d 75 e2 lea esi, DWORD PTR _next_code$[ebp+2]
\r
3318 0000a 33 c9 xor ecx, ecx
\r
3319 0000c b8 01 00 00 00 mov eax, 1
\r
3320 00011 2b d6 sub edx, esi
\r
3322 00013 8d 34 42 lea esi, DWORD PTR [edx+eax*2]
\r
3324 ; 589 : next_code[bits] = code = (code + bl_count[bits-1]) << 1;
\r
3326 00016 66 8b 74 35 e0 mov si, WORD PTR _next_code$[ebp+esi]
\r
3327 0001b 66 03 f1 add si, cx
\r
3328 0001e 66 03 f6 add si, si
\r
3329 00021 0f b7 ce movzx ecx, si
\r
3330 00024 66 89 4c 45 e0 mov WORD PTR _next_code$[ebp+eax*2], cx
\r
3332 0002a 83 f8 0f cmp eax, 15 ; 0000000fH
\r
3333 0002d 7e e4 jle SHORT $LL7@gen_codes
\r
3336 ; 591 : /* Check that the bit counts in bl_count are consistent. The last code
\r
3337 ; 592 : * must be all ones.
\r
3339 ; 594 : Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
\r
3340 ; 595 : "inconsistent bit counts");
\r
3341 ; 596 : Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
\r
3343 ; 598 : for (n = 0; n <= max_code; n++) {
\r
3345 0002f 33 f6 xor esi, esi
\r
3346 00031 85 db test ebx, ebx
\r
3347 00033 78 24 js SHORT $LN2@gen_codes
\r
3350 ; 599 : int len = tree[n].Len;
\r
3352 00035 0f b7 54 b7 02 movzx edx, WORD PTR [edi+esi*4+2]
\r
3354 ; 600 : if (len == 0) continue;
\r
3356 0003a 85 d2 test edx, edx
\r
3357 0003c 74 16 je SHORT $LN3@gen_codes
\r
3359 ; 601 : /* Now reverse the bits */
\r
3360 ; 602 : tree[n].Code = bi_reverse(next_code[len]++, len);
\r
3362 0003e 0f b7 44 55 e0 movzx eax, WORD PTR _next_code$[ebp+edx*2]
\r
3363 00043 8b c8 mov ecx, eax
\r
3365 00046 66 89 44 55 e0 mov WORD PTR _next_code$[ebp+edx*2], ax
\r
3366 0004b e8 00 00 00 00 call _bi_reverse
\r
3367 00050 66 89 04 b7 mov WORD PTR [edi+esi*4], ax
\r
3371 ; 591 : /* Check that the bit counts in bl_count are consistent. The last code
\r
3372 ; 592 : * must be all ones.
\r
3374 ; 594 : Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
\r
3375 ; 595 : "inconsistent bit counts");
\r
3376 ; 596 : Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
\r
3378 ; 598 : for (n = 0; n <= max_code; n++) {
\r
3381 00055 3b f3 cmp esi, ebx
\r
3382 00057 7e dc jle SHORT $LL14@gen_codes
\r
3387 ; 604 : Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
\r
3388 ; 605 : n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
\r
3392 0005a 8b e5 mov esp, ebp
\r
3396 ; Function compile flags: /Ogtp
\r
3398 ; COMDAT _gen_bitlen
\r
3400 _tree$ = -40 ; size = 4
\r
3401 tv643 = -36 ; size = 4
\r
3402 _stree$ = -36 ; size = 4
\r
3403 tv671 = -32 ; size = 4
\r
3404 _extra$ = -32 ; size = 4
\r
3405 _base$ = -28 ; size = 4
\r
3406 _max_code$ = -24 ; size = 4
\r
3407 tv709 = -20 ; size = 4
\r
3408 tv277 = -20 ; size = 4
\r
3409 _h$ = -16 ; size = 4
\r
3410 tv597 = -12 ; size = 4
\r
3411 _n$ = -12 ; size = 4
\r
3412 _overflow$ = -8 ; size = 4
\r
3413 _max_length$ = -4 ; size = 4
\r
3414 _gen_bitlen PROC ; COMDAT
\r
3421 00001 8b ec mov ebp, esp
\r
3422 00003 83 ec 28 sub esp, 40 ; 00000028H
\r
3424 ; 492 : ct_data *tree = desc->dyn_tree;
\r
3425 ; 493 : int max_code = desc->max_code;
\r
3427 00006 8b 51 04 mov edx, DWORD PTR [ecx+4]
\r
3429 0000a 8b 19 mov ebx, DWORD PTR [ecx]
\r
3431 ; 494 : const ct_data *stree = desc->stat_desc->static_tree;
\r
3433 0000c 8b 49 08 mov ecx, DWORD PTR [ecx+8]
\r
3434 0000f 89 55 e8 mov DWORD PTR _max_code$[ebp], edx
\r
3435 00012 8b 11 mov edx, DWORD PTR [ecx]
\r
3436 00014 89 55 dc mov DWORD PTR _stree$[ebp], edx
\r
3438 ; 495 : const intf *extra = desc->stat_desc->extra_bits;
\r
3440 00017 8b 51 04 mov edx, DWORD PTR [ecx+4]
\r
3442 0001b 89 55 e0 mov DWORD PTR _extra$[ebp], edx
\r
3444 ; 496 : int base = desc->stat_desc->extra_base;
\r
3446 0001e 8b 51 08 mov edx, DWORD PTR [ecx+8]
\r
3449 ; 497 : int max_length = desc->stat_desc->max_length;
\r
3451 00022 8b 79 10 mov edi, DWORD PTR [ecx+16]
\r
3453 ; 498 : int h; /* heap index */
\r
3454 ; 499 : int n, m; /* iterate over the tree elements */
\r
3455 ; 500 : int bits; /* bit length */
\r
3456 ; 501 : int xbits; /* extra bits */
\r
3457 ; 502 : ush f; /* frequency */
\r
3458 ; 503 : int overflow = 0; /* number of elements with bit length too large */
\r
3460 ; 505 : for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
\r
3462 00025 33 c9 xor ecx, ecx
\r
3463 00027 89 55 e4 mov DWORD PTR _base$[ebp], edx
\r
3464 0002a 0f b7 d1 movzx edx, cx
\r
3465 0002d 8b ca mov ecx, edx
\r
3466 0002f c1 e2 10 shl edx, 16 ; 00000010H
\r
3467 00032 0b ca or ecx, edx
\r
3468 00034 89 88 3c 0b 00
\r
3469 00 mov DWORD PTR [eax+2876], ecx
\r
3470 0003a 89 88 40 0b 00
\r
3471 00 mov DWORD PTR [eax+2880], ecx
\r
3472 00040 89 88 44 0b 00
\r
3473 00 mov DWORD PTR [eax+2884], ecx
\r
3474 00046 89 88 48 0b 00
\r
3475 00 mov DWORD PTR [eax+2888], ecx
\r
3476 0004c 89 88 4c 0b 00
\r
3477 00 mov DWORD PTR [eax+2892], ecx
\r
3478 00052 89 88 50 0b 00
\r
3479 00 mov DWORD PTR [eax+2896], ecx
\r
3480 00058 89 88 54 0b 00
\r
3481 00 mov DWORD PTR [eax+2900], ecx
\r
3482 0005e 89 88 58 0b 00
\r
3483 00 mov DWORD PTR [eax+2904], ecx
\r
3486 ; 507 : /* In a first pass, compute the optimal bit lengths (which may
\r
3487 ; 508 : * overflow in the case of the bit length tree).
\r
3489 ; 510 : tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
\r
3491 00064 8b 88 54 14 00
\r
3492 00 mov ecx, DWORD PTR [eax+5204]
\r
3493 0006a 8b 94 88 5c 0b
\r
3494 00 00 mov edx, DWORD PTR [eax+ecx*4+2908]
\r
3495 00071 33 c9 xor ecx, ecx
\r
3496 00073 66 89 4c 93 02 mov WORD PTR [ebx+edx*4+2], cx
\r
3499 ; 512 : for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
\r
3501 00078 8b 88 54 14 00
\r
3502 00 mov ecx, DWORD PTR [eax+5204]
\r
3503 0007e 33 f6 xor esi, esi
\r
3505 00081 89 5d d8 mov DWORD PTR _tree$[ebp], ebx
\r
3506 00084 89 7d fc mov DWORD PTR _max_length$[ebp], edi
\r
3507 00087 89 75 f8 mov DWORD PTR _overflow$[ebp], esi
\r
3508 0008a 81 f9 3d 02 00
\r
3509 00 cmp ecx, 573 ; 0000023dH
\r
3510 00090 0f 8d 5a 01 00
\r
3511 00 jge $LN5@gen_bitlen
\r
3514 ; 507 : /* In a first pass, compute the optimal bit lengths (which may
\r
3515 ; 508 : * overflow in the case of the bit length tree).
\r
3517 ; 510 : tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
\r
3519 00096 8d 94 88 5c 0b
\r
3520 00 00 lea edx, DWORD PTR [eax+ecx*4+2908]
\r
3521 0009d 89 55 f4 mov DWORD PTR tv597[ebp], edx
\r
3522 000a0 ba 3d 02 00 00 mov edx, 573 ; 0000023dH
\r
3523 000a5 2b d1 sub edx, ecx
\r
3526 ; 512 : for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
\r
3528 000a7 03 ca add ecx, edx
\r
3529 000a9 89 55 ec mov DWORD PTR tv277[ebp], edx
\r
3530 000ac 89 4d f0 mov DWORD PTR _h$[ebp], ecx
\r
3534 ; 513 : n = s->heap[h];
\r
3536 000b0 8b 4d f4 mov ecx, DWORD PTR tv597[ebp]
\r
3537 000b3 8b 11 mov edx, DWORD PTR [ecx]
\r
3539 ; 514 : bits = tree[tree[n].Dad].Len + 1;
\r
3541 000b5 0f b7 4c 93 02 movzx ecx, WORD PTR [ebx+edx*4+2]
\r
3542 000ba 0f b7 4c 8b 02 movzx ecx, WORD PTR [ebx+ecx*4+2]
\r
3545 ; 515 : if (bits > max_length) bits = max_length, overflow++;
\r
3547 000c0 3b cf cmp ecx, edi
\r
3548 000c2 7e 06 jle SHORT $LN17@gen_bitlen
\r
3550 000c5 8b cf mov ecx, edi
\r
3551 000c7 89 75 f8 mov DWORD PTR _overflow$[ebp], esi
\r
3554 ; 516 : tree[n].Len = (ush)bits;
\r
3556 000ca 66 89 4c 93 02 mov WORD PTR [ebx+edx*4+2], cx
\r
3558 ; 517 : /* We overwrite tree[n].Dad which is no longer needed */
\r
3560 ; 519 : if (n > max_code) continue; /* not a leaf node */
\r
3562 000cf 3b 55 e8 cmp edx, DWORD PTR _max_code$[ebp]
\r
3563 000d2 7f 47 jg SHORT $LN19@gen_bitlen
\r
3566 ; 521 : s->bl_count[bits]++;
\r
3567 ; 522 : xbits = 0;
\r
3568 ; 523 : if (n >= base) xbits = extra[n-base];
\r
3570 000d4 8b 7d e4 mov edi, DWORD PTR _base$[ebp]
\r
3571 000d7 66 ff 84 48 3c
\r
3572 0b 00 00 inc WORD PTR [eax+ecx*2+2876]
\r
3573 000df 33 f6 xor esi, esi
\r
3574 000e1 3b d7 cmp edx, edi
\r
3575 000e3 7c 0a jl SHORT $LN15@gen_bitlen
\r
3576 000e5 8b f2 mov esi, edx
\r
3577 000e7 2b f7 sub esi, edi
\r
3578 000e9 8b 7d e0 mov edi, DWORD PTR _extra$[ebp]
\r
3579 000ec 8b 34 b7 mov esi, DWORD PTR [edi+esi*4]
\r
3582 ; 524 : f = tree[n].Freq;
\r
3584 000ef 0f b7 3c 93 movzx edi, WORD PTR [ebx+edx*4]
\r
3586 ; 525 : s->opt_len += (ulg)f * (bits + xbits);
\r
3588 000f3 03 ce add ecx, esi
\r
3589 000f5 0f af cf imul ecx, edi
\r
3590 000f8 01 88 a8 16 00
\r
3591 00 add DWORD PTR [eax+5800], ecx
\r
3593 ; 526 : if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
\r
3595 000fe 8b 4d dc mov ecx, DWORD PTR _stree$[ebp]
\r
3596 00101 85 c9 test ecx, ecx
\r
3597 00103 74 10 je SHORT $LN38@gen_bitlen
\r
3598 00105 0f b7 54 91 02 movzx edx, WORD PTR [ecx+edx*4+2]
\r
3599 0010a 03 d6 add edx, esi
\r
3600 0010c 0f af d7 imul edx, edi
\r
3601 0010f 01 90 ac 16 00
\r
3602 00 add DWORD PTR [eax+5804], edx
\r
3604 00115 8b 7d fc mov edi, DWORD PTR _max_length$[ebp]
\r
3605 00118 8b 75 f8 mov esi, DWORD PTR _overflow$[ebp]
\r
3609 ; 512 : for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
\r
3611 0011b 83 45 f4 04 add DWORD PTR tv597[ebp], 4
\r
3612 0011f ff 4d ec dec DWORD PTR tv277[ebp]
\r
3613 00122 75 8c jne SHORT $LL41@gen_bitlen
\r
3616 ; 528 : if (overflow == 0) return;
\r
3618 00124 85 f6 test esi, esi
\r
3619 00126 0f 84 c4 00 00
\r
3620 00 je $LN5@gen_bitlen
\r
3621 0012c 8d bc 78 3c 0b
\r
3622 00 00 lea edi, DWORD PTR [eax+edi*2+2876]
\r
3626 ; 530 : Trace((stderr,"\nbit length overflow\n"));
\r
3627 ; 531 : /* This happens for example on obj2 and pic of the Calgary corpus */
\r
3629 ; 533 : /* Find the first bit length which could increase: */
\r
3631 ; 535 : bits = max_length-1;
\r
3633 00133 8b 4d fc mov ecx, DWORD PTR _max_length$[ebp]
\r
3636 ; 536 : while (s->bl_count[bits] == 0) bits--;
\r
3638 00137 66 83 bc 48 3c
\r
3639 0b 00 00 00 cmp WORD PTR [eax+ecx*2+2876], 0
\r
3640 00140 8d 94 48 3c 0b
\r
3641 00 00 lea edx, DWORD PTR [eax+ecx*2+2876]
\r
3642 00147 75 11 jne SHORT $LN8@gen_bitlen
\r
3643 00149 8d a4 24 00 00
\r
3646 00150 83 ea 02 sub edx, 2
\r
3648 00154 66 83 3a 00 cmp WORD PTR [edx], 0
\r
3649 00158 74 f6 je SHORT $LL9@gen_bitlen
\r
3652 ; 537 : s->bl_count[bits]--; /* move one leaf down the tree */
\r
3653 ; 538 : s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
\r
3655 0015a 66 83 84 48 3e
\r
3656 0b 00 00 02 add WORD PTR [eax+ecx*2+2878], 2
\r
3657 00163 ba ff ff 00 00 mov edx, 65535 ; 0000ffffH
\r
3658 00168 66 01 94 48 3c
\r
3659 0b 00 00 add WORD PTR [eax+ecx*2+2876], dx
\r
3661 ; 539 : s->bl_count[max_length]--;
\r
3663 00170 8b ca mov ecx, edx
\r
3664 00172 66 01 0f add WORD PTR [edi], cx
\r
3666 ; 540 : /* The brother of the overflow item also moves one step up,
\r
3667 ; 541 : * but this does not affect bl_count[max_length]
\r
3669 ; 543 : overflow -= 2;
\r
3671 00175 83 ee 02 sub esi, 2
\r
3673 ; 544 : } while (overflow > 0);
\r
3675 00178 85 f6 test esi, esi
\r
3676 0017a 7f b7 jg SHORT $LL12@gen_bitlen
\r
3679 ; 546 : /* Now recompute all bit lengths, scanning in increasing frequency.
\r
3680 ; 547 : * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
\r
3681 ; 548 : * lengths instead of fixing only the wrong ones. This idea is taken
\r
3682 ; 549 : * from 'ar' written by Haruhiko Okumura.)
\r
3684 ; 551 : for (bits = max_length; bits != 0; bits--) {
\r
3686 0017c 8b 55 fc mov edx, DWORD PTR _max_length$[ebp]
\r
3687 0017f 85 d2 test edx, edx
\r
3688 00181 74 6d je SHORT $LN5@gen_bitlen
\r
3689 00183 89 7d ec mov DWORD PTR tv709[ebp], edi
\r
3692 ; 552 : n = s->bl_count[bits];
\r
3694 00186 0f b7 3f movzx edi, WORD PTR [edi]
\r
3695 00189 89 7d f4 mov DWORD PTR _n$[ebp], edi
\r
3697 ; 553 : while (n != 0) {
\r
3699 0018c 85 ff test edi, edi
\r
3700 0018e 74 54 je SHORT $LN6@gen_bitlen
\r
3702 ; 552 : n = s->bl_count[bits];
\r
3704 00190 8b 4d f0 mov ecx, DWORD PTR _h$[ebp]
\r
3705 00193 8d b4 88 5c 0b
\r
3706 00 00 lea esi, DWORD PTR [eax+ecx*4+2908]
\r
3707 0019a 8d 9b 00 00 00
\r
3711 ; 554 : m = s->heap[--h];
\r
3713 001a0 8b 4e fc mov ecx, DWORD PTR [esi-4]
\r
3714 001a3 ff 4d f0 dec DWORD PTR _h$[ebp]
\r
3715 001a6 83 ee 04 sub esi, 4
\r
3716 001a9 89 75 e0 mov DWORD PTR tv671[ebp], esi
\r
3718 ; 555 : if (m > max_code) continue;
\r
3720 001ac 3b 4d e8 cmp ecx, DWORD PTR _max_code$[ebp]
\r
3721 001af 7f 2f jg SHORT $LN39@gen_bitlen
\r
3723 ; 556 : if ((unsigned) tree[m].Len != (unsigned) bits) {
\r
3725 001b1 0f b7 7c 8b 02 movzx edi, WORD PTR [ebx+ecx*4+2]
\r
3726 001b6 8d 74 8b 02 lea esi, DWORD PTR [ebx+ecx*4+2]
\r
3727 001ba 3b fa cmp edi, edx
\r
3728 001bc 74 19 je SHORT $LN1@gen_bitlen
\r
3730 ; 557 : Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
\r
3731 ; 558 : s->opt_len += ((long)bits - (long)tree[m].Len)
\r
3732 ; 559 : *(long)tree[m].Freq;
\r
3734 001be 8b da mov ebx, edx
\r
3735 001c0 2b df sub ebx, edi
\r
3736 001c2 8b fb mov edi, ebx
\r
3737 001c4 8b 5d d8 mov ebx, DWORD PTR _tree$[ebp]
\r
3738 001c7 0f b7 0c 8b movzx ecx, WORD PTR [ebx+ecx*4]
\r
3739 001cb 0f af f9 imul edi, ecx
\r
3740 001ce 01 b8 a8 16 00
\r
3741 00 add DWORD PTR [eax+5800], edi
\r
3743 ; 560 : tree[m].Len = (ush)bits;
\r
3745 001d4 66 89 16 mov WORD PTR [esi], dx
\r
3751 001d7 ff 4d f4 dec DWORD PTR _n$[ebp]
\r
3752 001da 8b 7d f4 mov edi, DWORD PTR _n$[ebp]
\r
3753 001dd 8b 75 e0 mov esi, DWORD PTR tv671[ebp]
\r
3756 ; 553 : while (n != 0) {
\r
3758 001e0 85 ff test edi, edi
\r
3759 001e2 75 bc jne SHORT $LL4@gen_bitlen
\r
3763 ; 546 : /* Now recompute all bit lengths, scanning in increasing frequency.
\r
3764 ; 547 : * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
\r
3765 ; 548 : * lengths instead of fixing only the wrong ones. This idea is taken
\r
3766 ; 549 : * from 'ar' written by Haruhiko Okumura.)
\r
3768 ; 551 : for (bits = max_length; bits != 0; bits--) {
\r
3770 001e4 8b 7d ec mov edi, DWORD PTR tv709[ebp]
\r
3771 001e7 83 ef 02 sub edi, 2
\r
3773 001eb 89 7d ec mov DWORD PTR tv709[ebp], edi
\r
3774 001ee 75 96 jne SHORT $LL7@gen_bitlen
\r
3784 001f3 8b e5 mov esp, ebp
\r
3788 ; Function compile flags: /Ogtp
\r
3790 ; COMDAT _pqdownheap
\r
3792 _v$ = -4 ; size = 4
\r
3793 _k$ = 8 ; size = 4
\r
3794 _pqdownheap PROC ; COMDAT
\r
3801 00001 8b ec mov ebp, esp
\r
3804 ; 458 : int v = s->heap[k];
\r
3805 ; 459 : int j = k << 1; /* left son of k */
\r
3806 ; 460 : while (j <= s->heap_len) {
\r
3808 00004 8b 90 50 14 00
\r
3809 00 mov edx, DWORD PTR [eax+5200]
\r
3812 0000c 8b 75 08 mov esi, DWORD PTR _k$[ebp]
\r
3813 0000f 8b 9c b0 5c 0b
\r
3814 00 00 mov ebx, DWORD PTR [eax+esi*4+2908]
\r
3815 00016 8d 0c 36 lea ecx, DWORD PTR [esi+esi]
\r
3816 00019 89 5d fc mov DWORD PTR _v$[ebp], ebx
\r
3817 0001c 3b ca cmp ecx, edx
\r
3818 0001e 0f 8f a1 00 00
\r
3819 00 jg $LN14@pqdownheap
\r
3822 ; 461 : /* Set j to the smallest of the two sons: */
\r
3823 ; 462 : if (j < s->heap_len &&
\r
3824 ; 463 : smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
\r
3826 00024 7d 35 jge SHORT $LN16@pqdownheap
\r
3827 00026 8b b4 88 60 0b
\r
3828 00 00 mov esi, DWORD PTR [eax+ecx*4+2912]
\r
3829 0002d 8b 9c 88 5c 0b
\r
3830 00 00 mov ebx, DWORD PTR [eax+ecx*4+2908]
\r
3831 00034 0f b7 14 b7 movzx edx, WORD PTR [edi+esi*4]
\r
3832 00038 0f b7 1c 9f movzx ebx, WORD PTR [edi+ebx*4]
\r
3833 0003c 66 3b d3 cmp dx, bx
\r
3834 0003f 72 19 jb SHORT $LN3@pqdownheap
\r
3835 00041 75 18 jne SHORT $LN16@pqdownheap
\r
3836 00043 8a 94 06 58 14
\r
3837 00 00 mov dl, BYTE PTR [esi+eax+5208]
\r
3838 0004a 8b b4 88 5c 0b
\r
3839 00 00 mov esi, DWORD PTR [eax+ecx*4+2908]
\r
3840 00051 3a 94 06 58 14
\r
3841 00 00 cmp dl, BYTE PTR [esi+eax+5208]
\r
3842 00058 77 01 ja SHORT $LN16@pqdownheap
\r
3851 ; 466 : /* Exit if v is smaller than both sons */
\r
3852 ; 467 : if (smaller(tree, v, s->heap[j], s->depth)) break;
\r
3854 0005b 8b b4 88 5c 0b
\r
3855 00 00 mov esi, DWORD PTR [eax+ecx*4+2908]
\r
3856 00062 8b 55 fc mov edx, DWORD PTR _v$[ebp]
\r
3857 00065 0f b7 14 97 movzx edx, WORD PTR [edi+edx*4]
\r
3858 00069 0f b7 1c b7 movzx ebx, WORD PTR [edi+esi*4]
\r
3859 0006d 66 3b d3 cmp dx, bx
\r
3860 00070 72 40 jb SHORT $LN13@pqdownheap
\r
3861 00072 75 13 jne SHORT $LN15@pqdownheap
\r
3862 00074 8b 55 fc mov edx, DWORD PTR _v$[ebp]
\r
3863 00077 8a 9c 02 58 14
\r
3864 00 00 mov bl, BYTE PTR [edx+eax+5208]
\r
3865 0007e 3a 9c 06 58 14
\r
3866 00 00 cmp bl, BYTE PTR [esi+eax+5208]
\r
3867 00085 76 2e jbe SHORT $LN12@pqdownheap
\r
3871 ; 469 : /* Exchange v with the smallest son */
\r
3872 ; 470 : s->heap[k] = s->heap[j]; k = j;
\r
3874 00087 8b 55 08 mov edx, DWORD PTR _k$[ebp]
\r
3875 0008a 89 b4 90 5c 0b
\r
3876 00 00 mov DWORD PTR [eax+edx*4+2908], esi
\r
3877 00091 8b 90 50 14 00
\r
3878 00 mov edx, DWORD PTR [eax+5200]
\r
3879 00097 8b f1 mov esi, ecx
\r
3882 ; 472 : /* And continue down the tree, setting j to the left son of k */
\r
3885 00099 03 c9 add ecx, ecx
\r
3886 0009b 89 75 08 mov DWORD PTR _k$[ebp], esi
\r
3887 0009e 3b ca cmp ecx, edx
\r
3888 000a0 7e 82 jle SHORT $LN17@pqdownheap
\r
3891 ; 475 : s->heap[k] = v;
\r
3893 000a2 8b 4d fc mov ecx, DWORD PTR _v$[ebp]
\r
3894 000a5 89 8c b0 5c 0b
\r
3895 00 00 mov DWORD PTR [eax+esi*4+2908], ecx
\r
3901 000ae 8b e5 mov esp, ebp
\r
3907 ; 475 : s->heap[k] = v;
\r
3909 000b2 8b 55 fc mov edx, DWORD PTR _v$[ebp]
\r
3911 000b5 8b 4d 08 mov ecx, DWORD PTR _k$[ebp]
\r
3913 000b9 89 94 88 5c 0b
\r
3914 00 00 mov DWORD PTR [eax+ecx*4+2908], edx
\r
3919 000c1 8b e5 mov esp, ebp
\r
3925 ; 475 : s->heap[k] = v;
\r
3927 000c5 89 9c b0 5c 0b
\r
3928 00 00 mov DWORD PTR [eax+esi*4+2908], ebx
\r
3934 000ce 8b e5 mov esp, ebp
\r
3938 ; Function compile flags: /Ogtp
\r
3940 ; COMDAT _init_block
\r
3942 _init_block PROC ; COMDAT
\r
3945 ; 412 : int n; /* iterates over tree elements */
\r
3947 ; 414 : /* Initialize the trees. */
\r
3948 ; 415 : for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
\r
3950 00000 8d 82 94 00 00
\r
3951 00 lea eax, DWORD PTR [edx+148]
\r
3952 00006 b9 1e 01 00 00 mov ecx, 286 ; 0000011eH
\r
3954 0000c 8d 64 24 00 npad 4
\r
3956 00010 33 f6 xor esi, esi
\r
3957 00012 66 89 30 mov WORD PTR [eax], si
\r
3958 00015 83 c0 04 add eax, 4
\r
3960 00019 75 f5 jne SHORT $LL9@init_block
\r
3962 ; 416 : for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
\r
3964 0001b 8d 82 88 09 00
\r
3965 00 lea eax, DWORD PTR [edx+2440]
\r
3966 00021 b9 1e 00 00 00 mov ecx, 30 ; 0000001eH
\r
3968 00026 33 f6 xor esi, esi
\r
3969 00028 66 89 30 mov WORD PTR [eax], si
\r
3970 0002b 83 c0 04 add eax, 4
\r
3972 0002f 75 f5 jne SHORT $LL6@init_block
\r
3974 ; 417 : for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
\r
3976 00031 8d 82 7c 0a 00
\r
3977 00 lea eax, DWORD PTR [edx+2684]
\r
3978 00037 b9 13 00 00 00 mov ecx, 19 ; 00000013H
\r
3979 0003c 8d 64 24 00 npad 4
\r
3981 00040 33 f6 xor esi, esi
\r
3982 00042 66 89 30 mov WORD PTR [eax], si
\r
3983 00045 83 c0 04 add eax, 4
\r
3985 00049 75 f5 jne SHORT $LL3@init_block
\r
3988 ; 419 : s->dyn_ltree[END_BLOCK].Freq = 1;
\r
3990 0004b b8 01 00 00 00 mov eax, 1
\r
3991 00050 66 89 82 94 04
\r
3992 00 00 mov WORD PTR [edx+1172], ax
\r
3994 ; 420 : s->opt_len = s->static_len = 0L;
\r
3996 00057 33 c0 xor eax, eax
\r
3997 00059 89 82 ac 16 00
\r
3998 00 mov DWORD PTR [edx+5804], eax
\r
3999 0005f 89 82 a8 16 00
\r
4000 00 mov DWORD PTR [edx+5800], eax
\r
4002 ; 421 : s->last_lit = s->matches = 0;
\r
4004 00065 89 82 b0 16 00
\r
4005 00 mov DWORD PTR [edx+5808], eax
\r
4006 0006b 89 82 a0 16 00
\r
4007 00 mov DWORD PTR [edx+5792], eax
\r
4014 ; Function compile flags: /Ogtp
\r
4016 ; COMDAT _tr_static_init
\r
4018 _tr_static_init PROC ; COMDAT
\r
4020 ; 236 : #if defined(GEN_TREES_H) || !defined(STDC)
\r
4021 ; 237 : static int static_init_done = 0;
\r
4022 ; 238 : int n; /* iterates over tree elements */
\r
4023 ; 239 : int bits; /* bit counter */
\r
4024 ; 240 : int length; /* length value */
\r
4025 ; 241 : int code; /* code value */
\r
4026 ; 242 : int dist; /* distance index */
\r
4027 ; 243 : ush bl_count[MAX_BITS+1];
\r
4028 ; 244 : /* number of codes at each bit length for an optimal tree */
\r
4030 ; 246 : if (static_init_done) return;
\r
4032 ; 248 : /* For some embedded targets, global variables are not initialized: */
\r
4033 ; 249 : #ifdef NO_INIT_GLOBAL_POINTERS
\r
4034 ; 250 : static_l_desc.static_tree = static_ltree;
\r
4035 ; 251 : static_l_desc.extra_bits = extra_lbits;
\r
4036 ; 252 : static_d_desc.static_tree = static_dtree;
\r
4037 ; 253 : static_d_desc.extra_bits = extra_dbits;
\r
4038 ; 254 : static_bl_desc.extra_bits = extra_blbits;
\r
4041 ; 257 : /* Initialize the mapping length (0..255) -> length code (0..28) */
\r
4042 ; 258 : length = 0;
\r
4043 ; 259 : for (code = 0; code < LENGTH_CODES-1; code++) {
\r
4044 ; 260 : base_length[code] = length;
\r
4045 ; 261 : for (n = 0; n < (1<<extra_lbits[code]); n++) {
\r
4046 ; 262 : _length_code[length++] = (uch)code;
\r
4049 ; 265 : Assert (length == 256, "tr_static_init: length != 256");
\r
4050 ; 266 : /* Note that the length 255 (match length 258) can be represented
\r
4051 ; 267 : * in two different ways: code 284 + 5 bits or code 285, so we
\r
4052 ; 268 : * overwrite length_code[255] to use the best encoding:
\r
4054 ; 270 : _length_code[length-1] = (uch)code;
\r
4056 ; 272 : /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
\r
4058 ; 274 : for (code = 0 ; code < 16; code++) {
\r
4059 ; 275 : base_dist[code] = dist;
\r
4060 ; 276 : for (n = 0; n < (1<<extra_dbits[code]); n++) {
\r
4061 ; 277 : _dist_code[dist++] = (uch)code;
\r
4064 ; 280 : Assert (dist == 256, "tr_static_init: dist != 256");
\r
4065 ; 281 : dist >>= 7; /* from now on, all distances are divided by 128 */
\r
4066 ; 282 : for ( ; code < D_CODES; code++) {
\r
4067 ; 283 : base_dist[code] = dist << 7;
\r
4068 ; 284 : for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
\r
4069 ; 285 : _dist_code[256 + dist++] = (uch)code;
\r
4072 ; 288 : Assert (dist == 256, "tr_static_init: 256+dist != 512");
\r
4074 ; 290 : /* Construct the codes of the static literal tree */
\r
4075 ; 291 : for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
\r
4077 ; 293 : while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
\r
4078 ; 294 : while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
\r
4079 ; 295 : while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
\r
4080 ; 296 : while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
\r
4081 ; 297 : /* Codes 286 and 287 do not exist, but we must include them in the
\r
4082 ; 298 : * tree construction to get a canonical Huffman tree (longest code
\r
4083 ; 299 : * all ones)
\r
4085 ; 301 : gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
\r
4087 ; 303 : /* The static distance tree is trivial: */
\r
4088 ; 304 : for (n = 0; n < D_CODES; n++) {
\r
4089 ; 305 : static_dtree[n].Len = 5;
\r
4090 ; 306 : static_dtree[n].Code = bi_reverse((unsigned)n, 5);
\r
4092 ; 308 : static_init_done = 1;
\r
4094 ; 310 : # ifdef GEN_TREES_H
\r
4095 ; 311 : gen_trees_header();
\r
4097 ; 313 : #endif /* defined(GEN_TREES_H) || !defined(STDC) */
\r
4101 _tr_static_init ENDP
\r
4102 ; Function compile flags: /Ogtp
\r
4103 ; COMDAT _copy_block
\r
4105 _copy_block PROC ; COMDAT
\r
4115 00003 8b d9 mov ebx, ecx
\r
4116 00005 8b fa mov edi, edx
\r
4118 ; 1209 : bi_windup(s); /* align on byte boundary */
\r
4120 00007 e8 00 00 00 00 call _bi_windup
\r
4123 ; 1211 : if (header) {
\r
4124 ; 1212 : put_short(s, (ush)len);
\r
4126 0000c 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
4127 0000f 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
4128 00012 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
4129 00015 ff 40 14 inc DWORD PTR [eax+20]
\r
4130 00018 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
4131 0001b 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
4132 0001e 8b cb mov ecx, ebx
\r
4133 00020 c1 e9 08 shr ecx, 8
\r
4134 00023 88 0c 16 mov BYTE PTR [esi+edx], cl
\r
4135 00026 ff 40 14 inc DWORD PTR [eax+20]
\r
4136 00029 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
4138 ; 1213 : put_short(s, (ush)~len);
\r
4140 0002c 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
4141 0002f 8a cb mov cl, bl
\r
4142 00031 f6 d1 not cl
\r
4143 00033 88 0c 16 mov BYTE PTR [esi+edx], cl
\r
4144 00036 ff 40 14 inc DWORD PTR [eax+20]
\r
4145 00039 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
4146 0003c 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
4147 0003f 8b cb mov ecx, ebx
\r
4148 00041 f7 d1 not ecx
\r
4149 00043 c1 e9 08 shr ecx, 8
\r
4150 00046 88 0c 16 mov BYTE PTR [esi+edx], cl
\r
4151 00049 ff 40 14 inc DWORD PTR [eax+20]
\r
4152 0004c 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
4154 ; 1214 : #ifdef DEBUG
\r
4155 ; 1215 : s->bits_sent += 2*16;
\r
4158 ; 1218 : #ifdef DEBUG
\r
4159 ; 1219 : s->bits_sent += (ulg)len<<3;
\r
4161 ; 1221 : while (len--) {
\r
4163 0004f 85 db test ebx, ebx
\r
4164 00051 74 12 je SHORT $LN7@copy_block
\r
4167 ; 1222 : put_byte(s, *buf++);
\r
4169 00053 8a 17 mov dl, BYTE PTR [edi]
\r
4170 00055 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
4171 00058 88 14 0e mov BYTE PTR [esi+ecx], dl
\r
4172 0005b ff 40 14 inc DWORD PTR [eax+20]
\r
4173 0005e 8b 70 14 mov esi, DWORD PTR [eax+20]
\r
4176 00063 75 ee jne SHORT $LL2@copy_block
\r
4188 PUBLIC __tr_stored_block
\r
4189 ; Function compile flags: /Ogtp
\r
4190 ; COMDAT __tr_stored_block
\r
4192 _buf$ = 8 ; size = 4
\r
4193 _stored_len$ = 12 ; size = 4
\r
4194 __tr_stored_block PROC ; COMDAT
\r
4201 00001 8b ec mov ebp, esp
\r
4203 00004 8b f1 mov esi, ecx
\r
4205 ; 871 : send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
\r
4207 00006 8b 88 bc 16 00
\r
4208 00 mov ecx, DWORD PTR [eax+5820]
\r
4209 0000c 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
4210 0000f 7e 5f jle SHORT $LN2@tr_stored_
\r
4211 00011 66 8b d6 mov dx, si
\r
4212 00014 66 d3 e2 shl dx, cl
\r
4213 00017 8b 48 08 mov ecx, DWORD PTR [eax+8]
\r
4215 0001b 66 09 90 b8 16
\r
4216 00 00 or WORD PTR [eax+5816], dx
\r
4217 00022 0f b6 98 b8 16
\r
4218 00 00 movzx ebx, BYTE PTR [eax+5816]
\r
4219 00029 8b 50 14 mov edx, DWORD PTR [eax+20]
\r
4220 0002c 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
4221 0002f ff 40 14 inc DWORD PTR [eax+20]
\r
4222 00032 0f b6 98 b9 16
\r
4223 00 00 movzx ebx, BYTE PTR [eax+5817]
\r
4224 00039 8b 48 14 mov ecx, DWORD PTR [eax+20]
\r
4225 0003c 8b 50 08 mov edx, DWORD PTR [eax+8]
\r
4226 0003f 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
4227 00042 8b 90 bc 16 00
\r
4228 00 mov edx, DWORD PTR [eax+5820]
\r
4229 00048 ff 40 14 inc DWORD PTR [eax+20]
\r
4230 0004b b1 10 mov cl, 16 ; 00000010H
\r
4231 0004d 2a ca sub cl, dl
\r
4232 0004f 66 d3 ee shr si, cl
\r
4234 ; 872 : #ifdef DEBUG
\r
4235 ; 873 : s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
\r
4236 ; 874 : s->compressed_len += (stored_len + 4) << 3;
\r
4238 ; 876 : copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
\r
4240 00052 8b 4d 0c mov ecx, DWORD PTR _stored_len$[ebp]
\r
4241 00055 83 c2 f3 add edx, -13 ; fffffff3H
\r
4243 00059 66 89 b0 b8 16
\r
4244 00 00 mov WORD PTR [eax+5816], si
\r
4245 00060 89 90 bc 16 00
\r
4246 00 mov DWORD PTR [eax+5820], edx
\r
4247 00066 8b 55 08 mov edx, DWORD PTR _buf$[ebp]
\r
4254 ; 872 : #ifdef DEBUG
\r
4255 ; 873 : s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
\r
4256 ; 874 : s->compressed_len += (stored_len + 4) << 3;
\r
4258 ; 876 : copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
\r
4260 0006b e9 00 00 00 00 jmp _copy_block
\r
4262 00070 8b 55 08 mov edx, DWORD PTR _buf$[ebp]
\r
4263 00073 66 d3 e6 shl si, cl
\r
4264 00076 66 09 b0 b8 16
\r
4265 00 00 or WORD PTR [eax+5816], si
\r
4266 0007d 83 c1 03 add ecx, 3
\r
4267 00080 89 88 bc 16 00
\r
4268 00 mov DWORD PTR [eax+5820], ecx
\r
4269 00086 8b 4d 0c mov ecx, DWORD PTR _stored_len$[ebp]
\r
4276 ; 872 : #ifdef DEBUG
\r
4277 ; 873 : s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
\r
4278 ; 874 : s->compressed_len += (stored_len + 4) << 3;
\r
4280 ; 876 : copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
\r
4282 0008b e9 00 00 00 00 jmp _copy_block
\r
4283 __tr_stored_block ENDP
\r
4284 ; Function compile flags: /Ogtp
\r
4286 ; COMDAT _send_all_trees
\r
4288 tv556 = -4 ; size = 4
\r
4289 tv555 = -4 ; size = 4
\r
4290 tv554 = -4 ; size = 4
\r
4291 _lcodes$ = 8 ; size = 4
\r
4292 _dcodes$ = 12 ; size = 4
\r
4293 _blcodes$ = 16 ; size = 4
\r
4294 _send_all_trees PROC ; COMDAT
\r
4300 00001 8b ec mov ebp, esp
\r
4303 ; 840 : int rank; /* index in bl_order */
\r
4305 ; 842 : Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
\r
4306 ; 843 : Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
\r
4307 ; 844 : "too many codes");
\r
4308 ; 845 : Tracev((stderr, "\nbl counts: "));
\r
4309 ; 846 : send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
\r
4311 00004 8b 45 08 mov eax, DWORD PTR _lcodes$[ebp]
\r
4312 00007 8b 8e bc 16 00
\r
4313 00 mov ecx, DWORD PTR [esi+5820]
\r
4315 0000e 05 ff fe ff ff add eax, -257 ; fffffeffH
\r
4317 00014 bb 01 00 00 00 mov ebx, 1
\r
4318 00019 83 f9 0b cmp ecx, 11 ; 0000000bH
\r
4319 0001c 7e 56 jle SHORT $LN11@send_all_t
\r
4320 0001e 66 8b d0 mov dx, ax
\r
4321 00021 66 d3 e2 shl dx, cl
\r
4322 00024 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
4323 00027 89 45 fc mov DWORD PTR tv556[ebp], eax
\r
4324 0002a 66 09 96 b8 16
\r
4325 00 00 or WORD PTR [esi+5816], dx
\r
4326 00031 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
4327 00034 8a 86 b8 16 00
\r
4328 00 mov al, BYTE PTR [esi+5816]
\r
4329 0003a 88 04 11 mov BYTE PTR [ecx+edx], al
\r
4330 0003d 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4331 00040 8a 96 b9 16 00
\r
4332 00 mov dl, BYTE PTR [esi+5817]
\r
4333 00046 8b 7e 14 mov edi, DWORD PTR [esi+20]
\r
4334 00049 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
4335 0004c 8b 45 fc mov eax, DWORD PTR tv556[ebp]
\r
4336 0004f 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
4337 00052 8b 96 bc 16 00
\r
4338 00 mov edx, DWORD PTR [esi+5820]
\r
4339 00058 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4340 0005b b1 10 mov cl, 16 ; 00000010H
\r
4341 0005d 2a ca sub cl, dl
\r
4342 0005f 66 d3 e8 shr ax, cl
\r
4343 00062 83 c2 f5 add edx, -11 ; fffffff5H
\r
4344 00065 89 96 bc 16 00
\r
4345 00 mov DWORD PTR [esi+5820], edx
\r
4346 0006b 66 89 86 b8 16
\r
4347 00 00 mov WORD PTR [esi+5816], ax
\r
4348 00072 eb 13 jmp SHORT $LN10@send_all_t
\r
4350 00074 66 d3 e0 shl ax, cl
\r
4351 00077 66 09 86 b8 16
\r
4352 00 00 or WORD PTR [esi+5816], ax
\r
4353 0007e 83 c1 05 add ecx, 5
\r
4354 00081 89 8e bc 16 00
\r
4355 00 mov DWORD PTR [esi+5820], ecx
\r
4358 ; 847 : send_bits(s, dcodes-1, 5);
\r
4360 00087 8b 45 0c mov eax, DWORD PTR _dcodes$[ebp]
\r
4361 0008a 8b 8e bc 16 00
\r
4362 00 mov ecx, DWORD PTR [esi+5820]
\r
4364 00091 83 f9 0b cmp ecx, 11 ; 0000000bH
\r
4365 00094 7e 56 jle SHORT $LN9@send_all_t
\r
4366 00096 66 8b d0 mov dx, ax
\r
4367 00099 66 d3 e2 shl dx, cl
\r
4368 0009c 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
4369 0009f 89 45 fc mov DWORD PTR tv555[ebp], eax
\r
4370 000a2 66 09 96 b8 16
\r
4371 00 00 or WORD PTR [esi+5816], dx
\r
4372 000a9 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
4373 000ac 8a 86 b8 16 00
\r
4374 00 mov al, BYTE PTR [esi+5816]
\r
4375 000b2 88 04 11 mov BYTE PTR [ecx+edx], al
\r
4376 000b5 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4377 000b8 8a 96 b9 16 00
\r
4378 00 mov dl, BYTE PTR [esi+5817]
\r
4379 000be 8b 7e 14 mov edi, DWORD PTR [esi+20]
\r
4380 000c1 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
4381 000c4 8b 45 fc mov eax, DWORD PTR tv555[ebp]
\r
4382 000c7 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
4383 000ca 8b 96 bc 16 00
\r
4384 00 mov edx, DWORD PTR [esi+5820]
\r
4385 000d0 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4386 000d3 b1 10 mov cl, 16 ; 00000010H
\r
4387 000d5 2a ca sub cl, dl
\r
4388 000d7 66 d3 e8 shr ax, cl
\r
4389 000da 83 c2 f5 add edx, -11 ; fffffff5H
\r
4390 000dd 89 96 bc 16 00
\r
4391 00 mov DWORD PTR [esi+5820], edx
\r
4392 000e3 66 89 86 b8 16
\r
4393 00 00 mov WORD PTR [esi+5816], ax
\r
4394 000ea eb 13 jmp SHORT $LN8@send_all_t
\r
4396 000ec 66 d3 e0 shl ax, cl
\r
4397 000ef 66 09 86 b8 16
\r
4398 00 00 or WORD PTR [esi+5816], ax
\r
4399 000f6 83 c1 05 add ecx, 5
\r
4400 000f9 89 8e bc 16 00
\r
4401 00 mov DWORD PTR [esi+5820], ecx
\r
4404 ; 848 : send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */
\r
4406 000ff 8b 45 10 mov eax, DWORD PTR _blcodes$[ebp]
\r
4407 00102 8b 8e bc 16 00
\r
4408 00 mov ecx, DWORD PTR [esi+5820]
\r
4409 00108 83 c0 fc add eax, -4 ; fffffffcH
\r
4410 0010b 83 f9 0c cmp ecx, 12 ; 0000000cH
\r
4411 0010e 7e 56 jle SHORT $LN7@send_all_t
\r
4412 00110 66 8b d0 mov dx, ax
\r
4413 00113 66 d3 e2 shl dx, cl
\r
4414 00116 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
4415 00119 89 45 fc mov DWORD PTR tv554[ebp], eax
\r
4416 0011c 66 09 96 b8 16
\r
4417 00 00 or WORD PTR [esi+5816], dx
\r
4418 00123 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
4419 00126 8a 86 b8 16 00
\r
4420 00 mov al, BYTE PTR [esi+5816]
\r
4421 0012c 88 04 11 mov BYTE PTR [ecx+edx], al
\r
4422 0012f 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4423 00132 8a 96 b9 16 00
\r
4424 00 mov dl, BYTE PTR [esi+5817]
\r
4425 00138 8b 7e 14 mov edi, DWORD PTR [esi+20]
\r
4426 0013b 8b 4e 08 mov ecx, DWORD PTR [esi+8]
\r
4427 0013e 8b 45 fc mov eax, DWORD PTR tv554[ebp]
\r
4428 00141 88 14 0f mov BYTE PTR [edi+ecx], dl
\r
4429 00144 8b 96 bc 16 00
\r
4430 00 mov edx, DWORD PTR [esi+5820]
\r
4431 0014a 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4432 0014d b1 10 mov cl, 16 ; 00000010H
\r
4433 0014f 2a ca sub cl, dl
\r
4434 00151 66 d3 e8 shr ax, cl
\r
4435 00154 83 c2 f4 add edx, -12 ; fffffff4H
\r
4436 00157 89 96 bc 16 00
\r
4437 00 mov DWORD PTR [esi+5820], edx
\r
4438 0015d 66 89 86 b8 16
\r
4439 00 00 mov WORD PTR [esi+5816], ax
\r
4440 00164 eb 13 jmp SHORT $LN6@send_all_t
\r
4442 00166 66 d3 e0 shl ax, cl
\r
4443 00169 66 09 86 b8 16
\r
4444 00 00 or WORD PTR [esi+5816], ax
\r
4445 00170 83 c1 04 add ecx, 4
\r
4446 00173 89 8e bc 16 00
\r
4447 00 mov DWORD PTR [esi+5820], ecx
\r
4450 ; 849 : for (rank = 0; rank < blcodes; rank++) {
\r
4452 00179 33 ff xor edi, edi
\r
4453 0017b 39 7d 10 cmp DWORD PTR _blcodes$[ebp], edi
\r
4454 0017e 0f 8e 9e 00 00
\r
4455 00 jle $LN3@send_all_t
\r
4458 ; 850 : Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
\r
4459 ; 851 : send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
\r
4461 00184 8b 8e bc 16 00
\r
4462 00 mov ecx, DWORD PTR [esi+5820]
\r
4463 0018a 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
4464 0018d 7e 66 jle SHORT $LN2@send_all_t
\r
4465 0018f 0f b6 97 00 00
\r
4466 00 00 movzx edx, BYTE PTR _bl_order[edi]
\r
4467 00196 0f b7 84 96 7e
\r
4468 0a 00 00 movzx eax, WORD PTR [esi+edx*4+2686]
\r
4469 0019e 66 8b d0 mov dx, ax
\r
4470 001a1 66 d3 e2 shl dx, cl
\r
4471 001a4 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
4472 001a7 66 09 96 b8 16
\r
4473 00 00 or WORD PTR [esi+5816], dx
\r
4474 001ae 0f b6 9e b8 16
\r
4475 00 00 movzx ebx, BYTE PTR [esi+5816]
\r
4476 001b5 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
4477 001b8 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
4478 001bb ff 46 14 inc DWORD PTR [esi+20]
\r
4479 001be 0f b6 9e b9 16
\r
4480 00 00 movzx ebx, BYTE PTR [esi+5817]
\r
4481 001c5 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
4482 001c8 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
4483 001cb 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
4484 001ce 8b 96 bc 16 00
\r
4485 00 mov edx, DWORD PTR [esi+5820]
\r
4486 001d4 b1 10 mov cl, 16 ; 00000010H
\r
4487 001d6 2a ca sub cl, dl
\r
4488 001d8 66 d3 e8 shr ax, cl
\r
4489 001db bb 01 00 00 00 mov ebx, 1
\r
4490 001e0 01 5e 14 add DWORD PTR [esi+20], ebx
\r
4491 001e3 83 c2 f3 add edx, -13 ; fffffff3H
\r
4492 001e6 66 89 86 b8 16
\r
4493 00 00 mov WORD PTR [esi+5816], ax
\r
4494 001ed 89 96 bc 16 00
\r
4495 00 mov DWORD PTR [esi+5820], edx
\r
4496 001f3 eb 22 jmp SHORT $LN4@send_all_t
\r
4498 001f5 0f b6 87 00 00
\r
4499 00 00 movzx eax, BYTE PTR _bl_order[edi]
\r
4500 001fc 66 8b 94 86 7e
\r
4501 0a 00 00 mov dx, WORD PTR [esi+eax*4+2686]
\r
4502 00204 66 d3 e2 shl dx, cl
\r
4503 00207 66 09 96 b8 16
\r
4504 00 00 or WORD PTR [esi+5816], dx
\r
4505 0020e 83 c1 03 add ecx, 3
\r
4506 00211 89 8e bc 16 00
\r
4507 00 mov DWORD PTR [esi+5820], ecx
\r
4510 ; 849 : for (rank = 0; rank < blcodes; rank++) {
\r
4512 00217 03 fb add edi, ebx
\r
4513 00219 3b 7d 10 cmp edi, DWORD PTR _blcodes$[ebp]
\r
4514 0021c 0f 8c 62 ff ff
\r
4515 ff jl $LL5@send_all_t
\r
4519 ; 853 : Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
\r
4521 ; 855 : send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
\r
4523 00222 8b 4d 08 mov ecx, DWORD PTR _lcodes$[ebp]
\r
4525 00226 8d 96 94 00 00
\r
4526 00 lea edx, DWORD PTR [esi+148]
\r
4527 0022c 8b c6 mov eax, esi
\r
4528 0022e e8 00 00 00 00 call _send_tree
\r
4530 ; 856 : Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
\r
4532 ; 858 : send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
\r
4534 00233 8b 4d 0c mov ecx, DWORD PTR _dcodes$[ebp]
\r
4536 00237 8d 96 88 09 00
\r
4537 00 lea edx, DWORD PTR [esi+2440]
\r
4538 0023d 8b c6 mov eax, esi
\r
4539 0023f e8 00 00 00 00 call _send_tree
\r
4543 ; 859 : Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
\r
4546 00246 8b e5 mov esp, ebp
\r
4549 _send_all_trees ENDP
\r
4550 ; Function compile flags: /Ogtp
\r
4552 ; COMDAT _build_tree
\r
4554 _node$ = -8 ; size = 4
\r
4555 _elems$ = -8 ; size = 4
\r
4556 _max_code$ = -4 ; size = 4
\r
4557 _desc$ = 8 ; size = 4
\r
4558 _build_tree PROC ; COMDAT
\r
4564 00001 8b ec mov ebp, esp
\r
4565 00003 83 ec 08 sub esp, 8
\r
4567 ; 621 : ct_data *tree = desc->dyn_tree;
\r
4569 00006 8b 45 08 mov eax, DWORD PTR _desc$[ebp]
\r
4572 0000b 8b 38 mov edi, DWORD PTR [eax]
\r
4574 ; 622 : const ct_data *stree = desc->stat_desc->static_tree;
\r
4576 0000d 8b 40 08 mov eax, DWORD PTR [eax+8]
\r
4578 ; 623 : int elems = desc->stat_desc->elems;
\r
4580 00010 8b 50 0c mov edx, DWORD PTR [eax+12]
\r
4581 00013 8b 18 mov ebx, DWORD PTR [eax]
\r
4583 ; 624 : int n, m; /* iterate over heap elements */
\r
4584 ; 625 : int max_code = -1; /* largest code with non zero frequency */
\r
4586 00015 83 c9 ff or ecx, -1
\r
4588 ; 626 : int node; /* new node being created */
\r
4590 ; 628 : /* Construct the initial heap, with least frequent element in
\r
4591 ; 629 : * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
\r
4592 ; 630 : * heap[0] is not used.
\r
4594 ; 632 : s->heap_len = 0, s->heap_max = HEAP_SIZE;
\r
4596 ; 634 : for (n = 0; n < elems; n++) {
\r
4598 00018 33 c0 xor eax, eax
\r
4599 0001a 89 55 f8 mov DWORD PTR _elems$[ebp], edx
\r
4600 0001d 89 4d fc mov DWORD PTR _max_code$[ebp], ecx
\r
4601 00020 c7 86 50 14 00
\r
4602 00 00 00 00 00 mov DWORD PTR [esi+5200], 0
\r
4603 0002a c7 86 54 14 00
\r
4604 00 3d 02 00 00 mov DWORD PTR [esi+5204], 573 ; 0000023dH
\r
4605 00034 85 d2 test edx, edx
\r
4606 00036 7e 36 jle SHORT $LN22@build_tree
\r
4609 ; 635 : if (tree[n].Freq != 0) {
\r
4611 00038 66 83 3c 87 00 cmp WORD PTR [edi+eax*4], 0
\r
4612 0003d 74 22 je SHORT $LN11@build_tree
\r
4614 ; 636 : s->heap[++(s->heap_len)] = max_code = n;
\r
4616 0003f ff 86 50 14 00
\r
4617 00 inc DWORD PTR [esi+5200]
\r
4618 00045 8b 96 50 14 00
\r
4619 00 mov edx, DWORD PTR [esi+5200]
\r
4620 0004b 89 84 96 5c 0b
\r
4621 00 00 mov DWORD PTR [esi+edx*4+2908], eax
\r
4622 00052 89 45 fc mov DWORD PTR _max_code$[ebp], eax
\r
4624 ; 637 : s->depth[n] = 0;
\r
4626 00055 c6 84 30 58 14
\r
4627 00 00 00 mov BYTE PTR [eax+esi+5208], 0
\r
4631 0005d 8b c8 mov ecx, eax
\r
4632 0005f eb 07 jmp SHORT $LN13@build_tree
\r
4635 ; 639 : tree[n].Len = 0;
\r
4637 00061 33 d2 xor edx, edx
\r
4638 00063 66 89 54 87 02 mov WORD PTR [edi+eax*4+2], dx
\r
4641 ; 626 : int node; /* new node being created */
\r
4643 ; 628 : /* Construct the initial heap, with least frequent element in
\r
4644 ; 629 : * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
\r
4645 ; 630 : * heap[0] is not used.
\r
4647 ; 632 : s->heap_len = 0, s->heap_max = HEAP_SIZE;
\r
4649 ; 634 : for (n = 0; n < elems; n++) {
\r
4652 00069 3b 45 f8 cmp eax, DWORD PTR _elems$[ebp]
\r
4653 0006c 7c ca jl SHORT $LL14@build_tree
\r
4659 ; 643 : /* The pkzip format requires that at least one distance code exists,
\r
4660 ; 644 : * and that at least one bit should be sent even if there is only one
\r
4661 ; 645 : * possible code. So to avoid special checks later on we force at least
\r
4662 ; 646 : * two codes of non zero frequency.
\r
4664 ; 648 : while (s->heap_len < 2) {
\r
4666 0006e 83 be 50 14 00
\r
4667 00 02 cmp DWORD PTR [esi+5200], 2
\r
4668 00075 7d 51 jge SHORT $LN8@build_tree
\r
4671 ; 649 : node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
\r
4673 00077 83 f9 02 cmp ecx, 2
\r
4674 0007a 7d 05 jge SHORT $LN17@build_tree
\r
4676 0007d 8b c1 mov eax, ecx
\r
4677 0007f eb 02 jmp SHORT $LN18@build_tree
\r
4679 00081 33 c0 xor eax, eax
\r
4681 00083 ff 86 50 14 00
\r
4682 00 inc DWORD PTR [esi+5200]
\r
4683 00089 8b 96 50 14 00
\r
4684 00 mov edx, DWORD PTR [esi+5200]
\r
4685 0008f 89 84 96 5c 0b
\r
4686 00 00 mov DWORD PTR [esi+edx*4+2908], eax
\r
4688 ; 650 : tree[node].Freq = 1;
\r
4690 00096 ba 01 00 00 00 mov edx, 1
\r
4691 0009b 66 89 14 87 mov WORD PTR [edi+eax*4], dx
\r
4693 ; 651 : s->depth[node] = 0;
\r
4695 0009f c6 84 06 58 14
\r
4696 00 00 00 mov BYTE PTR [esi+eax+5208], 0
\r
4698 ; 652 : s->opt_len--; if (stree) s->static_len -= stree[node].Len;
\r
4700 000a7 ff 8e a8 16 00
\r
4701 00 dec DWORD PTR [esi+5800]
\r
4702 000ad 85 db test ebx, ebx
\r
4703 000af 74 0b je SHORT $LN7@build_tree
\r
4704 000b1 0f b7 44 83 02 movzx eax, WORD PTR [ebx+eax*4+2]
\r
4705 000b6 29 86 ac 16 00
\r
4706 00 sub DWORD PTR [esi+5804], eax
\r
4712 ; 643 : /* The pkzip format requires that at least one distance code exists,
\r
4713 ; 644 : * and that at least one bit should be sent even if there is only one
\r
4714 ; 645 : * possible code. So to avoid special checks later on we force at least
\r
4715 ; 646 : * two codes of non zero frequency.
\r
4717 ; 648 : while (s->heap_len < 2) {
\r
4719 000bc 83 be 50 14 00
\r
4720 00 02 cmp DWORD PTR [esi+5200], 2
\r
4721 000c3 7c b2 jl SHORT $LL9@build_tree
\r
4723 ; 649 : node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
\r
4725 000c5 89 4d fc mov DWORD PTR _max_code$[ebp], ecx
\r
4728 ; 653 : /* node is 0 or 1 so it does not have extra bits */
\r
4730 ; 655 : desc->max_code = max_code;
\r
4732 000c8 8b 55 08 mov edx, DWORD PTR _desc$[ebp]
\r
4733 000cb 89 4a 04 mov DWORD PTR [edx+4], ecx
\r
4736 ; 657 : /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
\r
4737 ; 658 : * establish sub-heaps of increasing lengths:
\r
4739 ; 660 : for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
\r
4741 000ce 8b 86 50 14 00
\r
4742 00 mov eax, DWORD PTR [esi+5200]
\r
4744 000d5 2b c2 sub eax, edx
\r
4745 000d7 8b d8 mov ebx, eax
\r
4746 000d9 d1 fb sar ebx, 1
\r
4747 000db 83 fb 01 cmp ebx, 1
\r
4748 000de 7c 11 jl SHORT $LN4@build_tree
\r
4751 000e1 8b c6 mov eax, esi
\r
4752 000e3 e8 00 00 00 00 call _pqdownheap
\r
4754 000e9 83 c4 04 add esp, 4
\r
4755 000ec 83 fb 01 cmp ebx, 1
\r
4756 000ef 7d ef jge SHORT $LL6@build_tree
\r
4760 ; 662 : /* Construct the Huffman tree by repeatedly combining the least two
\r
4761 ; 663 : * frequent nodes.
\r
4763 ; 665 : node = elems; /* next internal node of the tree */
\r
4765 000f1 8b 45 f8 mov eax, DWORD PTR _elems$[ebp]
\r
4766 000f4 89 45 f8 mov DWORD PTR _node$[ebp], eax
\r
4767 000f7 eb 07 8d a4 24
\r
4768 00 00 00 00 npad 9
\r
4772 ; 667 : pqremove(s, tree, n); /* n = node of least frequency */
\r
4774 00100 8b 86 50 14 00
\r
4775 00 mov eax, DWORD PTR [esi+5200]
\r
4776 00106 8b 8c 86 5c 0b
\r
4777 00 00 mov ecx, DWORD PTR [esi+eax*4+2908]
\r
4778 0010d 8b 9e 60 0b 00
\r
4779 00 mov ebx, DWORD PTR [esi+2912]
\r
4781 00114 89 86 50 14 00
\r
4782 00 mov DWORD PTR [esi+5200], eax
\r
4783 0011a 6a 01 push 1
\r
4784 0011c 8b c6 mov eax, esi
\r
4785 0011e 89 8e 60 0b 00
\r
4786 00 mov DWORD PTR [esi+2912], ecx
\r
4787 00124 e8 00 00 00 00 call _pqdownheap
\r
4789 ; 668 : m = s->heap[SMALLEST]; /* m = node of next least frequency */
\r
4791 00129 8b 86 60 0b 00
\r
4792 00 mov eax, DWORD PTR [esi+2912]
\r
4795 ; 670 : s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
\r
4797 0012f 83 ca ff or edx, -1
\r
4798 00132 01 96 54 14 00
\r
4799 00 add DWORD PTR [esi+5204], edx
\r
4800 00138 8b 8e 54 14 00
\r
4801 00 mov ecx, DWORD PTR [esi+5204]
\r
4802 0013e 89 9c 8e 5c 0b
\r
4803 00 00 mov DWORD PTR [esi+ecx*4+2908], ebx
\r
4805 ; 671 : s->heap[--(s->heap_max)] = m;
\r
4807 00145 01 96 54 14 00
\r
4808 00 add DWORD PTR [esi+5204], edx
\r
4809 0014b 8b 8e 54 14 00
\r
4810 00 mov ecx, DWORD PTR [esi+5204]
\r
4811 00151 89 84 8e 5c 0b
\r
4812 00 00 mov DWORD PTR [esi+ecx*4+2908], eax
\r
4815 ; 673 : /* Create a new node father of n and m */
\r
4816 ; 674 : tree[node].Freq = tree[n].Freq + tree[m].Freq;
\r
4818 00158 66 8b 14 87 mov dx, WORD PTR [edi+eax*4]
\r
4819 0015c 66 03 14 9f add dx, WORD PTR [edi+ebx*4]
\r
4820 00160 8b 4d f8 mov ecx, DWORD PTR _node$[ebp]
\r
4821 00163 66 89 14 8f mov WORD PTR [edi+ecx*4], dx
\r
4823 ; 675 : s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
\r
4824 ; 676 : s->depth[n] : s->depth[m]) + 1);
\r
4826 00167 8a 94 1e 58 14
\r
4827 00 00 mov dl, BYTE PTR [esi+ebx+5208]
\r
4828 0016e 8a 8c 06 58 14
\r
4829 00 00 mov cl, BYTE PTR [esi+eax+5208]
\r
4830 00175 83 c4 04 add esp, 4
\r
4831 00178 3a d1 cmp dl, cl
\r
4832 0017a 0f b6 d2 movzx edx, dl
\r
4833 0017d 73 03 jae SHORT $LN20@build_tree
\r
4834 0017f 0f b6 d1 movzx edx, cl
\r
4836 00182 8b 4d f8 mov ecx, DWORD PTR _node$[ebp]
\r
4837 00185 fe c2 inc dl
\r
4838 00187 88 94 0e 58 14
\r
4839 00 00 mov BYTE PTR [esi+ecx+5208], dl
\r
4841 ; 677 : tree[n].Dad = tree[m].Dad = (ush)node;
\r
4843 0018e 0f b7 d1 movzx edx, cx
\r
4844 00191 66 89 54 87 02 mov WORD PTR [edi+eax*4+2], dx
\r
4845 00196 66 89 54 9f 02 mov WORD PTR [edi+ebx*4+2], dx
\r
4847 ; 678 : #ifdef DUMP_BL_TREE
\r
4848 ; 679 : if (tree == s->bl_tree) {
\r
4849 ; 680 : fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
\r
4850 ; 681 : node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
\r
4853 ; 684 : /* and insert the new node in the heap */
\r
4854 ; 685 : s->heap[SMALLEST] = node++;
\r
4856 0019b 89 8e 60 0b 00
\r
4857 00 mov DWORD PTR [esi+2912], ecx
\r
4860 ; 686 : pqdownheap(s, tree, SMALLEST);
\r
4862 001a2 6a 01 push 1
\r
4863 001a4 8b c6 mov eax, esi
\r
4864 001a6 89 4d f8 mov DWORD PTR _node$[ebp], ecx
\r
4865 001a9 e8 00 00 00 00 call _pqdownheap
\r
4866 001ae 83 c4 04 add esp, 4
\r
4869 ; 688 : } while (s->heap_len >= 2);
\r
4871 001b1 83 be 50 14 00
\r
4872 00 02 cmp DWORD PTR [esi+5200], 2
\r
4873 001b8 0f 8d 42 ff ff
\r
4874 ff jge $LL3@build_tree
\r
4877 ; 690 : s->heap[--(s->heap_max)] = s->heap[SMALLEST];
\r
4879 001be ff 8e 54 14 00
\r
4880 00 dec DWORD PTR [esi+5204]
\r
4881 001c4 8b 86 54 14 00
\r
4882 00 mov eax, DWORD PTR [esi+5204]
\r
4883 001ca 8b 96 60 0b 00
\r
4884 00 mov edx, DWORD PTR [esi+2912]
\r
4887 ; 692 : /* At this point, the fields freq and dad are set. We can now
\r
4888 ; 693 : * generate the bit lengths.
\r
4890 ; 695 : gen_bitlen(s, (tree_desc *)desc);
\r
4892 001d0 8b 4d 08 mov ecx, DWORD PTR _desc$[ebp]
\r
4893 001d3 89 94 86 5c 0b
\r
4894 00 00 mov DWORD PTR [esi+eax*4+2908], edx
\r
4895 001da 8b c6 mov eax, esi
\r
4896 001dc e8 00 00 00 00 call _gen_bitlen
\r
4899 ; 697 : /* The field len is now set, we can generate the bit codes */
\r
4900 ; 698 : gen_codes ((ct_data *)tree, max_code, s->bl_count);
\r
4902 001e1 8b 5d fc mov ebx, DWORD PTR _max_code$[ebp]
\r
4903 001e4 8d 96 3c 0b 00
\r
4904 00 lea edx, DWORD PTR [esi+2876]
\r
4905 001ea e8 00 00 00 00 call _gen_codes
\r
4911 001f1 8b e5 mov esp, ebp
\r
4917 ; Function compile flags: /Ogtp
\r
4918 ; COMDAT __tr_init
\r
4920 __tr_init PROC ; COMDAT
\r
4923 ; 384 : tr_static_init();
\r
4925 ; 386 : s->l_desc.dyn_tree = s->dyn_ltree;
\r
4927 00000 8d 82 94 00 00
\r
4928 00 lea eax, DWORD PTR [edx+148]
\r
4930 ; 387 : s->l_desc.stat_desc = &static_l_desc;
\r
4932 ; 389 : s->d_desc.dyn_tree = s->dyn_dtree;
\r
4934 00006 8d 8a 88 09 00
\r
4935 00 lea ecx, DWORD PTR [edx+2440]
\r
4936 0000c 89 82 18 0b 00
\r
4937 00 mov DWORD PTR [edx+2840], eax
\r
4938 00012 89 8a 24 0b 00
\r
4939 00 mov DWORD PTR [edx+2852], ecx
\r
4941 ; 390 : s->d_desc.stat_desc = &static_d_desc;
\r
4943 ; 392 : s->bl_desc.dyn_tree = s->bl_tree;
\r
4944 ; 393 : s->bl_desc.stat_desc = &static_bl_desc;
\r
4946 ; 395 : s->bi_buf = 0;
\r
4948 00018 33 c9 xor ecx, ecx
\r
4949 0001a 8d 82 7c 0a 00
\r
4950 00 lea eax, DWORD PTR [edx+2684]
\r
4951 00020 c7 82 20 0b 00
\r
4952 00 00 00 00 00 mov DWORD PTR [edx+2848], OFFSET _static_l_desc
\r
4953 0002a c7 82 2c 0b 00
\r
4954 00 00 00 00 00 mov DWORD PTR [edx+2860], OFFSET _static_d_desc
\r
4955 00034 89 82 30 0b 00
\r
4956 00 mov DWORD PTR [edx+2864], eax
\r
4957 0003a c7 82 38 0b 00
\r
4958 00 00 00 00 00 mov DWORD PTR [edx+2872], OFFSET _static_bl_desc
\r
4959 00044 66 89 8a b8 16
\r
4960 00 00 mov WORD PTR [edx+5816], cx
\r
4962 ; 396 : s->bi_valid = 0;
\r
4964 0004b 89 8a bc 16 00
\r
4965 00 mov DWORD PTR [edx+5820], ecx
\r
4967 ; 397 : #ifdef DEBUG
\r
4968 ; 398 : s->compressed_len = 0L;
\r
4969 ; 399 : s->bits_sent = 0L;
\r
4972 ; 402 : /* Initialize the first block of the first file: */
\r
4973 ; 403 : init_block(s);
\r
4975 00051 e9 00 00 00 00 jmp _init_block
\r
4977 ; Function compile flags: /Ogtp
\r
4978 ; COMDAT _build_bl_tree
\r
4980 _build_bl_tree PROC ; COMDAT
\r
4986 00001 8b f0 mov esi, eax
\r
4988 ; 804 : int max_blindex; /* index of last bit length code of non zero freq */
\r
4990 ; 806 : /* Determine the bit length frequencies for literal and distance trees */
\r
4991 ; 807 : scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
\r
4993 00003 8b 86 1c 0b 00
\r
4994 00 mov eax, DWORD PTR [esi+2844]
\r
4995 00009 8d 8e 94 00 00
\r
4996 00 lea ecx, DWORD PTR [esi+148]
\r
4998 00010 e8 00 00 00 00 call _scan_tree
\r
5000 ; 808 : scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
\r
5002 00015 8b 86 28 0b 00
\r
5003 00 mov eax, DWORD PTR [esi+2856]
\r
5004 0001b 8d 8e 88 09 00
\r
5005 00 lea ecx, DWORD PTR [esi+2440]
\r
5007 00022 e8 00 00 00 00 call _scan_tree
\r
5010 ; 810 : /* Build the bit length tree: */
\r
5011 ; 811 : build_tree(s, (tree_desc *)(&(s->bl_desc)));
\r
5013 00027 8d 86 30 0b 00
\r
5014 00 lea eax, DWORD PTR [esi+2864]
\r
5016 0002e e8 00 00 00 00 call _build_tree
\r
5017 00033 83 c4 0c add esp, 12 ; 0000000cH
\r
5019 ; 812 : /* opt_len now includes the length of the tree representations, except
\r
5020 ; 813 : * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
\r
5023 ; 816 : /* Determine the number of bit length codes to send. The pkzip format
\r
5024 ; 817 : * requires that at least 4 bit length codes be sent. (appnote.txt says
\r
5025 ; 818 : * 3 but the actual value used is 4.)
\r
5027 ; 820 : for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
\r
5029 00036 b8 12 00 00 00 mov eax, 18 ; 00000012H
\r
5030 0003b eb 03 8d 49 00 npad 5
\r
5033 ; 821 : if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
\r
5035 00040 0f b6 88 00 00
\r
5036 00 00 movzx ecx, BYTE PTR _bl_order[eax]
\r
5037 00047 66 83 bc 8e 7e
\r
5038 0a 00 00 00 cmp WORD PTR [esi+ecx*4+2686], 0
\r
5039 00050 75 69 jne SHORT $LN8@build_bl_t
\r
5040 00052 0f b6 90 ff ff
\r
5041 ff ff movzx edx, BYTE PTR _bl_order[eax-1]
\r
5042 00059 66 83 bc 96 7e
\r
5043 0a 00 00 00 cmp WORD PTR [esi+edx*4+2686], 0
\r
5044 00062 75 38 jne SHORT $LN10@build_bl_t
\r
5045 00064 0f b6 88 fe ff
\r
5046 ff ff movzx ecx, BYTE PTR _bl_order[eax-2]
\r
5047 0006b 66 83 bc 8e 7e
\r
5048 0a 00 00 00 cmp WORD PTR [esi+ecx*4+2686], 0
\r
5049 00074 75 33 jne SHORT $LN11@build_bl_t
\r
5050 00076 0f b6 90 fd ff
\r
5051 ff ff movzx edx, BYTE PTR _bl_order[eax-3]
\r
5052 0007d 66 83 bc 96 7e
\r
5053 0a 00 00 00 cmp WORD PTR [esi+edx*4+2686], 0
\r
5054 00086 75 30 jne SHORT $LN12@build_bl_t
\r
5056 ; 812 : /* opt_len now includes the length of the tree representations, except
\r
5057 ; 813 : * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
\r
5060 ; 816 : /* Determine the number of bit length codes to send. The pkzip format
\r
5061 ; 817 : * requires that at least 4 bit length codes be sent. (appnote.txt says
\r
5062 ; 818 : * 3 but the actual value used is 4.)
\r
5064 ; 820 : for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
\r
5066 00088 83 e8 04 sub eax, 4
\r
5067 0008b 83 f8 03 cmp eax, 3
\r
5068 0008e 7d b0 jge SHORT $LL4@build_bl_t
\r
5071 ; 823 : /* Update opt_len to include the bit length tree and counts */
\r
5072 ; 824 : s->opt_len += 3*(max_blindex+1) + 5+5+4;
\r
5074 00090 8d 4c 40 11 lea ecx, DWORD PTR [eax+eax*2+17]
\r
5075 00094 01 8e a8 16 00
\r
5076 00 add DWORD PTR [esi+5800], ecx
\r
5079 ; 825 : Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
\r
5080 ; 826 : s->opt_len, s->static_len));
\r
5082 ; 828 : return max_blindex;
\r
5088 ; 821 : if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
\r
5093 ; 823 : /* Update opt_len to include the bit length tree and counts */
\r
5094 ; 824 : s->opt_len += 3*(max_blindex+1) + 5+5+4;
\r
5096 0009d 8d 4c 40 11 lea ecx, DWORD PTR [eax+eax*2+17]
\r
5097 000a1 01 8e a8 16 00
\r
5098 00 add DWORD PTR [esi+5800], ecx
\r
5101 ; 825 : Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
\r
5102 ; 826 : s->opt_len, s->static_len));
\r
5104 ; 828 : return max_blindex;
\r
5110 ; 821 : if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
\r
5112 000a9 83 e8 02 sub eax, 2
\r
5115 ; 823 : /* Update opt_len to include the bit length tree and counts */
\r
5116 ; 824 : s->opt_len += 3*(max_blindex+1) + 5+5+4;
\r
5118 000ac 8d 4c 40 11 lea ecx, DWORD PTR [eax+eax*2+17]
\r
5119 000b0 01 8e a8 16 00
\r
5120 00 add DWORD PTR [esi+5800], ecx
\r
5123 ; 825 : Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
\r
5124 ; 826 : s->opt_len, s->static_len));
\r
5126 ; 828 : return max_blindex;
\r
5132 ; 821 : if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
\r
5134 000b8 83 e8 03 sub eax, 3
\r
5138 ; 823 : /* Update opt_len to include the bit length tree and counts */
\r
5139 ; 824 : s->opt_len += 3*(max_blindex+1) + 5+5+4;
\r
5141 000bb 8d 4c 40 11 lea ecx, DWORD PTR [eax+eax*2+17]
\r
5142 000bf 01 8e a8 16 00
\r
5143 00 add DWORD PTR [esi+5800], ecx
\r
5146 ; 825 : Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
\r
5147 ; 826 : s->opt_len, s->static_len));
\r
5149 ; 828 : return max_blindex;
\r
5153 _build_bl_tree ENDP
\r
5154 PUBLIC __tr_flush_block
\r
5155 ; Function compile flags: /Ogtp
\r
5156 ; COMDAT __tr_flush_block
\r
5158 _max_blindex$ = -4 ; size = 4
\r
5159 _buf$ = 8 ; size = 4
\r
5160 _last$ = 12 ; size = 4
\r
5161 __tr_flush_block PROC ; COMDAT
\r
5163 ; _stored_len$ = eax
\r
5168 00001 8b ec mov ebp, esp
\r
5172 00006 8b f1 mov esi, ecx
\r
5174 ; 913 : ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
\r
5175 ; 914 : int max_blindex = 0; /* index of last bit length code of non zero freq */
\r
5177 ; 916 : /* Build the Huffman trees unless a stored block is forced */
\r
5178 ; 917 : if (s->level > 0) {
\r
5180 00008 83 be 84 00 00
\r
5181 00 00 cmp DWORD PTR [esi+132], 0
\r
5183 00010 8b d8 mov ebx, eax
\r
5184 00012 c7 45 fc 00 00
\r
5185 00 00 mov DWORD PTR _max_blindex$[ebp], 0
\r
5186 00019 7e 53 jle SHORT $LN14@tr_flush_b
\r
5189 ; 919 : /* Check if the file is binary or text */
\r
5190 ; 920 : if (s->strm->data_type == Z_UNKNOWN)
\r
5192 0001b 8b 3e mov edi, DWORD PTR [esi]
\r
5193 0001d 83 7f 2c 02 cmp DWORD PTR [edi+44], 2
\r
5194 00021 75 08 jne SHORT $LN13@tr_flush_b
\r
5196 ; 921 : s->strm->data_type = detect_data_type(s);
\r
5198 00023 e8 00 00 00 00 call _detect_data_type
\r
5199 00028 89 47 2c mov DWORD PTR [edi+44], eax
\r
5203 ; 923 : /* Construct the literal and distance trees */
\r
5204 ; 924 : build_tree(s, (tree_desc *)(&(s->l_desc)));
\r
5206 0002b 8d 86 18 0b 00
\r
5207 00 lea eax, DWORD PTR [esi+2840]
\r
5209 00032 e8 00 00 00 00 call _build_tree
\r
5211 ; 925 : Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
\r
5212 ; 926 : s->static_len));
\r
5214 ; 928 : build_tree(s, (tree_desc *)(&(s->d_desc)));
\r
5216 00037 8d 8e 24 0b 00
\r
5217 00 lea ecx, DWORD PTR [esi+2852]
\r
5219 0003e e8 00 00 00 00 call _build_tree
\r
5220 00043 83 c4 08 add esp, 8
\r
5222 ; 929 : Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
\r
5223 ; 930 : s->static_len));
\r
5224 ; 931 : /* At this point, opt_len and static_len are the total bit lengths of
\r
5225 ; 932 : * the compressed block data, excluding the tree representations.
\r
5228 ; 935 : /* Build the bit length tree for the above two trees, and get the index
\r
5229 ; 936 : * in bl_order of the last bit length code to send.
\r
5231 ; 938 : max_blindex = build_bl_tree(s);
\r
5233 00046 8b c6 mov eax, esi
\r
5234 00048 e8 00 00 00 00 call _build_bl_tree
\r
5237 ; 940 : /* Determine the best encoding. Compute the block lengths in bytes. */
\r
5238 ; 941 : opt_lenb = (s->opt_len+3+7)>>3;
\r
5240 0004d 8b 96 a8 16 00
\r
5241 00 mov edx, DWORD PTR [esi+5800]
\r
5243 ; 942 : static_lenb = (s->static_len+3+7)>>3;
\r
5245 00053 8b 8e ac 16 00
\r
5246 00 mov ecx, DWORD PTR [esi+5804]
\r
5247 00059 83 c2 0a add edx, 10 ; 0000000aH
\r
5248 0005c 83 c1 0a add ecx, 10 ; 0000000aH
\r
5249 0005f c1 ea 03 shr edx, 3
\r
5250 00062 c1 e9 03 shr ecx, 3
\r
5251 00065 89 45 fc mov DWORD PTR _max_blindex$[ebp], eax
\r
5254 ; 944 : Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
\r
5255 ; 945 : opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
\r
5256 ; 946 : s->last_lit));
\r
5258 ; 948 : if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
\r
5260 00068 3b ca cmp ecx, edx
\r
5261 0006a 77 07 ja SHORT $LN17@tr_flush_b
\r
5266 0006c eb 03 jmp SHORT $LN18@tr_flush_b
\r
5269 ; 951 : Assert(buf != (char*)0, "lost buf");
\r
5270 ; 952 : opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
\r
5272 0006e 8d 4b 05 lea ecx, DWORD PTR [ebx+5]
\r
5274 00071 8b d1 mov edx, ecx
\r
5279 ; 955 : #ifdef FORCE_STORED
\r
5280 ; 956 : if (buf != (char*)0) { /* force stored block */
\r
5282 ; 958 : if (stored_len+4 <= opt_lenb && buf != (char*)0) {
\r
5284 00073 8d 43 04 lea eax, DWORD PTR [ebx+4]
\r
5285 00076 3b c2 cmp eax, edx
\r
5286 00078 77 18 ja SHORT $LN10@tr_flush_b
\r
5287 0007a 8b 45 08 mov eax, DWORD PTR _buf$[ebp]
\r
5288 0007d 85 c0 test eax, eax
\r
5289 0007f 74 11 je SHORT $LN10@tr_flush_b
\r
5291 ; 959 : /* 4: two words for the lengths */
\r
5293 ; 961 : /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
\r
5294 ; 962 : * Otherwise we can't have processed more than WSIZE input bytes since
\r
5295 ; 963 : * the last block flush, because compression would have been
\r
5296 ; 964 : * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
\r
5297 ; 965 : * transform a block into a stored block.
\r
5299 ; 967 : _tr_stored_block(s, buf, stored_len, last);
\r
5301 00081 8b 4d 0c mov ecx, DWORD PTR _last$[ebp]
\r
5304 00086 8b c6 mov eax, esi
\r
5305 00088 e8 00 00 00 00 call __tr_stored_block
\r
5306 0008d e9 55 01 00 00 jmp $LN19@tr_flush_b
\r
5310 ; 969 : #ifdef FORCE_STATIC
\r
5311 ; 970 : } else if (static_lenb >= 0) { /* force static trees */
\r
5313 ; 972 : } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
\r
5315 00092 83 be 88 00 00
\r
5316 00 04 cmp DWORD PTR [esi+136], 4
\r
5317 00099 0f 84 bc 00 00
\r
5318 00 je $LN7@tr_flush_b
\r
5319 0009f 3b ca cmp ecx, edx
\r
5320 000a1 0f 84 b4 00 00
\r
5321 00 je $LN7@tr_flush_b
\r
5323 ; 976 : #ifdef DEBUG
\r
5324 ; 977 : s->compressed_len += 3 + s->static_len;
\r
5327 ; 980 : send_bits(s, (DYN_TREES<<1)+last, 3);
\r
5329 000a7 8b 55 0c mov edx, DWORD PTR _last$[ebp]
\r
5330 000aa 8b 8e bc 16 00
\r
5331 00 mov ecx, DWORD PTR [esi+5820]
\r
5332 000b0 83 c2 04 add edx, 4
\r
5333 000b3 bf 01 00 00 00 mov edi, 1
\r
5334 000b8 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
5335 000bb 7e 52 jle SHORT $LN3@tr_flush_b
\r
5336 000bd 66 8b c2 mov ax, dx
\r
5337 000c0 66 d3 e0 shl ax, cl
\r
5338 000c3 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5339 000c6 66 09 86 b8 16
\r
5340 00 00 or WORD PTR [esi+5816], ax
\r
5341 000cd 0f b6 9e b8 16
\r
5342 00 00 movzx ebx, BYTE PTR [esi+5816]
\r
5343 000d4 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5344 000d7 88 1c 01 mov BYTE PTR [ecx+eax], bl
\r
5345 000da 01 7e 14 add DWORD PTR [esi+20], edi
\r
5346 000dd 0f b6 9e b9 16
\r
5347 00 00 movzx ebx, BYTE PTR [esi+5817]
\r
5348 000e4 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5349 000e7 8b 46 08 mov eax, DWORD PTR [esi+8]
\r
5350 000ea 88 1c 01 mov BYTE PTR [ecx+eax], bl
\r
5351 000ed 8b 9e bc 16 00
\r
5352 00 mov ebx, DWORD PTR [esi+5820]
\r
5353 000f3 01 7e 14 add DWORD PTR [esi+20], edi
\r
5354 000f6 b1 10 mov cl, 16 ; 00000010H
\r
5355 000f8 2a cb sub cl, bl
\r
5356 000fa 66 d3 ea shr dx, cl
\r
5357 000fd 83 c3 f3 add ebx, -13 ; fffffff3H
\r
5358 00100 89 9e bc 16 00
\r
5359 00 mov DWORD PTR [esi+5820], ebx
\r
5360 00106 66 89 96 b8 16
\r
5361 00 00 mov WORD PTR [esi+5816], dx
\r
5362 0010d eb 13 jmp SHORT $LN2@tr_flush_b
\r
5364 0010f 66 d3 e2 shl dx, cl
\r
5365 00112 66 09 96 b8 16
\r
5366 00 00 or WORD PTR [esi+5816], dx
\r
5367 00119 83 c1 03 add ecx, 3
\r
5368 0011c 89 8e bc 16 00
\r
5369 00 mov DWORD PTR [esi+5820], ecx
\r
5372 ; 981 : send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
\r
5373 ; 982 : max_blindex+1);
\r
5375 00122 8b 45 fc mov eax, DWORD PTR _max_blindex$[ebp]
\r
5376 00125 8b 8e 28 0b 00
\r
5377 00 mov ecx, DWORD PTR [esi+2856]
\r
5378 0012b 8b 96 1c 0b 00
\r
5379 00 mov edx, DWORD PTR [esi+2844]
\r
5382 00133 03 cf add ecx, edi
\r
5384 00136 03 d7 add edx, edi
\r
5386 00139 e8 00 00 00 00 call _send_all_trees
\r
5388 ; 983 : compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree);
\r
5390 0013e 8d 86 88 09 00
\r
5391 00 lea eax, DWORD PTR [esi+2440]
\r
5393 00145 8d 8e 94 00 00
\r
5394 00 lea ecx, DWORD PTR [esi+148]
\r
5396 0014c 8b c6 mov eax, esi
\r
5397 0014e e8 00 00 00 00 call _compress_block
\r
5398 00153 83 c4 14 add esp, 20 ; 00000014H
\r
5399 00156 e9 8f 00 00 00 jmp $LN4@tr_flush_b
\r
5403 ; 974 : send_bits(s, (STATIC_TREES<<1)+last, 3);
\r
5405 0015b 8b 45 0c mov eax, DWORD PTR _last$[ebp]
\r
5406 0015e 8b 8e bc 16 00
\r
5407 00 mov ecx, DWORD PTR [esi+5820]
\r
5408 00164 83 c0 02 add eax, 2
\r
5409 00167 83 f9 0d cmp ecx, 13 ; 0000000dH
\r
5410 0016a 7e 57 jle SHORT $LN6@tr_flush_b
\r
5411 0016c 66 8b d0 mov dx, ax
\r
5412 0016f 66 d3 e2 shl dx, cl
\r
5413 00172 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5414 00175 bf 01 00 00 00 mov edi, 1
\r
5415 0017a 66 09 96 b8 16
\r
5416 00 00 or WORD PTR [esi+5816], dx
\r
5417 00181 0f b6 9e b8 16
\r
5418 00 00 movzx ebx, BYTE PTR [esi+5816]
\r
5419 00188 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5420 0018b 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
5421 0018e 01 7e 14 add DWORD PTR [esi+20], edi
\r
5422 00191 0f b6 9e b9 16
\r
5423 00 00 movzx ebx, BYTE PTR [esi+5817]
\r
5424 00198 8b 4e 14 mov ecx, DWORD PTR [esi+20]
\r
5425 0019b 8b 56 08 mov edx, DWORD PTR [esi+8]
\r
5426 0019e 88 1c 11 mov BYTE PTR [ecx+edx], bl
\r
5427 001a1 8b 96 bc 16 00
\r
5428 00 mov edx, DWORD PTR [esi+5820]
\r
5429 001a7 01 7e 14 add DWORD PTR [esi+20], edi
\r
5430 001aa b1 10 mov cl, 16 ; 00000010H
\r
5431 001ac 2a ca sub cl, dl
\r
5432 001ae 66 d3 e8 shr ax, cl
\r
5433 001b1 83 c2 f3 add edx, -13 ; fffffff3H
\r
5434 001b4 89 96 bc 16 00
\r
5435 00 mov DWORD PTR [esi+5820], edx
\r
5436 001ba 66 89 86 b8 16
\r
5437 00 00 mov WORD PTR [esi+5816], ax
\r
5438 001c1 eb 13 jmp SHORT $LN5@tr_flush_b
\r
5440 001c3 66 d3 e0 shl ax, cl
\r
5441 001c6 66 09 86 b8 16
\r
5442 00 00 or WORD PTR [esi+5816], ax
\r
5443 001cd 83 c1 03 add ecx, 3
\r
5444 001d0 89 8e bc 16 00
\r
5445 00 mov DWORD PTR [esi+5820], ecx
\r
5448 ; 975 : compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree);
\r
5450 001d6 68 00 00 00 00 push OFFSET _static_dtree
\r
5451 001db 68 00 00 00 00 push OFFSET _static_ltree
\r
5452 001e0 8b c6 mov eax, esi
\r
5453 001e2 e8 00 00 00 00 call _compress_block
\r
5455 001e7 83 c4 08 add esp, 8
\r
5458 ; 984 : #ifdef DEBUG
\r
5459 ; 985 : s->compressed_len += 3 + s->opt_len;
\r
5462 ; 988 : Assert (s->compressed_len == s->bits_sent, "bad compressed size");
\r
5463 ; 989 : /* The above check is made mod 2^32, for files larger than 512 MB
\r
5464 ; 990 : * and uLong implemented on 32 bits.
\r
5466 ; 992 : init_block(s);
\r
5468 001ea 8b d6 mov edx, esi
\r
5469 001ec e8 00 00 00 00 call _init_block
\r
5472 ; 994 : if (last) {
\r
5474 001f1 83 7d 0c 00 cmp DWORD PTR _last$[ebp], 0
\r
5475 001f5 74 07 je SHORT $LN1@tr_flush_b
\r
5477 ; 995 : bi_windup(s);
\r
5479 001f7 8b c6 mov eax, esi
\r
5480 001f9 e8 00 00 00 00 call _bi_windup
\r
5486 ; 996 : #ifdef DEBUG
\r
5487 ; 997 : s->compressed_len += 7; /* align on byte boundary */
\r
5490 ; 1000 : Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
\r
5491 ; 1001 : s->compressed_len-7*last));
\r
5494 00201 8b e5 mov esp, ebp
\r
5497 __tr_flush_block ENDP
\r
Code Review / simantics / sysdyn.git / blob