├── Decompressor
    ├── main.cpp
    ├── Decompressor.vcxproj.user
    ├── Decompressor.vcxproj.filters
    ├── include
    │   └── smx
    │   │   └── smx-headers.h
    └── Decompressor.vcxproj
├── zlib
    ├── zlib.vcxproj.user
    ├── inffast.h
    ├── gzclose.c
    ├── compress.c
    ├── inftrees.h
    ├── uncompr.c
    ├── zlib.vcxproj.filters
    ├── adler32.c
    ├── inffixed.h
    ├── inflate.h
    ├── gzguts.h
    ├── zutil.h
    ├── trees.h
    ├── zutil.c
    ├── zlib.vcxproj
    ├── inftrees.c
    ├── inffast.c
    ├── deflate.h
    ├── crc32.c
    ├── zconf.h
    ├── infback.c
    └── crc32.h
├── README.md
└── Decompressor.sln


/Decompressor/main.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Kailo97/Decompressor/HEAD/Decompressor/main.cpp


--------------------------------------------------------------------------------
/zlib/zlib.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup>
4 |     <ShowAllFiles>true</ShowAllFiles>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/Decompressor/Decompressor.vcxproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup>
4 |     <ShowAllFiles>false</ShowAllFiles>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/zlib/inffast.h:
--------------------------------------------------------------------------------
 1 | /* inffast.h -- header to use inffast.c
 2 |  * Copyright (C) 1995-2003, 2010 Mark Adler
 3 |  * For conditions of distribution and use, see copyright notice in zlib.h
 4 |  */
 5 | 
 6 | /* WARNING: this file should *not* be used by applications. It is
 7 |    part of the implementation of the compression library and is
 8 |    subject to change. Applications should only use zlib.h.
 9 |  */
10 | 
11 | void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Decompressor
 2 | (De)compressor for sourcemod's smx files
 3 | 
 4 | ### Download
 5 | Get it at [releases](https://github.com/Kailo97/Decompressor/releases) page!
 6 | 
 7 | ### Usage
 8 | Removes compression if it is present; Adds compression if it is missing.
 9 | 
10 | Name of file passed as 1st param (just move file on Decompressor.exe)
11 | ```
12 | Decompressor.exe <smx file>
13 | ```
14 | uncompressed.smx created if file was compressed, compressed.smx created if file wasn't compressed.
15 | 


--------------------------------------------------------------------------------
/zlib/gzclose.c:
--------------------------------------------------------------------------------
 1 | /* gzclose.c -- zlib gzclose() function
 2 |  * Copyright (C) 2004, 2010 Mark Adler
 3 |  * For conditions of distribution and use, see copyright notice in zlib.h
 4 |  */
 5 | 
 6 | #include "gzguts.h"
 7 | 
 8 | /* gzclose() is in a separate file so that it is linked in only if it is used.
 9 |    That way the other gzclose functions can be used instead to avoid linking in
10 |    unneeded compression or decompression routines. */
11 | int ZEXPORT gzclose(file)
12 |     gzFile file;
13 | {
14 | #ifndef NO_GZCOMPRESS
15 |     gz_statep state;
16 | 
17 |     if (file == NULL)
18 |         return Z_STREAM_ERROR;
19 |     state = (gz_statep)file;
20 | 
21 |     return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
22 | #else
23 |     return gzclose_r(file);
24 | #endif
25 | }
26 | 


--------------------------------------------------------------------------------
/Decompressor/Decompressor.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Исходные файлы">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Файлы заголовков">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Файлы ресурсов">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="main.cpp">
19 |       <Filter>Исходные файлы</Filter>
20 |     </ClCompile>
21 |   </ItemGroup>
22 | </Project>


--------------------------------------------------------------------------------
/zlib/compress.c:
--------------------------------------------------------------------------------
 1 | /* compress.c -- compress a memory buffer
 2 |  * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
 3 |  * For conditions of distribution and use, see copyright notice in zlib.h
 4 |  */
 5 | 
 6 | /* @(#) $Id$ */
 7 | 
 8 | #define ZLIB_INTERNAL
 9 | #include "zlib.h"
10 | 
11 | /* ===========================================================================
12 |      Compresses the source buffer into the destination buffer. The level
13 |    parameter has the same meaning as in deflateInit.  sourceLen is the byte
14 |    length of the source buffer. Upon entry, destLen is the total size of the
15 |    destination buffer, which must be at least 0.1% larger than sourceLen plus
16 |    12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
17 | 
18 |      compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
19 |    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
20 |    Z_STREAM_ERROR if the level parameter is invalid.
21 | */
22 | int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
23 |     Bytef *dest;
24 |     uLongf *destLen;
25 |     const Bytef *source;
26 |     uLong sourceLen;
27 |     int level;
28 | {
29 |     z_stream stream;
30 |     int err;
31 |     const uInt max = (uInt)-1;
32 |     uLong left;
33 | 
34 |     left = *destLen;
35 |     *destLen = 0;
36 | 
37 |     stream.zalloc = (alloc_func)0;
38 |     stream.zfree = (free_func)0;
39 |     stream.opaque = (voidpf)0;
40 | 
41 |     err = deflateInit(&stream, level);
42 |     if (err != Z_OK) return err;
43 | 
44 |     stream.next_out = dest;
45 |     stream.avail_out = 0;
46 |     stream.next_in = (z_const Bytef *)source;
47 |     stream.avail_in = 0;
48 | 
49 |     do {
50 |         if (stream.avail_out == 0) {
51 |             stream.avail_out = left > (uLong)max ? max : (uInt)left;
52 |             left -= stream.avail_out;
53 |         }
54 |         if (stream.avail_in == 0) {
55 |             stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
56 |             sourceLen -= stream.avail_in;
57 |         }
58 |         err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
59 |     } while (err == Z_OK);
60 | 
61 |     *destLen = stream.total_out;
62 |     deflateEnd(&stream);
63 |     return err == Z_STREAM_END ? Z_OK : err;
64 | }
65 | 
66 | /* ===========================================================================
67 |  */
68 | int ZEXPORT compress (dest, destLen, source, sourceLen)
69 |     Bytef *dest;
70 |     uLongf *destLen;
71 |     const Bytef *source;
72 |     uLong sourceLen;
73 | {
74 |     return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
75 | }
76 | 
77 | /* ===========================================================================
78 |      If the default memLevel or windowBits for deflateInit() is changed, then
79 |    this function needs to be updated.
80 |  */
81 | uLong ZEXPORT compressBound (sourceLen)
82 |     uLong sourceLen;
83 | {
84 |     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
85 |            (sourceLen >> 25) + 13;
86 | }
87 | 


--------------------------------------------------------------------------------
/zlib/inftrees.h:
--------------------------------------------------------------------------------
 1 | /* inftrees.h -- header to use inftrees.c
 2 |  * Copyright (C) 1995-2005, 2010 Mark Adler
 3 |  * For conditions of distribution and use, see copyright notice in zlib.h
 4 |  */
 5 | 
 6 | /* WARNING: this file should *not* be used by applications. It is
 7 |    part of the implementation of the compression library and is
 8 |    subject to change. Applications should only use zlib.h.
 9 |  */
10 | 
11 | /* Structure for decoding tables.  Each entry provides either the
12 |    information needed to do the operation requested by the code that
13 |    indexed that table entry, or it provides a pointer to another
14 |    table that indexes more bits of the code.  op indicates whether
15 |    the entry is a pointer to another table, a literal, a length or
16 |    distance, an end-of-block, or an invalid code.  For a table
17 |    pointer, the low four bits of op is the number of index bits of
18 |    that table.  For a length or distance, the low four bits of op
19 |    is the number of extra bits to get after the code.  bits is
20 |    the number of bits in this code or part of the code to drop off
21 |    of the bit buffer.  val is the actual byte to output in the case
22 |    of a literal, the base length or distance, or the offset from
23 |    the current table to the next table.  Each entry is four bytes. */
24 | typedef struct {
25 |     unsigned char op;           /* operation, extra bits, table bits */
26 |     unsigned char bits;         /* bits in this part of the code */
27 |     unsigned short val;         /* offset in table or code value */
28 | } code;
29 | 
30 | /* op values as set by inflate_table():
31 |     00000000 - literal
32 |     0000tttt - table link, tttt != 0 is the number of table index bits
33 |     0001eeee - length or distance, eeee is the number of extra bits
34 |     01100000 - end of block
35 |     01000000 - invalid code
36 |  */
37 | 
38 | /* Maximum size of the dynamic table.  The maximum number of code structures is
39 |    1444, which is the sum of 852 for literal/length codes and 592 for distance
40 |    codes.  These values were found by exhaustive searches using the program
41 |    examples/enough.c found in the zlib distribtution.  The arguments to that
42 |    program are the number of symbols, the initial root table size, and the
43 |    maximum bit length of a code.  "enough 286 9 15" for literal/length codes
44 |    returns returns 852, and "enough 30 6 15" for distance codes returns 592.
45 |    The initial root table size (9 or 6) is found in the fifth argument of the
46 |    inflate_table() calls in inflate.c and infback.c.  If the root table size is
47 |    changed, then these maximum sizes would be need to be recalculated and
48 |    updated. */
49 | #define ENOUGH_LENS 852
50 | #define ENOUGH_DISTS 592
51 | #define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
52 | 
53 | /* Type of code to build for inflate_table() */
54 | typedef enum {
55 |     CODES,
56 |     LENS,
57 |     DISTS
58 | } codetype;
59 | 
60 | int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
61 |                              unsigned codes, code FAR * FAR *table,
62 |                              unsigned FAR *bits, unsigned short FAR *work));
63 | 


--------------------------------------------------------------------------------
/zlib/uncompr.c:
--------------------------------------------------------------------------------
 1 | /* uncompr.c -- decompress a memory buffer
 2 |  * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
 3 |  * For conditions of distribution and use, see copyright notice in zlib.h
 4 |  */
 5 | 
 6 | /* @(#) $Id$ */
 7 | 
 8 | #define ZLIB_INTERNAL
 9 | #include "zlib.h"
10 | 
11 | /* ===========================================================================
12 |      Decompresses the source buffer into the destination buffer.  *sourceLen is
13 |    the byte length of the source buffer. Upon entry, *destLen is the total size
14 |    of the destination buffer, which must be large enough to hold the entire
15 |    uncompressed data. (The size of the uncompressed data must have been saved
16 |    previously by the compressor and transmitted to the decompressor by some
17 |    mechanism outside the scope of this compression library.) Upon exit,
18 |    *destLen is the size of the decompressed data and *sourceLen is the number
19 |    of source bytes consumed. Upon return, source + *sourceLen points to the
20 |    first unused input byte.
21 | 
22 |      uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
23 |    memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
24 |    Z_DATA_ERROR if the input data was corrupted, including if the input data is
25 |    an incomplete zlib stream.
26 | */
27 | int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
28 |     Bytef *dest;
29 |     uLongf *destLen;
30 |     const Bytef *source;
31 |     uLong *sourceLen;
32 | {
33 |     z_stream stream;
34 |     int err;
35 |     const uInt max = (uInt)-1;
36 |     uLong len, left;
37 |     Byte buf[1];    /* for detection of incomplete stream when *destLen == 0 */
38 | 
39 |     len = *sourceLen;
40 |     if (*destLen) {
41 |         left = *destLen;
42 |         *destLen = 0;
43 |     }
44 |     else {
45 |         left = 1;
46 |         dest = buf;
47 |     }
48 | 
49 |     stream.next_in = (z_const Bytef *)source;
50 |     stream.avail_in = 0;
51 |     stream.zalloc = (alloc_func)0;
52 |     stream.zfree = (free_func)0;
53 |     stream.opaque = (voidpf)0;
54 | 
55 |     err = inflateInit(&stream);
56 |     if (err != Z_OK) return err;
57 | 
58 |     stream.next_out = dest;
59 |     stream.avail_out = 0;
60 | 
61 |     do {
62 |         if (stream.avail_out == 0) {
63 |             stream.avail_out = left > (uLong)max ? max : (uInt)left;
64 |             left -= stream.avail_out;
65 |         }
66 |         if (stream.avail_in == 0) {
67 |             stream.avail_in = len > (uLong)max ? max : (uInt)len;
68 |             len -= stream.avail_in;
69 |         }
70 |         err = inflate(&stream, Z_NO_FLUSH);
71 |     } while (err == Z_OK);
72 | 
73 |     *sourceLen -= len + stream.avail_in;
74 |     if (dest != buf)
75 |         *destLen = stream.total_out;
76 |     else if (stream.total_out && err == Z_BUF_ERROR)
77 |         left = 1;
78 | 
79 |     inflateEnd(&stream);
80 |     return err == Z_STREAM_END ? Z_OK :
81 |            err == Z_NEED_DICT ? Z_DATA_ERROR  :
82 |            err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
83 |            err;
84 | }
85 | 
86 | int ZEXPORT uncompress (dest, destLen, source, sourceLen)
87 |     Bytef *dest;
88 |     uLongf *destLen;
89 |     const Bytef *source;
90 |     uLong sourceLen;
91 | {
92 |     return uncompress2(dest, destLen, source, &sourceLen);
93 | }
94 | 


--------------------------------------------------------------------------------
/zlib/zlib.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Исходные файлы">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Файлы заголовков">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Файлы ресурсов">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClCompile Include="uncompr.c">
19 |       <Filter>Исходные файлы</Filter>
20 |     </ClCompile>
21 |     <ClCompile Include="inflate.c">
22 |       <Filter>Исходные файлы</Filter>
23 |     </ClCompile>
24 |     <ClCompile Include="adler32.c">
25 |       <Filter>Исходные файлы</Filter>
26 |     </ClCompile>
27 |     <ClCompile Include="crc32.c">
28 |       <Filter>Исходные файлы</Filter>
29 |     </ClCompile>
30 |     <ClCompile Include="compress.c">
31 |       <Filter>Исходные файлы</Filter>
32 |     </ClCompile>
33 |     <ClCompile Include="deflate.c">
34 |       <Filter>Исходные файлы</Filter>
35 |     </ClCompile>
36 |     <ClCompile Include="gzclose.c">
37 |       <Filter>Исходные файлы</Filter>
38 |     </ClCompile>
39 |     <ClCompile Include="infback.c">
40 |       <Filter>Исходные файлы</Filter>
41 |     </ClCompile>
42 |     <ClCompile Include="inffast.c">
43 |       <Filter>Исходные файлы</Filter>
44 |     </ClCompile>
45 |     <ClCompile Include="inftrees.c">
46 |       <Filter>Исходные файлы</Filter>
47 |     </ClCompile>
48 |     <ClCompile Include="trees.c">
49 |       <Filter>Исходные файлы</Filter>
50 |     </ClCompile>
51 |     <ClCompile Include="zutil.c">
52 |       <Filter>Исходные файлы</Filter>
53 |     </ClCompile>
54 |   </ItemGroup>
55 |   <ItemGroup>
56 |     <ClInclude Include="crc32.h">
57 |       <Filter>Файлы заголовков</Filter>
58 |     </ClInclude>
59 |     <ClInclude Include="deflate.h">
60 |       <Filter>Файлы заголовков</Filter>
61 |     </ClInclude>
62 |     <ClInclude Include="gzguts.h">
63 |       <Filter>Файлы заголовков</Filter>
64 |     </ClInclude>
65 |     <ClInclude Include="inffast.h">
66 |       <Filter>Файлы заголовков</Filter>
67 |     </ClInclude>
68 |     <ClInclude Include="inffixed.h">
69 |       <Filter>Файлы заголовков</Filter>
70 |     </ClInclude>
71 |     <ClInclude Include="inflate.h">
72 |       <Filter>Файлы заголовков</Filter>
73 |     </ClInclude>
74 |     <ClInclude Include="inftrees.h">
75 |       <Filter>Файлы заголовков</Filter>
76 |     </ClInclude>
77 |     <ClInclude Include="trees.h">
78 |       <Filter>Файлы заголовков</Filter>
79 |     </ClInclude>
80 |     <ClInclude Include="zconf.h">
81 |       <Filter>Файлы заголовков</Filter>
82 |     </ClInclude>
83 |     <ClInclude Include="zlib.h">
84 |       <Filter>Файлы заголовков</Filter>
85 |     </ClInclude>
86 |     <ClInclude Include="zutil.h">
87 |       <Filter>Файлы заголовков</Filter>
88 |     </ClInclude>
89 |   </ItemGroup>
90 | </Project>


--------------------------------------------------------------------------------
/Decompressor.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.27130.0
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Decompressor", "Decompressor\Decompressor.vcxproj", "{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}"
 7 | EndProject
 8 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlib", "zlib\zlib.vcxproj", "{A954A18D-6FFA-480B-B1BD-E460F133AB66}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Itanium = Debug|Itanium
13 | 		Debug|x64 = Debug|x64
14 | 		Debug|x86 = Debug|x86
15 | 		Release|Itanium = Release|Itanium
16 | 		Release|x64 = Release|x64
17 | 		Release|x86 = Release|x86
18 | 		ReleaseWithoutAsm|Itanium = ReleaseWithoutAsm|Itanium
19 | 		ReleaseWithoutAsm|x64 = ReleaseWithoutAsm|x64
20 | 		ReleaseWithoutAsm|x86 = ReleaseWithoutAsm|x86
21 | 	EndGlobalSection
22 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
23 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Debug|Itanium.ActiveCfg = Debug|Win32
24 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Debug|x64.ActiveCfg = Debug|x64
25 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Debug|x64.Build.0 = Debug|x64
26 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Debug|x86.ActiveCfg = Debug|Win32
27 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Debug|x86.Build.0 = Debug|Win32
28 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Release|Itanium.ActiveCfg = Release|Win32
29 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Release|x64.ActiveCfg = Release|x64
30 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Release|x64.Build.0 = Release|x64
31 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Release|x86.ActiveCfg = Release|Win32
32 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.Release|x86.Build.0 = Release|Win32
33 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|Itanium.ActiveCfg = Release|Win32
34 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|Itanium.Build.0 = Release|Win32
35 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|x64.ActiveCfg = Release|x64
36 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|x64.Build.0 = Release|x64
37 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|x86.ActiveCfg = Release|Win32
38 | 		{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}.ReleaseWithoutAsm|x86.Build.0 = Release|Win32
39 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Debug|Itanium.ActiveCfg = Debug|Win32
40 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Debug|x64.ActiveCfg = Debug|x64
41 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Debug|x64.Build.0 = Debug|x64
42 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Debug|x86.ActiveCfg = Debug|Win32
43 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Debug|x86.Build.0 = Debug|Win32
44 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Release|Itanium.ActiveCfg = Release|Win32
45 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Release|x64.ActiveCfg = Release|x64
46 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Release|x64.Build.0 = Release|x64
47 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Release|x86.ActiveCfg = Release|Win32
48 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.Release|x86.Build.0 = Release|Win32
49 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|Itanium.ActiveCfg = Release|x64
50 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|Itanium.Build.0 = Release|x64
51 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|x64.ActiveCfg = Release|x64
52 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|x64.Build.0 = Release|x64
53 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|x86.ActiveCfg = Release|Win32
54 | 		{A954A18D-6FFA-480B-B1BD-E460F133AB66}.ReleaseWithoutAsm|x86.Build.0 = Release|Win32
55 | 	EndGlobalSection
56 | 	GlobalSection(SolutionProperties) = preSolution
57 | 		HideSolutionNode = FALSE
58 | 	EndGlobalSection
59 | 	GlobalSection(ExtensibilityGlobals) = postSolution
60 | 		SolutionGuid = {74A31A92-6BBC-47E3-BD8D-29B746D5A54C}
61 | 	EndGlobalSection
62 | EndGlobal
63 | 


--------------------------------------------------------------------------------
/zlib/adler32.c:
--------------------------------------------------------------------------------
  1 | /* adler32.c -- compute the Adler-32 checksum of a data stream
  2 |  * Copyright (C) 1995-2011, 2016 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* @(#) $Id$ */
  7 | 
  8 | #include "zutil.h"
  9 | 
 10 | local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
 11 | 
 12 | #define BASE 65521U     /* largest prime smaller than 65536 */
 13 | #define NMAX 5552
 14 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
 15 | 
 16 | #define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
 17 | #define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
 18 | #define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
 19 | #define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
 20 | #define DO16(buf)   DO8(buf,0); DO8(buf,8);
 21 | 
 22 | /* use NO_DIVIDE if your processor does not do division in hardware --
 23 |    try it both ways to see which is faster */
 24 | #ifdef NO_DIVIDE
 25 | /* note that this assumes BASE is 65521, where 65536 % 65521 == 15
 26 |    (thank you to John Reiser for pointing this out) */
 27 | #  define CHOP(a) \
 28 |     do { \
 29 |         unsigned long tmp = a >> 16; \
 30 |         a &= 0xffffUL; \
 31 |         a += (tmp << 4) - tmp; \
 32 |     } while (0)
 33 | #  define MOD28(a) \
 34 |     do { \
 35 |         CHOP(a); \
 36 |         if (a >= BASE) a -= BASE; \
 37 |     } while (0)
 38 | #  define MOD(a) \
 39 |     do { \
 40 |         CHOP(a); \
 41 |         MOD28(a); \
 42 |     } while (0)
 43 | #  define MOD63(a) \
 44 |     do { /* this assumes a is not negative */ \
 45 |         z_off64_t tmp = a >> 32; \
 46 |         a &= 0xffffffffL; \
 47 |         a += (tmp << 8) - (tmp << 5) + tmp; \
 48 |         tmp = a >> 16; \
 49 |         a &= 0xffffL; \
 50 |         a += (tmp << 4) - tmp; \
 51 |         tmp = a >> 16; \
 52 |         a &= 0xffffL; \
 53 |         a += (tmp << 4) - tmp; \
 54 |         if (a >= BASE) a -= BASE; \
 55 |     } while (0)
 56 | #else
 57 | #  define MOD(a) a %= BASE
 58 | #  define MOD28(a) a %= BASE
 59 | #  define MOD63(a) a %= BASE
 60 | #endif
 61 | 
 62 | /* ========================================================================= */
 63 | uLong ZEXPORT adler32_z(adler, buf, len)
 64 |     uLong adler;
 65 |     const Bytef *buf;
 66 |     z_size_t len;
 67 | {
 68 |     unsigned long sum2;
 69 |     unsigned n;
 70 | 
 71 |     /* split Adler-32 into component sums */
 72 |     sum2 = (adler >> 16) & 0xffff;
 73 |     adler &= 0xffff;
 74 | 
 75 |     /* in case user likes doing a byte at a time, keep it fast */
 76 |     if (len == 1) {
 77 |         adler += buf[0];
 78 |         if (adler >= BASE)
 79 |             adler -= BASE;
 80 |         sum2 += adler;
 81 |         if (sum2 >= BASE)
 82 |             sum2 -= BASE;
 83 |         return adler | (sum2 << 16);
 84 |     }
 85 | 
 86 |     /* initial Adler-32 value (deferred check for len == 1 speed) */
 87 |     if (buf == Z_NULL)
 88 |         return 1L;
 89 | 
 90 |     /* in case short lengths are provided, keep it somewhat fast */
 91 |     if (len < 16) {
 92 |         while (len--) {
 93 |             adler += *buf++;
 94 |             sum2 += adler;
 95 |         }
 96 |         if (adler >= BASE)
 97 |             adler -= BASE;
 98 |         MOD28(sum2);            /* only added so many BASE's */
 99 |         return adler | (sum2 << 16);
100 |     }
101 | 
102 |     /* do length NMAX blocks -- requires just one modulo operation */
103 |     while (len >= NMAX) {
104 |         len -= NMAX;
105 |         n = NMAX / 16;          /* NMAX is divisible by 16 */
106 |         do {
107 |             DO16(buf);          /* 16 sums unrolled */
108 |             buf += 16;
109 |         } while (--n);
110 |         MOD(adler);
111 |         MOD(sum2);
112 |     }
113 | 
114 |     /* do remaining bytes (less than NMAX, still just one modulo) */
115 |     if (len) {                  /* avoid modulos if none remaining */
116 |         while (len >= 16) {
117 |             len -= 16;
118 |             DO16(buf);
119 |             buf += 16;
120 |         }
121 |         while (len--) {
122 |             adler += *buf++;
123 |             sum2 += adler;
124 |         }
125 |         MOD(adler);
126 |         MOD(sum2);
127 |     }
128 | 
129 |     /* return recombined sums */
130 |     return adler | (sum2 << 16);
131 | }
132 | 
133 | /* ========================================================================= */
134 | uLong ZEXPORT adler32(adler, buf, len)
135 |     uLong adler;
136 |     const Bytef *buf;
137 |     uInt len;
138 | {
139 |     return adler32_z(adler, buf, len);
140 | }
141 | 
142 | /* ========================================================================= */
143 | local uLong adler32_combine_(adler1, adler2, len2)
144 |     uLong adler1;
145 |     uLong adler2;
146 |     z_off64_t len2;
147 | {
148 |     unsigned long sum1;
149 |     unsigned long sum2;
150 |     unsigned rem;
151 | 
152 |     /* for negative len, return invalid adler32 as a clue for debugging */
153 |     if (len2 < 0)
154 |         return 0xffffffffUL;
155 | 
156 |     /* the derivation of this formula is left as an exercise for the reader */
157 |     MOD63(len2);                /* assumes len2 >= 0 */
158 |     rem = (unsigned)len2;
159 |     sum1 = adler1 & 0xffff;
160 |     sum2 = rem * sum1;
161 |     MOD(sum2);
162 |     sum1 += (adler2 & 0xffff) + BASE - 1;
163 |     sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
164 |     if (sum1 >= BASE) sum1 -= BASE;
165 |     if (sum1 >= BASE) sum1 -= BASE;
166 |     if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
167 |     if (sum2 >= BASE) sum2 -= BASE;
168 |     return sum1 | (sum2 << 16);
169 | }
170 | 
171 | /* ========================================================================= */
172 | uLong ZEXPORT adler32_combine(adler1, adler2, len2)
173 |     uLong adler1;
174 |     uLong adler2;
175 |     z_off_t len2;
176 | {
177 |     return adler32_combine_(adler1, adler2, len2);
178 | }
179 | 
180 | uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
181 |     uLong adler1;
182 |     uLong adler2;
183 |     z_off64_t len2;
184 | {
185 |     return adler32_combine_(adler1, adler2, len2);
186 | }
187 | 


--------------------------------------------------------------------------------
/zlib/inffixed.h:
--------------------------------------------------------------------------------
 1 |     /* inffixed.h -- table for decoding fixed codes
 2 |      * Generated automatically by makefixed().
 3 |      */
 4 | 
 5 |     /* WARNING: this file should *not* be used by applications.
 6 |        It is part of the implementation of this library and is
 7 |        subject to change. Applications should only use zlib.h.
 8 |      */
 9 | 
10 |     static const code lenfix[512] = {
11 |         {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
12 |         {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
13 |         {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
14 |         {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
15 |         {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
16 |         {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
17 |         {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
18 |         {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
19 |         {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
20 |         {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
21 |         {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
22 |         {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
23 |         {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
24 |         {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
25 |         {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
26 |         {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
27 |         {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
28 |         {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
29 |         {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
30 |         {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
31 |         {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
32 |         {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
33 |         {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
34 |         {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
35 |         {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
36 |         {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
37 |         {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
38 |         {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
39 |         {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
40 |         {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
41 |         {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
42 |         {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
43 |         {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
44 |         {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
45 |         {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
46 |         {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
47 |         {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
48 |         {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
49 |         {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
50 |         {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
51 |         {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
52 |         {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
53 |         {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
54 |         {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
55 |         {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
56 |         {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
57 |         {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
58 |         {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
59 |         {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
60 |         {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
61 |         {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
62 |         {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
63 |         {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
64 |         {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
65 |         {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
66 |         {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
67 |         {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
68 |         {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
69 |         {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
70 |         {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
71 |         {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
72 |         {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
73 |         {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
74 |         {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
75 |         {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
76 |         {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
77 |         {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
78 |         {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
79 |         {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
80 |         {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
81 |         {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
82 |         {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
83 |         {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
84 |         {0,9,255}
85 |     };
86 | 
87 |     static const code distfix[32] = {
88 |         {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
89 |         {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
90 |         {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
91 |         {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
92 |         {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
93 |         {22,5,193},{64,5,0}
94 |     };
95 | 


--------------------------------------------------------------------------------
/zlib/inflate.h:
--------------------------------------------------------------------------------
  1 | /* inflate.h -- internal inflate state definition
  2 |  * Copyright (C) 1995-2016 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* WARNING: this file should *not* be used by applications. It is
  7 |    part of the implementation of the compression library and is
  8 |    subject to change. Applications should only use zlib.h.
  9 |  */
 10 | 
 11 | /* define NO_GZIP when compiling if you want to disable gzip header and
 12 |    trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
 13 |    the crc code when it is not needed.  For shared libraries, gzip decoding
 14 |    should be left enabled. */
 15 | #ifndef NO_GZIP
 16 | #  define GUNZIP
 17 | #endif
 18 | 
 19 | /* Possible inflate modes between inflate() calls */
 20 | typedef enum {
 21 |     HEAD = 16180,   /* i: waiting for magic header */
 22 |     FLAGS,      /* i: waiting for method and flags (gzip) */
 23 |     TIME,       /* i: waiting for modification time (gzip) */
 24 |     OS,         /* i: waiting for extra flags and operating system (gzip) */
 25 |     EXLEN,      /* i: waiting for extra length (gzip) */
 26 |     EXTRA,      /* i: waiting for extra bytes (gzip) */
 27 |     NAME,       /* i: waiting for end of file name (gzip) */
 28 |     COMMENT,    /* i: waiting for end of comment (gzip) */
 29 |     HCRC,       /* i: waiting for header crc (gzip) */
 30 |     DICTID,     /* i: waiting for dictionary check value */
 31 |     DICT,       /* waiting for inflateSetDictionary() call */
 32 |         TYPE,       /* i: waiting for type bits, including last-flag bit */
 33 |         TYPEDO,     /* i: same, but skip check to exit inflate on new block */
 34 |         STORED,     /* i: waiting for stored size (length and complement) */
 35 |         COPY_,      /* i/o: same as COPY below, but only first time in */
 36 |         COPY,       /* i/o: waiting for input or output to copy stored block */
 37 |         TABLE,      /* i: waiting for dynamic block table lengths */
 38 |         LENLENS,    /* i: waiting for code length code lengths */
 39 |         CODELENS,   /* i: waiting for length/lit and distance code lengths */
 40 |             LEN_,       /* i: same as LEN below, but only first time in */
 41 |             LEN,        /* i: waiting for length/lit/eob code */
 42 |             LENEXT,     /* i: waiting for length extra bits */
 43 |             DIST,       /* i: waiting for distance code */
 44 |             DISTEXT,    /* i: waiting for distance extra bits */
 45 |             MATCH,      /* o: waiting for output space to copy string */
 46 |             LIT,        /* o: waiting for output space to write literal */
 47 |     CHECK,      /* i: waiting for 32-bit check value */
 48 |     LENGTH,     /* i: waiting for 32-bit length (gzip) */
 49 |     DONE,       /* finished check, done -- remain here until reset */
 50 |     BAD,        /* got a data error -- remain here until reset */
 51 |     MEM,        /* got an inflate() memory error -- remain here until reset */
 52 |     SYNC        /* looking for synchronization bytes to restart inflate() */
 53 | } inflate_mode;
 54 | 
 55 | /*
 56 |     State transitions between above modes -
 57 | 
 58 |     (most modes can go to BAD or MEM on error -- not shown for clarity)
 59 | 
 60 |     Process header:
 61 |         HEAD -> (gzip) or (zlib) or (raw)
 62 |         (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
 63 |                   HCRC -> TYPE
 64 |         (zlib) -> DICTID or TYPE
 65 |         DICTID -> DICT -> TYPE
 66 |         (raw) -> TYPEDO
 67 |     Read deflate blocks:
 68 |             TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
 69 |             STORED -> COPY_ -> COPY -> TYPE
 70 |             TABLE -> LENLENS -> CODELENS -> LEN_
 71 |             LEN_ -> LEN
 72 |     Read deflate codes in fixed or dynamic block:
 73 |                 LEN -> LENEXT or LIT or TYPE
 74 |                 LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
 75 |                 LIT -> LEN
 76 |     Process trailer:
 77 |         CHECK -> LENGTH -> DONE
 78 |  */
 79 | 
 80 | /* State maintained between inflate() calls -- approximately 7K bytes, not
 81 |    including the allocated sliding window, which is up to 32K bytes. */
 82 | struct inflate_state {
 83 |     z_streamp strm;             /* pointer back to this zlib stream */
 84 |     inflate_mode mode;          /* current inflate mode */
 85 |     int last;                   /* true if processing last block */
 86 |     int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip,
 87 |                                    bit 2 true to validate check value */
 88 |     int havedict;               /* true if dictionary provided */
 89 |     int flags;                  /* gzip header method and flags (0 if zlib) */
 90 |     unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
 91 |     unsigned long check;        /* protected copy of check value */
 92 |     unsigned long total;        /* protected copy of output count */
 93 |     gz_headerp head;            /* where to save gzip header information */
 94 |         /* sliding window */
 95 |     unsigned wbits;             /* log base 2 of requested window size */
 96 |     unsigned wsize;             /* window size or zero if not using window */
 97 |     unsigned whave;             /* valid bytes in the window */
 98 |     unsigned wnext;             /* window write index */
 99 |     unsigned char FAR *window;  /* allocated sliding window, if needed */
100 |         /* bit accumulator */
101 |     unsigned long hold;         /* input bit accumulator */
102 |     unsigned bits;              /* number of bits in "in" */
103 |         /* for string and stored block copying */
104 |     unsigned length;            /* literal or length of data to copy */
105 |     unsigned offset;            /* distance back to copy string from */
106 |         /* for table and code decoding */
107 |     unsigned extra;             /* extra bits needed */
108 |         /* fixed and dynamic code tables */
109 |     code const FAR *lencode;    /* starting table for length/literal codes */
110 |     code const FAR *distcode;   /* starting table for distance codes */
111 |     unsigned lenbits;           /* index bits for lencode */
112 |     unsigned distbits;          /* index bits for distcode */
113 |         /* dynamic table building */
114 |     unsigned ncode;             /* number of code length code lengths */
115 |     unsigned nlen;              /* number of length code lengths */
116 |     unsigned ndist;             /* number of distance code lengths */
117 |     unsigned have;              /* number of code lengths in lens[] */
118 |     code FAR *next;             /* next available space in codes[] */
119 |     unsigned short lens[320];   /* temporary storage for code lengths */
120 |     unsigned short work[288];   /* work area for code table building */
121 |     code codes[ENOUGH];         /* space for code tables */
122 |     int sane;                   /* if false, allow invalid distance too far */
123 |     int back;                   /* bits back of last unprocessed length/lit */
124 |     unsigned was;               /* initial length of match */
125 | };
126 | 


--------------------------------------------------------------------------------
/zlib/gzguts.h:
--------------------------------------------------------------------------------
  1 | /* gzguts.h -- zlib internal header definitions for gz* operations
  2 |  * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | #ifdef _LARGEFILE64_SOURCE
  7 | #  ifndef _LARGEFILE_SOURCE
  8 | #    define _LARGEFILE_SOURCE 1
  9 | #  endif
 10 | #  ifdef _FILE_OFFSET_BITS
 11 | #    undef _FILE_OFFSET_BITS
 12 | #  endif
 13 | #endif
 14 | 
 15 | #ifdef HAVE_HIDDEN
 16 | #  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
 17 | #else
 18 | #  define ZLIB_INTERNAL
 19 | #endif
 20 | 
 21 | #include <stdio.h>
 22 | #include "zlib.h"
 23 | #ifdef STDC
 24 | #  include <string.h>
 25 | #  include <stdlib.h>
 26 | #  include <limits.h>
 27 | #endif
 28 | 
 29 | #ifndef _POSIX_SOURCE
 30 | #  define _POSIX_SOURCE
 31 | #endif
 32 | #include <fcntl.h>
 33 | 
 34 | #ifdef _WIN32
 35 | #  include <stddef.h>
 36 | #endif
 37 | 
 38 | #if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
 39 | #  include <io.h>
 40 | #endif
 41 | 
 42 | #if defined(_WIN32) || defined(__CYGWIN__)
 43 | #  define WIDECHAR
 44 | #endif
 45 | 
 46 | #ifdef WINAPI_FAMILY
 47 | #  define open _open
 48 | #  define read _read
 49 | #  define write _write
 50 | #  define close _close
 51 | #endif
 52 | 
 53 | #ifdef NO_DEFLATE       /* for compatibility with old definition */
 54 | #  define NO_GZCOMPRESS
 55 | #endif
 56 | 
 57 | #if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
 58 | #  ifndef HAVE_VSNPRINTF
 59 | #    define HAVE_VSNPRINTF
 60 | #  endif
 61 | #endif
 62 | 
 63 | #if defined(__CYGWIN__)
 64 | #  ifndef HAVE_VSNPRINTF
 65 | #    define HAVE_VSNPRINTF
 66 | #  endif
 67 | #endif
 68 | 
 69 | #if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
 70 | #  ifndef HAVE_VSNPRINTF
 71 | #    define HAVE_VSNPRINTF
 72 | #  endif
 73 | #endif
 74 | 
 75 | #ifndef HAVE_VSNPRINTF
 76 | #  ifdef MSDOS
 77 | /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
 78 |    but for now we just assume it doesn't. */
 79 | #    define NO_vsnprintf
 80 | #  endif
 81 | #  ifdef __TURBOC__
 82 | #    define NO_vsnprintf
 83 | #  endif
 84 | #  ifdef WIN32
 85 | /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
 86 | #    if !defined(vsnprintf) && !defined(NO_vsnprintf)
 87 | #      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
 88 | #         define vsnprintf _vsnprintf
 89 | #      endif
 90 | #    endif
 91 | #  endif
 92 | #  ifdef __SASC
 93 | #    define NO_vsnprintf
 94 | #  endif
 95 | #  ifdef VMS
 96 | #    define NO_vsnprintf
 97 | #  endif
 98 | #  ifdef __OS400__
 99 | #    define NO_vsnprintf
100 | #  endif
101 | #  ifdef __MVS__
102 | #    define NO_vsnprintf
103 | #  endif
104 | #endif
105 | 
106 | /* unlike snprintf (which is required in C99), _snprintf does not guarantee
107 |    null termination of the result -- however this is only used in gzlib.c where
108 |    the result is assured to fit in the space provided */
109 | #if defined(_MSC_VER) && _MSC_VER < 1900
110 | #  define snprintf _snprintf
111 | #endif
112 | 
113 | #ifndef local
114 | #  define local static
115 | #endif
116 | /* since "static" is used to mean two completely different things in C, we
117 |    define "local" for the non-static meaning of "static", for readability
118 |    (compile with -Dlocal if your debugger can't find static symbols) */
119 | 
120 | /* gz* functions always use library allocation functions */
121 | #ifndef STDC
122 |   extern voidp  malloc OF((uInt size));
123 |   extern void   free   OF((voidpf ptr));
124 | #endif
125 | 
126 | /* get errno and strerror definition */
127 | #if defined UNDER_CE
128 | #  include <windows.h>
129 | #  define zstrerror() gz_strwinerror((DWORD)GetLastError())
130 | #else
131 | #  ifndef NO_STRERROR
132 | #    include <errno.h>
133 | #    define zstrerror() strerror(errno)
134 | #  else
135 | #    define zstrerror() "stdio error (consult errno)"
136 | #  endif
137 | #endif
138 | 
139 | /* provide prototypes for these when building zlib without LFS */
140 | #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
141 |     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
142 |     ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
143 |     ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
144 |     ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
145 | #endif
146 | 
147 | /* default memLevel */
148 | #if MAX_MEM_LEVEL >= 8
149 | #  define DEF_MEM_LEVEL 8
150 | #else
151 | #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
152 | #endif
153 | 
154 | /* default i/o buffer size -- double this for output when reading (this and
155 |    twice this must be able to fit in an unsigned type) */
156 | #define GZBUFSIZE 8192
157 | 
158 | /* gzip modes, also provide a little integrity check on the passed structure */
159 | #define GZ_NONE 0
160 | #define GZ_READ 7247
161 | #define GZ_WRITE 31153
162 | #define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
163 | 
164 | /* values for gz_state how */
165 | #define LOOK 0      /* look for a gzip header */
166 | #define COPY 1      /* copy input directly */
167 | #define GZIP 2      /* decompress a gzip stream */
168 | 
169 | /* internal gzip file state data structure */
170 | typedef struct {
171 |         /* exposed contents for gzgetc() macro */
172 |     struct gzFile_s x;      /* "x" for exposed */
173 |                             /* x.have: number of bytes available at x.next */
174 |                             /* x.next: next output data to deliver or write */
175 |                             /* x.pos: current position in uncompressed data */
176 |         /* used for both reading and writing */
177 |     int mode;               /* see gzip modes above */
178 |     int fd;                 /* file descriptor */
179 |     char *path;             /* path or fd for error messages */
180 |     unsigned size;          /* buffer size, zero if not allocated yet */
181 |     unsigned want;          /* requested buffer size, default is GZBUFSIZE */
182 |     unsigned char *in;      /* input buffer (double-sized when writing) */
183 |     unsigned char *out;     /* output buffer (double-sized when reading) */
184 |     int direct;             /* 0 if processing gzip, 1 if transparent */
185 |         /* just for reading */
186 |     int how;                /* 0: get header, 1: copy, 2: decompress */
187 |     z_off64_t start;        /* where the gzip data started, for rewinding */
188 |     int eof;                /* true if end of input file reached */
189 |     int past;               /* true if read requested past end */
190 |         /* just for writing */
191 |     int level;              /* compression level */
192 |     int strategy;           /* compression strategy */
193 |         /* seek request */
194 |     z_off64_t skip;         /* amount to skip (already rewound if backwards) */
195 |     int seek;               /* true if seek request pending */
196 |         /* error information */
197 |     int err;                /* error code */
198 |     char *msg;              /* error message */
199 |         /* zlib inflate or deflate stream */
200 |     z_stream strm;          /* stream structure in-place (not a pointer) */
201 | } gz_state;
202 | typedef gz_state FAR *gz_statep;
203 | 
204 | /* shared functions */
205 | void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
206 | #if defined UNDER_CE
207 | char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
208 | #endif
209 | 
210 | /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
211 |    value -- needed when comparing unsigned to z_off64_t, which is signed
212 |    (possible z_off64_t types off_t, off64_t, and long are all signed) */
213 | #ifdef INT_MAX
214 | #  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
215 | #else
216 | unsigned ZLIB_INTERNAL gz_intmax OF((void));
217 | #  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
218 | #endif
219 | 


--------------------------------------------------------------------------------
/Decompressor/include/smx/smx-headers.h:
--------------------------------------------------------------------------------
  1 | // vim: set sts=2 ts=8 sw=2 tw=99 et:
  2 | // =============================================================================
  3 | // SourcePawn
  4 | // Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
  5 | // =============================================================================
  6 | // 
  7 | // This program is free software; you can redistribute it and/or modify it under
  8 | // the terms of the GNU General Public License, version 3.0, as published by the
  9 | // Free Software Foundation.
 10 | // 
 11 | // This program is distributed in the hope that it will be useful, but WITHOUT
 12 | // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 13 | // FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 14 | // details.
 15 | // 
 16 | // You should have received a copy of the GNU General Public License along with
 17 | // this program.  If not, see <http://www.gnu.org/licenses/>.
 18 | // 
 19 | // As a special exception, AlliedModders LLC gives you permission to link the
 20 | // code of this program (as well as its derivative works) to "Half-Life 2," the
 21 | // "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
 22 | // by the Valve Corporation.  You must obey the GNU General Public License in
 23 | // all respects for all other code used.  Additionally, AlliedModders LLC grants
 24 | // this exception to all derivative works.  AlliedModders LLC defines further
 25 | // exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
 26 | // or <http://www.sourcemod.net/license.php>.
 27 | 
 28 | #ifndef _INCLUDE_SPFILE_HEADERS_H
 29 | #define _INCLUDE_SPFILE_HEADERS_H
 30 | 
 31 | #include <stddef.h>
 32 | #include <stdint.h>
 33 | 
 34 | namespace sp {
 35 | 
 36 | struct SmxConsts
 37 | {
 38 |   // SourcePawn File Format (SPFF) magic number.
 39 |   static const uint32_t FILE_MAGIC = 0x53504646;
 40 | 
 41 |   // File format verison number.
 42 |   // 0x0101 - SourcePawn 1.0; initial version used by SourceMod 1.0.
 43 |   // 0x0102 - SourcePawn 1.1; used by SourceMod 1.1+.
 44 |   // 0x0200 - Used by spcomp2.
 45 |   //
 46 |   // The major version bits (8-15) indicate a product number. Consumers should
 47 |   // reject any version for a different product.
 48 |   //
 49 |   // The minor version bits (0-7) indicate a compatibility revision. Any minor
 50 |   // version higher than the current version should be rejected.
 51 |   static const uint16_t SP1_VERSION_1_0 = 0x0101;
 52 |   static const uint16_t SP1_VERSION_1_1 = 0x0102;
 53 |   static const uint16_t SP1_VERSION_1_7 = 0x0107;
 54 |   static const uint16_t SP1_VERSION_MIN = SP1_VERSION_1_0;
 55 |   static const uint16_t SP1_VERSION_MAX = SP1_VERSION_1_7;
 56 |   static const uint16_t SP2_VERSION_MIN = 0x0200;
 57 |   static const uint16_t SP2_VERSION_MAX = 0x0200;
 58 | 
 59 |   // Compression types.
 60 |   static const uint8_t FILE_COMPRESSION_NONE = 0;
 61 |   static const uint8_t FILE_COMPRESSION_GZ = 1;
 62 | 
 63 |   // SourcePawn 1.
 64 |   static const uint8_t CODE_VERSION_JIT_1_0 = 9;
 65 |   static const uint8_t CODE_VERSION_JIT_1_1 = 10;
 66 |   static const uint8_t CODE_VERSION_JIT_1_7 = 11;
 67 |   static const uint8_t CODE_VERSION_SP1_MIN = CODE_VERSION_JIT_1_0;
 68 |   static const uint8_t CODE_VERSION_SP1_MAX = CODE_VERSION_JIT_1_1;
 69 | 
 70 |   // For SP1 consumers, the container version may not be checked, but usually
 71 |   // the code version is. This constant allows newer containers to be rejected
 72 |   // in those applications.
 73 |   static const uint8_t CODE_VERSION_REJECT = 0x7F;
 74 | };
 75 | 
 76 | // These structures are byte-packed.
 77 | #if defined __GNUC__
 78 | # pragma pack(1)
 79 | #else
 80 | # pragma pack(push)
 81 | # pragma pack(1)
 82 | #endif
 83 | 
 84 | // The very first bytes in a .smx file. The .smx file format is a container for
 85 | // arbitrary sections, though to actually load a .smx file certain sections
 86 | // must be present. The on-disk format has four major regions, in order:
 87 | //   1. The header (sp_file_hdr_t).
 88 | //   2. The section list (sp_file_section_t).
 89 | //   3. The string table.
 90 | //   4. The section contents.
 91 | //
 92 | // Although any part of the file after the header can be compressed, by default
 93 | // only the section contents are, and the section list and string table are not.
 94 | typedef struct sp_file_hdr_s
 95 | {
 96 |   // Magic number and version number.
 97 |   uint32_t  magic;
 98 |   uint16_t  version;
 99 | 
100 |   // disksize, imagesize, and dataoffs (at the end) describe a region of the
101 |   // file that may be compressed. The region must occur after the initial
102 |   // sp_file_hdr_t header. For SourceMod compatibility, the meanings are as
103 |   // follows.
104 |   //
105 |   // Without compression:
106 |   //   imagesize is the amount of bytes that must be read into memory to parse
107 |   //             the SMX container, starting from the first byte of the file.
108 |   //   disksize is undefined.
109 |   //   dataoffs is undefined.
110 |   //
111 |   // With compression:
112 |   //   dataoffs is an offset to the start of the compression region.
113 |   //   disksize is the length of the compressed region, in bytes, plus dataoffs.
114 |   //   imagesize is the size of the entire SMX container after decompression.
115 |   //
116 |   //   This means that at least |imagesize-dataoffs| must be allocated to
117 |   //   decompress, and the compressed region's length is |datasize-dataoffs|.
118 |   //
119 |   // The compressed region should always be expanded "in-place". That is, to
120 |   // parse the container, the compressed bytes should be replaced with
121 |   // decompressed bytes.
122 |   //
123 |   // Note: This scheme may seem odd. It's a combination of historical debt and
124 |   // previously unspecified behavior. The original .amx file format contained
125 |   // an on-disk structure that supported an endian-agnostic variable-length 
126 |   // encoding of its data section, and this structure was loaded directly into
127 |   // memory and used as the VM context. AMX Mod X later developed a container
128 |   // format called ".amxx" as a "universal binary" for 32-bit and 64-bit
129 |   // plugins. This format dropped compact encoding, but supported gzip. The
130 |   // disksize/imagesize oddness made its way to this file format. When .smx
131 |   // was created for SourceMod, it persisted even though AMX was dropped
132 |   // entirely. So it goes.
133 |   uint8_t   compression;
134 |   uint32_t  disksize;
135 |   uint32_t  imagesize;
136 | 
137 |   // Number of named file sections.
138 |   uint8_t   sections;
139 | 
140 |   // Offset to the string table. Each string is null-terminated. The string
141 |   // table is only used for strings related to parsing the container itself.
142 |   // For SourcePawn, a separate ".names" section exists for Pawn-specific data.
143 |   uint32_t  stringtab;
144 | 
145 |   // Offset to where compression begins.
146 |   uint32_t  dataoffs;
147 | } sp_file_hdr_t;
148 | 
149 | // Each section is written immediately after the header.
150 | typedef struct sp_file_section_s
151 | {
152 |   uint32_t  nameoffs;  /**< Offset into the string table. */
153 |   uint32_t  dataoffs;  /**< Offset into the file for the section contents. */
154 |   uint32_t  size;      /**< Size of this section's contents. */
155 | } sp_file_section_t;
156 | 
157 | // Code section. This is used only in SP1, but is emitted by default for legacy
158 | // systems which check |codeversion| but not the SMX file version.
159 | typedef struct sp_file_code_s
160 | {
161 |   uint32_t  codesize;    /**< Size of the code section. */
162 |   uint8_t   cellsize;    /**< Cellsize in bytes. */
163 |   uint8_t   codeversion; /**< Version of opcodes supported. */
164 |   uint16_t  flags;       /**< Flags. */
165 |   uint32_t  main;        /**< Address to "main". */
166 |   uint32_t  code;        /**< Offset to bytecode, relative to the start of this section. */
167 | } sp_file_code_t;
168 | 
169 | #if defined __GNUC__
170 | # pragma pack()
171 | #else
172 | # pragma pack(pop)
173 | #endif
174 | 
175 | } // namespace sp
176 | 
177 | #endif //_INCLUDE_SPFILE_HEADERS_H
178 | 


--------------------------------------------------------------------------------
/zlib/zutil.h:
--------------------------------------------------------------------------------
  1 | /* zutil.h -- internal interface and configuration of the compression library
  2 |  * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* WARNING: this file should *not* be used by applications. It is
  7 |    part of the implementation of the compression library and is
  8 |    subject to change. Applications should only use zlib.h.
  9 |  */
 10 | 
 11 | /* @(#) $Id$ */
 12 | 
 13 | #ifndef ZUTIL_H
 14 | #define ZUTIL_H
 15 | 
 16 | #ifdef HAVE_HIDDEN
 17 | #  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
 18 | #else
 19 | #  define ZLIB_INTERNAL
 20 | #endif
 21 | 
 22 | #include "zlib.h"
 23 | 
 24 | #if defined(STDC) && !defined(Z_SOLO)
 25 | #  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
 26 | #    include <stddef.h>
 27 | #  endif
 28 | #  include <string.h>
 29 | #  include <stdlib.h>
 30 | #endif
 31 | 
 32 | #ifdef Z_SOLO
 33 |    typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
 34 | #endif
 35 | 
 36 | #ifndef local
 37 | #  define local static
 38 | #endif
 39 | /* since "static" is used to mean two completely different things in C, we
 40 |    define "local" for the non-static meaning of "static", for readability
 41 |    (compile with -Dlocal if your debugger can't find static symbols) */
 42 | 
 43 | typedef unsigned char  uch;
 44 | typedef uch FAR uchf;
 45 | typedef unsigned short ush;
 46 | typedef ush FAR ushf;
 47 | typedef unsigned long  ulg;
 48 | 
 49 | extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
 50 | /* (size given to avoid silly warnings with Visual C++) */
 51 | 
 52 | #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
 53 | 
 54 | #define ERR_RETURN(strm,err) \
 55 |   return (strm->msg = ERR_MSG(err), (err))
 56 | /* To be used only when the state is known to be valid */
 57 | 
 58 |         /* common constants */
 59 | 
 60 | #ifndef DEF_WBITS
 61 | #  define DEF_WBITS MAX_WBITS
 62 | #endif
 63 | /* default windowBits for decompression. MAX_WBITS is for compression only */
 64 | 
 65 | #if MAX_MEM_LEVEL >= 8
 66 | #  define DEF_MEM_LEVEL 8
 67 | #else
 68 | #  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
 69 | #endif
 70 | /* default memLevel */
 71 | 
 72 | #define STORED_BLOCK 0
 73 | #define STATIC_TREES 1
 74 | #define DYN_TREES    2
 75 | /* The three kinds of block type */
 76 | 
 77 | #define MIN_MATCH  3
 78 | #define MAX_MATCH  258
 79 | /* The minimum and maximum match lengths */
 80 | 
 81 | #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
 82 | 
 83 |         /* target dependencies */
 84 | 
 85 | #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
 86 | #  define OS_CODE  0x00
 87 | #  ifndef Z_SOLO
 88 | #    if defined(__TURBOC__) || defined(__BORLANDC__)
 89 | #      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
 90 |          /* Allow compilation with ANSI keywords only enabled */
 91 |          void _Cdecl farfree( void *block );
 92 |          void *_Cdecl farmalloc( unsigned long nbytes );
 93 | #      else
 94 | #        include <alloc.h>
 95 | #      endif
 96 | #    else /* MSC or DJGPP */
 97 | #      include <malloc.h>
 98 | #    endif
 99 | #  endif
100 | #endif
101 | 
102 | #ifdef AMIGA
103 | #  define OS_CODE  1
104 | #endif
105 | 
106 | #if defined(VAXC) || defined(VMS)
107 | #  define OS_CODE  2
108 | #  define F_OPEN(name, mode) \
109 |      fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
110 | #endif
111 | 
112 | #ifdef __370__
113 | #  if __TARGET_LIB__ < 0x20000000
114 | #    define OS_CODE 4
115 | #  elif __TARGET_LIB__ < 0x40000000
116 | #    define OS_CODE 11
117 | #  else
118 | #    define OS_CODE 8
119 | #  endif
120 | #endif
121 | 
122 | #if defined(ATARI) || defined(atarist)
123 | #  define OS_CODE  5
124 | #endif
125 | 
126 | #ifdef OS2
127 | #  define OS_CODE  6
128 | #  if defined(M_I86) && !defined(Z_SOLO)
129 | #    include <malloc.h>
130 | #  endif
131 | #endif
132 | 
133 | #if defined(MACOS) || defined(TARGET_OS_MAC)
134 | #  define OS_CODE  7
135 | #  ifndef Z_SOLO
136 | #    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
137 | #      include <unix.h> /* for fdopen */
138 | #    else
139 | #      ifndef fdopen
140 | #        define fdopen(fd,mode) NULL /* No fdopen() */
141 | #      endif
142 | #    endif
143 | #  endif
144 | #endif
145 | 
146 | #ifdef __acorn
147 | #  define OS_CODE 13
148 | #endif
149 | 
150 | #if defined(WIN32) && !defined(__CYGWIN__)
151 | #  define OS_CODE  10
152 | #endif
153 | 
154 | #ifdef _BEOS_
155 | #  define OS_CODE  16
156 | #endif
157 | 
158 | #ifdef __TOS_OS400__
159 | #  define OS_CODE 18
160 | #endif
161 | 
162 | #ifdef __APPLE__
163 | #  define OS_CODE 19
164 | #endif
165 | 
166 | #if defined(_BEOS_) || defined(RISCOS)
167 | #  define fdopen(fd,mode) NULL /* No fdopen() */
168 | #endif
169 | 
170 | #if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
171 | #  if defined(_WIN32_WCE)
172 | #    define fdopen(fd,mode) NULL /* No fdopen() */
173 | #    ifndef _PTRDIFF_T_DEFINED
174 |        typedef int ptrdiff_t;
175 | #      define _PTRDIFF_T_DEFINED
176 | #    endif
177 | #  else
178 | #    define fdopen(fd,type)  _fdopen(fd,type)
179 | #  endif
180 | #endif
181 | 
182 | #if defined(__BORLANDC__) && !defined(MSDOS)
183 |   #pragma warn -8004
184 |   #pragma warn -8008
185 |   #pragma warn -8066
186 | #endif
187 | 
188 | /* provide prototypes for these when building zlib without LFS */
189 | #if !defined(_WIN32) && \
190 |     (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
191 |     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
192 |     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
193 | #endif
194 | 
195 |         /* common defaults */
196 | 
197 | #ifndef OS_CODE
198 | #  define OS_CODE  3     /* assume Unix */
199 | #endif
200 | 
201 | #ifndef F_OPEN
202 | #  define F_OPEN(name, mode) fopen((name), (mode))
203 | #endif
204 | 
205 |          /* functions */
206 | 
207 | #if defined(pyr) || defined(Z_SOLO)
208 | #  define NO_MEMCPY
209 | #endif
210 | #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
211 |  /* Use our own functions for small and medium model with MSC <= 5.0.
212 |   * You may have to use the same strategy for Borland C (untested).
213 |   * The __SC__ check is for Symantec.
214 |   */
215 | #  define NO_MEMCPY
216 | #endif
217 | #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
218 | #  define HAVE_MEMCPY
219 | #endif
220 | #ifdef HAVE_MEMCPY
221 | #  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
222 | #    define zmemcpy _fmemcpy
223 | #    define zmemcmp _fmemcmp
224 | #    define zmemzero(dest, len) _fmemset(dest, 0, len)
225 | #  else
226 | #    define zmemcpy memcpy
227 | #    define zmemcmp memcmp
228 | #    define zmemzero(dest, len) memset(dest, 0, len)
229 | #  endif
230 | #else
231 |    void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
232 |    int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
233 |    void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
234 | #endif
235 | 
236 | /* Diagnostic functions */
237 | #ifdef ZLIB_DEBUG
238 | #  include <stdio.h>
239 |    extern int ZLIB_INTERNAL z_verbose;
240 |    extern void ZLIB_INTERNAL z_error OF((char *m));
241 | #  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
242 | #  define Trace(x) {if (z_verbose>=0) fprintf x ;}
243 | #  define Tracev(x) {if (z_verbose>0) fprintf x ;}
244 | #  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
245 | #  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
246 | #  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
247 | #else
248 | #  define Assert(cond,msg)
249 | #  define Trace(x)
250 | #  define Tracev(x)
251 | #  define Tracevv(x)
252 | #  define Tracec(c,x)
253 | #  define Tracecv(c,x)
254 | #endif
255 | 
256 | #ifndef Z_SOLO
257 |    voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
258 |                                     unsigned size));
259 |    void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
260 | #endif
261 | 
262 | #define ZALLOC(strm, items, size) \
263 |            (*((strm)->zalloc))((strm)->opaque, (items), (size))
264 | #define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
265 | #define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
266 | 
267 | /* Reverse the bytes in a 32-bit value */
268 | #define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
269 |                     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
270 | 
271 | #endif /* ZUTIL_H */
272 | 


--------------------------------------------------------------------------------
/Decompressor/Decompressor.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>15.0</VCProjectVersion>
 23 |     <ProjectGuid>{B8DB3FEB-9A39-46ED-8570-DD3E9E420F37}</ProjectGuid>
 24 |     <Keyword>Win32Proj</Keyword>
 25 |     <RootNamespace>Decompressor</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 30 |     <ConfigurationType>Application</ConfigurationType>
 31 |     <UseDebugLibraries>true</UseDebugLibraries>
 32 |     <PlatformToolset>v141</PlatformToolset>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 36 |     <ConfigurationType>Application</ConfigurationType>
 37 |     <UseDebugLibraries>false</UseDebugLibraries>
 38 |     <PlatformToolset>v141</PlatformToolset>
 39 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 40 |     <CharacterSet>Unicode</CharacterSet>
 41 |   </PropertyGroup>
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 43 |     <ConfigurationType>Application</ConfigurationType>
 44 |     <UseDebugLibraries>true</UseDebugLibraries>
 45 |     <PlatformToolset>v141</PlatformToolset>
 46 |     <CharacterSet>Unicode</CharacterSet>
 47 |   </PropertyGroup>
 48 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 49 |     <ConfigurationType>Application</ConfigurationType>
 50 |     <UseDebugLibraries>false</UseDebugLibraries>
 51 |     <PlatformToolset>v141</PlatformToolset>
 52 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 53 |     <CharacterSet>Unicode</CharacterSet>
 54 |   </PropertyGroup>
 55 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 56 |   <ImportGroup Label="ExtensionSettings">
 57 |   </ImportGroup>
 58 |   <ImportGroup Label="Shared">
 59 |   </ImportGroup>
 60 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 61 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 62 |   </ImportGroup>
 63 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 64 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 65 |   </ImportGroup>
 66 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 67 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 68 |   </ImportGroup>
 69 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 70 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 71 |   </ImportGroup>
 72 |   <PropertyGroup Label="UserMacros" />
 73 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 74 |     <LinkIncremental>true</LinkIncremental>
 75 |     <IncludePath>$(ProjectDir)include;$(SolutionDir)zlib;$(IncludePath)</IncludePath>
 76 |   </PropertyGroup>
 77 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 78 |     <LinkIncremental>true</LinkIncremental>
 79 |     <IncludePath>$(ProjectDir)include;$(SolutionDir)zlib;$(IncludePath)</IncludePath>
 80 |   </PropertyGroup>
 81 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 82 |     <LinkIncremental>false</LinkIncremental>
 83 |     <IncludePath>$(ProjectDir)include;$(SolutionDir)zlib;$(IncludePath)</IncludePath>
 84 |   </PropertyGroup>
 85 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 86 |     <LinkIncremental>false</LinkIncremental>
 87 |     <IncludePath>$(ProjectDir)include;$(SolutionDir)zlib;$(IncludePath)</IncludePath>
 88 |   </PropertyGroup>
 89 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 90 |     <ClCompile>
 91 |       <WarningLevel>Level3</WarningLevel>
 92 |       <Optimization>Disabled</Optimization>
 93 |       <SDLCheck>true</SDLCheck>
 94 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 95 |       <ConformanceMode>true</ConformanceMode>
 96 |     </ClCompile>
 97 |     <Link>
 98 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 99 |       <SubSystem>Console</SubSystem>
100 |       <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
101 |     </Link>
102 |   </ItemDefinitionGroup>
103 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
104 |     <ClCompile>
105 |       <WarningLevel>Level3</WarningLevel>
106 |       <Optimization>Disabled</Optimization>
107 |       <SDLCheck>true</SDLCheck>
108 |       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
109 |       <ConformanceMode>true</ConformanceMode>
110 |     </ClCompile>
111 |     <Link>
112 |       <GenerateDebugInformation>true</GenerateDebugInformation>
113 |       <SubSystem>Console</SubSystem>
114 |     </Link>
115 |   </ItemDefinitionGroup>
116 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
117 |     <ClCompile>
118 |       <WarningLevel>Level3</WarningLevel>
119 |       <Optimization>MaxSpeed</Optimization>
120 |       <FunctionLevelLinking>true</FunctionLevelLinking>
121 |       <IntrinsicFunctions>true</IntrinsicFunctions>
122 |       <SDLCheck>true</SDLCheck>
123 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
124 |       <ConformanceMode>true</ConformanceMode>
125 |     </ClCompile>
126 |     <Link>
127 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
128 |       <OptimizeReferences>true</OptimizeReferences>
129 |       <GenerateDebugInformation>true</GenerateDebugInformation>
130 |       <SubSystem>Console</SubSystem>
131 |       <LinkTimeCodeGeneration>UseFastLinkTimeCodeGeneration</LinkTimeCodeGeneration>
132 |     </Link>
133 |   </ItemDefinitionGroup>
134 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
135 |     <ClCompile>
136 |       <WarningLevel>Level3</WarningLevel>
137 |       <Optimization>MaxSpeed</Optimization>
138 |       <FunctionLevelLinking>true</FunctionLevelLinking>
139 |       <IntrinsicFunctions>true</IntrinsicFunctions>
140 |       <SDLCheck>true</SDLCheck>
141 |       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
142 |       <ConformanceMode>true</ConformanceMode>
143 |     </ClCompile>
144 |     <Link>
145 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
146 |       <OptimizeReferences>true</OptimizeReferences>
147 |       <GenerateDebugInformation>true</GenerateDebugInformation>
148 |       <SubSystem>Console</SubSystem>
149 |     </Link>
150 |   </ItemDefinitionGroup>
151 |   <ItemGroup>
152 |     <ClCompile Include="main.cpp" />
153 |   </ItemGroup>
154 |   <ItemGroup>
155 |     <ProjectReference Include="..\zlib\zlib.vcxproj">
156 |       <Project>{a954a18d-6ffa-480b-b1bd-e460f133ab66}</Project>
157 |     </ProjectReference>
158 |   </ItemGroup>
159 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
160 |   <ImportGroup Label="ExtensionTargets">
161 |   </ImportGroup>
162 | </Project>


--------------------------------------------------------------------------------
/zlib/trees.h:
--------------------------------------------------------------------------------
  1 | /* header created automatically with -DGEN_TREES_H */
  2 | 
  3 | local const ct_data static_ltree[L_CODES+2] = {
  4 | {{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
  5 | {{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
  6 | {{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
  7 | {{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
  8 | {{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
  9 | {{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
 10 | {{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
 11 | {{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
 12 | {{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
 13 | {{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
 14 | {{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
 15 | {{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
 16 | {{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
 17 | {{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
 18 | {{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
 19 | {{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
 20 | {{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
 21 | {{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
 22 | {{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
 23 | {{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
 24 | {{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
 25 | {{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
 26 | {{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
 27 | {{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
 28 | {{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
 29 | {{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
 30 | {{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
 31 | {{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
 32 | {{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
 33 | {{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
 34 | {{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
 35 | {{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
 36 | {{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
 37 | {{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
 38 | {{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
 39 | {{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
 40 | {{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
 41 | {{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
 42 | {{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
 43 | {{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
 44 | {{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
 45 | {{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
 46 | {{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
 47 | {{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
 48 | {{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
 49 | {{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
 50 | {{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
 51 | {{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
 52 | {{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
 53 | {{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
 54 | {{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
 55 | {{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
 56 | {{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
 57 | {{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
 58 | {{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
 59 | {{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
 60 | {{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
 61 | {{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
 62 | };
 63 | 
 64 | local const ct_data static_dtree[D_CODES] = {
 65 | {{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
 66 | {{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
 67 | {{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
 68 | {{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
 69 | {{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
 70 | {{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
 71 | };
 72 | 
 73 | const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
 74 |  0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
 75 |  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
 76 | 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
 77 | 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
 78 | 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
 79 | 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
 80 | 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
 81 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
 82 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
 83 | 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
 84 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
 85 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
 86 | 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
 87 | 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
 88 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
 89 | 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
 90 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
 91 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
 92 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
 93 | 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 94 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 95 | 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
 96 | 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
 97 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
 98 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
 99 | 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
100 | };
101 | 
102 | const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
103 |  0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
104 | 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
105 | 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
106 | 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
107 | 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
108 | 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
109 | 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
110 | 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
111 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
112 | 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
113 | 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
114 | 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
115 | 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
116 | };
117 | 
118 | local const int base_length[LENGTH_CODES] = {
119 | 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
120 | 64, 80, 96, 112, 128, 160, 192, 224, 0
121 | };
122 | 
123 | local const int base_dist[D_CODES] = {
124 |     0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
125 |    32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
126 |  1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
127 | };
128 | 
129 | 


--------------------------------------------------------------------------------
/zlib/zutil.c:
--------------------------------------------------------------------------------
  1 | /* zutil.c -- target dependent utility functions for the compression library
  2 |  * Copyright (C) 1995-2017 Jean-loup Gailly
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* @(#) $Id$ */
  7 | 
  8 | #include "zutil.h"
  9 | #ifndef Z_SOLO
 10 | #  include "gzguts.h"
 11 | #endif
 12 | 
 13 | z_const char * const z_errmsg[10] = {
 14 |     (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
 15 |     (z_const char *)"stream end",          /* Z_STREAM_END      1  */
 16 |     (z_const char *)"",                    /* Z_OK              0  */
 17 |     (z_const char *)"file error",          /* Z_ERRNO         (-1) */
 18 |     (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
 19 |     (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
 20 |     (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
 21 |     (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
 22 |     (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
 23 |     (z_const char *)""
 24 | };
 25 | 
 26 | 
 27 | const char * ZEXPORT zlibVersion()
 28 | {
 29 |     return ZLIB_VERSION;
 30 | }
 31 | 
 32 | uLong ZEXPORT zlibCompileFlags()
 33 | {
 34 |     uLong flags;
 35 | 
 36 |     flags = 0;
 37 |     switch ((int)(sizeof(uInt))) {
 38 |     case 2:     break;
 39 |     case 4:     flags += 1;     break;
 40 |     case 8:     flags += 2;     break;
 41 |     default:    flags += 3;
 42 |     }
 43 |     switch ((int)(sizeof(uLong))) {
 44 |     case 2:     break;
 45 |     case 4:     flags += 1 << 2;        break;
 46 |     case 8:     flags += 2 << 2;        break;
 47 |     default:    flags += 3 << 2;
 48 |     }
 49 |     switch ((int)(sizeof(voidpf))) {
 50 |     case 2:     break;
 51 |     case 4:     flags += 1 << 4;        break;
 52 |     case 8:     flags += 2 << 4;        break;
 53 |     default:    flags += 3 << 4;
 54 |     }
 55 |     switch ((int)(sizeof(z_off_t))) {
 56 |     case 2:     break;
 57 |     case 4:     flags += 1 << 6;        break;
 58 |     case 8:     flags += 2 << 6;        break;
 59 |     default:    flags += 3 << 6;
 60 |     }
 61 | #ifdef ZLIB_DEBUG
 62 |     flags += 1 << 8;
 63 | #endif
 64 | #if defined(ASMV) || defined(ASMINF)
 65 |     flags += 1 << 9;
 66 | #endif
 67 | #ifdef ZLIB_WINAPI
 68 |     flags += 1 << 10;
 69 | #endif
 70 | #ifdef BUILDFIXED
 71 |     flags += 1 << 12;
 72 | #endif
 73 | #ifdef DYNAMIC_CRC_TABLE
 74 |     flags += 1 << 13;
 75 | #endif
 76 | #ifdef NO_GZCOMPRESS
 77 |     flags += 1L << 16;
 78 | #endif
 79 | #ifdef NO_GZIP
 80 |     flags += 1L << 17;
 81 | #endif
 82 | #ifdef PKZIP_BUG_WORKAROUND
 83 |     flags += 1L << 20;
 84 | #endif
 85 | #ifdef FASTEST
 86 |     flags += 1L << 21;
 87 | #endif
 88 | #if defined(STDC) || defined(Z_HAVE_STDARG_H)
 89 | #  ifdef NO_vsnprintf
 90 |     flags += 1L << 25;
 91 | #    ifdef HAS_vsprintf_void
 92 |     flags += 1L << 26;
 93 | #    endif
 94 | #  else
 95 | #    ifdef HAS_vsnprintf_void
 96 |     flags += 1L << 26;
 97 | #    endif
 98 | #  endif
 99 | #else
100 |     flags += 1L << 24;
101 | #  ifdef NO_snprintf
102 |     flags += 1L << 25;
103 | #    ifdef HAS_sprintf_void
104 |     flags += 1L << 26;
105 | #    endif
106 | #  else
107 | #    ifdef HAS_snprintf_void
108 |     flags += 1L << 26;
109 | #    endif
110 | #  endif
111 | #endif
112 |     return flags;
113 | }
114 | 
115 | #ifdef ZLIB_DEBUG
116 | #include <stdlib.h>
117 | #  ifndef verbose
118 | #    define verbose 0
119 | #  endif
120 | int ZLIB_INTERNAL z_verbose = verbose;
121 | 
122 | void ZLIB_INTERNAL z_error (m)
123 |     char *m;
124 | {
125 |     fprintf(stderr, "%s\n", m);
126 |     exit(1);
127 | }
128 | #endif
129 | 
130 | /* exported to allow conversion of error code to string for compress() and
131 |  * uncompress()
132 |  */
133 | const char * ZEXPORT zError(err)
134 |     int err;
135 | {
136 |     return ERR_MSG(err);
137 | }
138 | 
139 | #if defined(_WIN32_WCE)
140 |     /* The Microsoft C Run-Time Library for Windows CE doesn't have
141 |      * errno.  We define it as a global variable to simplify porting.
142 |      * Its value is always 0 and should not be used.
143 |      */
144 |     int errno = 0;
145 | #endif
146 | 
147 | #ifndef HAVE_MEMCPY
148 | 
149 | void ZLIB_INTERNAL zmemcpy(dest, source, len)
150 |     Bytef* dest;
151 |     const Bytef* source;
152 |     uInt  len;
153 | {
154 |     if (len == 0) return;
155 |     do {
156 |         *dest++ = *source++; /* ??? to be unrolled */
157 |     } while (--len != 0);
158 | }
159 | 
160 | int ZLIB_INTERNAL zmemcmp(s1, s2, len)
161 |     const Bytef* s1;
162 |     const Bytef* s2;
163 |     uInt  len;
164 | {
165 |     uInt j;
166 | 
167 |     for (j = 0; j < len; j++) {
168 |         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
169 |     }
170 |     return 0;
171 | }
172 | 
173 | void ZLIB_INTERNAL zmemzero(dest, len)
174 |     Bytef* dest;
175 |     uInt  len;
176 | {
177 |     if (len == 0) return;
178 |     do {
179 |         *dest++ = 0;  /* ??? to be unrolled */
180 |     } while (--len != 0);
181 | }
182 | #endif
183 | 
184 | #ifndef Z_SOLO
185 | 
186 | #ifdef SYS16BIT
187 | 
188 | #ifdef __TURBOC__
189 | /* Turbo C in 16-bit mode */
190 | 
191 | #  define MY_ZCALLOC
192 | 
193 | /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
194 |  * and farmalloc(64K) returns a pointer with an offset of 8, so we
195 |  * must fix the pointer. Warning: the pointer must be put back to its
196 |  * original form in order to free it, use zcfree().
197 |  */
198 | 
199 | #define MAX_PTR 10
200 | /* 10*64K = 640K */
201 | 
202 | local int next_ptr = 0;
203 | 
204 | typedef struct ptr_table_s {
205 |     voidpf org_ptr;
206 |     voidpf new_ptr;
207 | } ptr_table;
208 | 
209 | local ptr_table table[MAX_PTR];
210 | /* This table is used to remember the original form of pointers
211 |  * to large buffers (64K). Such pointers are normalized with a zero offset.
212 |  * Since MSDOS is not a preemptive multitasking OS, this table is not
213 |  * protected from concurrent access. This hack doesn't work anyway on
214 |  * a protected system like OS/2. Use Microsoft C instead.
215 |  */
216 | 
217 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
218 | {
219 |     voidpf buf;
220 |     ulg bsize = (ulg)items*size;
221 | 
222 |     (void)opaque;
223 | 
224 |     /* If we allocate less than 65520 bytes, we assume that farmalloc
225 |      * will return a usable pointer which doesn't have to be normalized.
226 |      */
227 |     if (bsize < 65520L) {
228 |         buf = farmalloc(bsize);
229 |         if (*(ush*)&buf != 0) return buf;
230 |     } else {
231 |         buf = farmalloc(bsize + 16L);
232 |     }
233 |     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
234 |     table[next_ptr].org_ptr = buf;
235 | 
236 |     /* Normalize the pointer to seg:0 */
237 |     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
238 |     *(ush*)&buf = 0;
239 |     table[next_ptr++].new_ptr = buf;
240 |     return buf;
241 | }
242 | 
243 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
244 | {
245 |     int n;
246 | 
247 |     (void)opaque;
248 | 
249 |     if (*(ush*)&ptr != 0) { /* object < 64K */
250 |         farfree(ptr);
251 |         return;
252 |     }
253 |     /* Find the original pointer */
254 |     for (n = 0; n < next_ptr; n++) {
255 |         if (ptr != table[n].new_ptr) continue;
256 | 
257 |         farfree(table[n].org_ptr);
258 |         while (++n < next_ptr) {
259 |             table[n-1] = table[n];
260 |         }
261 |         next_ptr--;
262 |         return;
263 |     }
264 |     Assert(0, "zcfree: ptr not found");
265 | }
266 | 
267 | #endif /* __TURBOC__ */
268 | 
269 | 
270 | #ifdef M_I86
271 | /* Microsoft C in 16-bit mode */
272 | 
273 | #  define MY_ZCALLOC
274 | 
275 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
276 | #  define _halloc  halloc
277 | #  define _hfree   hfree
278 | #endif
279 | 
280 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
281 | {
282 |     (void)opaque;
283 |     return _halloc((long)items, size);
284 | }
285 | 
286 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
287 | {
288 |     (void)opaque;
289 |     _hfree(ptr);
290 | }
291 | 
292 | #endif /* M_I86 */
293 | 
294 | #endif /* SYS16BIT */
295 | 
296 | 
297 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */
298 | 
299 | #ifndef STDC
300 | extern voidp  malloc OF((uInt size));
301 | extern voidp  calloc OF((uInt items, uInt size));
302 | extern void   free   OF((voidpf ptr));
303 | #endif
304 | 
305 | voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
306 |     voidpf opaque;
307 |     unsigned items;
308 |     unsigned size;
309 | {
310 |     (void)opaque;
311 |     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
312 |                               (voidpf)calloc(items, size);
313 | }
314 | 
315 | void ZLIB_INTERNAL zcfree (opaque, ptr)
316 |     voidpf opaque;
317 |     voidpf ptr;
318 | {
319 |     (void)opaque;
320 |     free(ptr);
321 | }
322 | 
323 | #endif /* MY_ZCALLOC */
324 | 
325 | #endif /* !Z_SOLO */
326 | 


--------------------------------------------------------------------------------
/zlib/zlib.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <ItemGroup>
 22 |     <ClCompile Include="adler32.c" />
 23 |     <ClCompile Include="compress.c" />
 24 |     <ClCompile Include="crc32.c" />
 25 |     <ClCompile Include="deflate.c" />
 26 |     <ClCompile Include="gzclose.c" />
 27 |     <ClCompile Include="infback.c" />
 28 |     <ClCompile Include="inffast.c" />
 29 |     <ClCompile Include="inflate.c" />
 30 |     <ClCompile Include="inftrees.c" />
 31 |     <ClCompile Include="trees.c" />
 32 |     <ClCompile Include="uncompr.c" />
 33 |     <ClCompile Include="zutil.c" />
 34 |   </ItemGroup>
 35 |   <ItemGroup>
 36 |     <ClInclude Include="crc32.h" />
 37 |     <ClInclude Include="deflate.h" />
 38 |     <ClInclude Include="gzguts.h" />
 39 |     <ClInclude Include="inffast.h" />
 40 |     <ClInclude Include="inffixed.h" />
 41 |     <ClInclude Include="inflate.h" />
 42 |     <ClInclude Include="inftrees.h" />
 43 |     <ClInclude Include="trees.h" />
 44 |     <ClInclude Include="zconf.h" />
 45 |     <ClInclude Include="zlib.h" />
 46 |     <ClInclude Include="zutil.h" />
 47 |   </ItemGroup>
 48 |   <PropertyGroup Label="Globals">
 49 |     <VCProjectVersion>15.0</VCProjectVersion>
 50 |     <ProjectGuid>{A954A18D-6FFA-480B-B1BD-E460F133AB66}</ProjectGuid>
 51 |     <Keyword>Win32Proj</Keyword>
 52 |     <RootNamespace>zlib</RootNamespace>
 53 |     <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
 54 |   </PropertyGroup>
 55 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 56 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 57 |     <ConfigurationType>StaticLibrary</ConfigurationType>
 58 |     <UseDebugLibraries>true</UseDebugLibraries>
 59 |     <PlatformToolset>v141</PlatformToolset>
 60 |     <CharacterSet>Unicode</CharacterSet>
 61 |   </PropertyGroup>
 62 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 63 |     <ConfigurationType>StaticLibrary</ConfigurationType>
 64 |     <UseDebugLibraries>false</UseDebugLibraries>
 65 |     <PlatformToolset>v141</PlatformToolset>
 66 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 67 |     <CharacterSet>Unicode</CharacterSet>
 68 |   </PropertyGroup>
 69 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 70 |     <ConfigurationType>StaticLibrary</ConfigurationType>
 71 |     <UseDebugLibraries>true</UseDebugLibraries>
 72 |     <PlatformToolset>v141</PlatformToolset>
 73 |     <CharacterSet>Unicode</CharacterSet>
 74 |   </PropertyGroup>
 75 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 76 |     <ConfigurationType>StaticLibrary</ConfigurationType>
 77 |     <UseDebugLibraries>false</UseDebugLibraries>
 78 |     <PlatformToolset>v141</PlatformToolset>
 79 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 80 |     <CharacterSet>Unicode</CharacterSet>
 81 |   </PropertyGroup>
 82 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 83 |   <ImportGroup Label="ExtensionSettings">
 84 |   </ImportGroup>
 85 |   <ImportGroup Label="Shared">
 86 |   </ImportGroup>
 87 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 88 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 89 |   </ImportGroup>
 90 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 91 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 92 |   </ImportGroup>
 93 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 94 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 95 |   </ImportGroup>
 96 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 97 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 98 |   </ImportGroup>
 99 |   <PropertyGroup Label="UserMacros" />
100 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
101 |     <LinkIncremental>true</LinkIncremental>
102 |   </PropertyGroup>
103 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
104 |     <LinkIncremental>true</LinkIncremental>
105 |   </PropertyGroup>
106 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
107 |     <LinkIncremental>false</LinkIncremental>
108 |   </PropertyGroup>
109 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
110 |     <LinkIncremental>false</LinkIncremental>
111 |   </PropertyGroup>
112 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
113 |     <ClCompile>
114 |       <PrecompiledHeader>
115 |       </PrecompiledHeader>
116 |       <WarningLevel>Level3</WarningLevel>
117 |       <Optimization>Disabled</Optimization>
118 |       <SDLCheck>true</SDLCheck>
119 |       <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
120 |       <ConformanceMode>true</ConformanceMode>
121 |     </ClCompile>
122 |     <Link>
123 |       <SubSystem>Windows</SubSystem>
124 |       <GenerateDebugInformation>true</GenerateDebugInformation>
125 |     </Link>
126 |   </ItemDefinitionGroup>
127 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
128 |     <ClCompile>
129 |       <PrecompiledHeader>
130 |       </PrecompiledHeader>
131 |       <WarningLevel>Level3</WarningLevel>
132 |       <Optimization>Disabled</Optimization>
133 |       <SDLCheck>true</SDLCheck>
134 |       <PreprocessorDefinitions>_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
135 |       <ConformanceMode>true</ConformanceMode>
136 |     </ClCompile>
137 |     <Link>
138 |       <SubSystem>Windows</SubSystem>
139 |       <GenerateDebugInformation>true</GenerateDebugInformation>
140 |     </Link>
141 |   </ItemDefinitionGroup>
142 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
143 |     <ClCompile>
144 |       <PrecompiledHeader>
145 |       </PrecompiledHeader>
146 |       <WarningLevel>Level3</WarningLevel>
147 |       <Optimization>MaxSpeed</Optimization>
148 |       <FunctionLevelLinking>true</FunctionLevelLinking>
149 |       <IntrinsicFunctions>true</IntrinsicFunctions>
150 |       <SDLCheck>true</SDLCheck>
151 |       <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
152 |       <ConformanceMode>true</ConformanceMode>
153 |     </ClCompile>
154 |     <Link>
155 |       <SubSystem>Windows</SubSystem>
156 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
157 |       <OptimizeReferences>true</OptimizeReferences>
158 |       <GenerateDebugInformation>true</GenerateDebugInformation>
159 |     </Link>
160 |   </ItemDefinitionGroup>
161 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
162 |     <ClCompile>
163 |       <PrecompiledHeader>
164 |       </PrecompiledHeader>
165 |       <WarningLevel>Level3</WarningLevel>
166 |       <Optimization>MaxSpeed</Optimization>
167 |       <FunctionLevelLinking>true</FunctionLevelLinking>
168 |       <IntrinsicFunctions>true</IntrinsicFunctions>
169 |       <SDLCheck>true</SDLCheck>
170 |       <PreprocessorDefinitions>NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
171 |       <ConformanceMode>true</ConformanceMode>
172 |     </ClCompile>
173 |     <Link>
174 |       <SubSystem>Windows</SubSystem>
175 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
176 |       <OptimizeReferences>true</OptimizeReferences>
177 |       <GenerateDebugInformation>true</GenerateDebugInformation>
178 |     </Link>
179 |   </ItemDefinitionGroup>
180 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
181 |   <ImportGroup Label="ExtensionTargets">
182 |   </ImportGroup>
183 | </Project>


--------------------------------------------------------------------------------
/zlib/inftrees.c:
--------------------------------------------------------------------------------
  1 | /* inftrees.c -- generate Huffman trees for efficient decoding
  2 |  * Copyright (C) 1995-2017 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | #include "zutil.h"
  7 | #include "inftrees.h"
  8 | 
  9 | #define MAXBITS 15
 10 | 
 11 | const char inflate_copyright[] =
 12 |    " inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
 13 | /*
 14 |   If you use the zlib library in a product, an acknowledgment is welcome
 15 |   in the documentation of your product. If for some reason you cannot
 16 |   include such an acknowledgment, I would appreciate that you keep this
 17 |   copyright string in the executable of your product.
 18 |  */
 19 | 
 20 | /*
 21 |    Build a set of tables to decode the provided canonical Huffman code.
 22 |    The code lengths are lens[0..codes-1].  The result starts at *table,
 23 |    whose indices are 0..2^bits-1.  work is a writable array of at least
 24 |    lens shorts, which is used as a work area.  type is the type of code
 25 |    to be generated, CODES, LENS, or DISTS.  On return, zero is success,
 26 |    -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
 27 |    on return points to the next available entry's address.  bits is the
 28 |    requested root table index bits, and on return it is the actual root
 29 |    table index bits.  It will differ if the request is greater than the
 30 |    longest code or if it is less than the shortest code.
 31 |  */
 32 | int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
 33 | codetype type;
 34 | unsigned short FAR *lens;
 35 | unsigned codes;
 36 | code FAR * FAR *table;
 37 | unsigned FAR *bits;
 38 | unsigned short FAR *work;
 39 | {
 40 |     unsigned len;               /* a code's length in bits */
 41 |     unsigned sym;               /* index of code symbols */
 42 |     unsigned min, max;          /* minimum and maximum code lengths */
 43 |     unsigned root;              /* number of index bits for root table */
 44 |     unsigned curr;              /* number of index bits for current table */
 45 |     unsigned drop;              /* code bits to drop for sub-table */
 46 |     int left;                   /* number of prefix codes available */
 47 |     unsigned used;              /* code entries in table used */
 48 |     unsigned huff;              /* Huffman code */
 49 |     unsigned incr;              /* for incrementing code, index */
 50 |     unsigned fill;              /* index for replicating entries */
 51 |     unsigned low;               /* low bits for current root entry */
 52 |     unsigned mask;              /* mask for low root bits */
 53 |     code here;                  /* table entry for duplication */
 54 |     code FAR *next;             /* next available space in table */
 55 |     const unsigned short FAR *base;     /* base value table to use */
 56 |     const unsigned short FAR *extra;    /* extra bits table to use */
 57 |     unsigned match;             /* use base and extra for symbol >= match */
 58 |     unsigned short count[MAXBITS+1];    /* number of codes of each length */
 59 |     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
 60 |     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
 61 |         3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
 62 |         35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
 63 |     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
 64 |         16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
 65 |         19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
 66 |     static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
 67 |         1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
 68 |         257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
 69 |         8193, 12289, 16385, 24577, 0, 0};
 70 |     static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
 71 |         16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
 72 |         23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
 73 |         28, 28, 29, 29, 64, 64};
 74 | 
 75 |     /*
 76 |        Process a set of code lengths to create a canonical Huffman code.  The
 77 |        code lengths are lens[0..codes-1].  Each length corresponds to the
 78 |        symbols 0..codes-1.  The Huffman code is generated by first sorting the
 79 |        symbols by length from short to long, and retaining the symbol order
 80 |        for codes with equal lengths.  Then the code starts with all zero bits
 81 |        for the first code of the shortest length, and the codes are integer
 82 |        increments for the same length, and zeros are appended as the length
 83 |        increases.  For the deflate format, these bits are stored backwards
 84 |        from their more natural integer increment ordering, and so when the
 85 |        decoding tables are built in the large loop below, the integer codes
 86 |        are incremented backwards.
 87 | 
 88 |        This routine assumes, but does not check, that all of the entries in
 89 |        lens[] are in the range 0..MAXBITS.  The caller must assure this.
 90 |        1..MAXBITS is interpreted as that code length.  zero means that that
 91 |        symbol does not occur in this code.
 92 | 
 93 |        The codes are sorted by computing a count of codes for each length,
 94 |        creating from that a table of starting indices for each length in the
 95 |        sorted table, and then entering the symbols in order in the sorted
 96 |        table.  The sorted table is work[], with that space being provided by
 97 |        the caller.
 98 | 
 99 |        The length counts are used for other purposes as well, i.e. finding
100 |        the minimum and maximum length codes, determining if there are any
101 |        codes at all, checking for a valid set of lengths, and looking ahead
102 |        at length counts to determine sub-table sizes when building the
103 |        decoding tables.
104 |      */
105 | 
106 |     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
107 |     for (len = 0; len <= MAXBITS; len++)
108 |         count[len] = 0;
109 |     for (sym = 0; sym < codes; sym++)
110 |         count[lens[sym]]++;
111 | 
112 |     /* bound code lengths, force root to be within code lengths */
113 |     root = *bits;
114 |     for (max = MAXBITS; max >= 1; max--)
115 |         if (count[max] != 0) break;
116 |     if (root > max) root = max;
117 |     if (max == 0) {                     /* no symbols to code at all */
118 |         here.op = (unsigned char)64;    /* invalid code marker */
119 |         here.bits = (unsigned char)1;
120 |         here.val = (unsigned short)0;
121 |         *(*table)++ = here;             /* make a table to force an error */
122 |         *(*table)++ = here;
123 |         *bits = 1;
124 |         return 0;     /* no symbols, but wait for decoding to report error */
125 |     }
126 |     for (min = 1; min < max; min++)
127 |         if (count[min] != 0) break;
128 |     if (root < min) root = min;
129 | 
130 |     /* check for an over-subscribed or incomplete set of lengths */
131 |     left = 1;
132 |     for (len = 1; len <= MAXBITS; len++) {
133 |         left <<= 1;
134 |         left -= count[len];
135 |         if (left < 0) return -1;        /* over-subscribed */
136 |     }
137 |     if (left > 0 && (type == CODES || max != 1))
138 |         return -1;                      /* incomplete set */
139 | 
140 |     /* generate offsets into symbol table for each length for sorting */
141 |     offs[1] = 0;
142 |     for (len = 1; len < MAXBITS; len++)
143 |         offs[len + 1] = offs[len] + count[len];
144 | 
145 |     /* sort symbols by length, by symbol order within each length */
146 |     for (sym = 0; sym < codes; sym++)
147 |         if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
148 | 
149 |     /*
150 |        Create and fill in decoding tables.  In this loop, the table being
151 |        filled is at next and has curr index bits.  The code being used is huff
152 |        with length len.  That code is converted to an index by dropping drop
153 |        bits off of the bottom.  For codes where len is less than drop + curr,
154 |        those top drop + curr - len bits are incremented through all values to
155 |        fill the table with replicated entries.
156 | 
157 |        root is the number of index bits for the root table.  When len exceeds
158 |        root, sub-tables are created pointed to by the root entry with an index
159 |        of the low root bits of huff.  This is saved in low to check for when a
160 |        new sub-table should be started.  drop is zero when the root table is
161 |        being filled, and drop is root when sub-tables are being filled.
162 | 
163 |        When a new sub-table is needed, it is necessary to look ahead in the
164 |        code lengths to determine what size sub-table is needed.  The length
165 |        counts are used for this, and so count[] is decremented as codes are
166 |        entered in the tables.
167 | 
168 |        used keeps track of how many table entries have been allocated from the
169 |        provided *table space.  It is checked for LENS and DIST tables against
170 |        the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
171 |        the initial root table size constants.  See the comments in inftrees.h
172 |        for more information.
173 | 
174 |        sym increments through all symbols, and the loop terminates when
175 |        all codes of length max, i.e. all codes, have been processed.  This
176 |        routine permits incomplete codes, so another loop after this one fills
177 |        in the rest of the decoding tables with invalid code markers.
178 |      */
179 | 
180 |     /* set up for code type */
181 |     switch (type) {
182 |     case CODES:
183 |         base = extra = work;    /* dummy value--not used */
184 |         match = 20;
185 |         break;
186 |     case LENS:
187 |         base = lbase;
188 |         extra = lext;
189 |         match = 257;
190 |         break;
191 |     default:    /* DISTS */
192 |         base = dbase;
193 |         extra = dext;
194 |         match = 0;
195 |     }
196 | 
197 |     /* initialize state for loop */
198 |     huff = 0;                   /* starting code */
199 |     sym = 0;                    /* starting code symbol */
200 |     len = min;                  /* starting code length */
201 |     next = *table;              /* current table to fill in */
202 |     curr = root;                /* current table index bits */
203 |     drop = 0;                   /* current bits to drop from code for index */
204 |     low = (unsigned)(-1);       /* trigger new sub-table when len > root */
205 |     used = 1U << root;          /* use root table entries */
206 |     mask = used - 1;            /* mask for comparing low */
207 | 
208 |     /* check available table space */
209 |     if ((type == LENS && used > ENOUGH_LENS) ||
210 |         (type == DISTS && used > ENOUGH_DISTS))
211 |         return 1;
212 | 
213 |     /* process all codes and make table entries */
214 |     for (;;) {
215 |         /* create table entry */
216 |         here.bits = (unsigned char)(len - drop);
217 |         if (work[sym] + 1U < match) {
218 |             here.op = (unsigned char)0;
219 |             here.val = work[sym];
220 |         }
221 |         else if (work[sym] >= match) {
222 |             here.op = (unsigned char)(extra[work[sym] - match]);
223 |             here.val = base[work[sym] - match];
224 |         }
225 |         else {
226 |             here.op = (unsigned char)(32 + 64);         /* end of block */
227 |             here.val = 0;
228 |         }
229 | 
230 |         /* replicate for those indices with low len bits equal to huff */
231 |         incr = 1U << (len - drop);
232 |         fill = 1U << curr;
233 |         min = fill;                 /* save offset to next table */
234 |         do {
235 |             fill -= incr;
236 |             next[(huff >> drop) + fill] = here;
237 |         } while (fill != 0);
238 | 
239 |         /* backwards increment the len-bit code huff */
240 |         incr = 1U << (len - 1);
241 |         while (huff & incr)
242 |             incr >>= 1;
243 |         if (incr != 0) {
244 |             huff &= incr - 1;
245 |             huff += incr;
246 |         }
247 |         else
248 |             huff = 0;
249 | 
250 |         /* go to next symbol, update count, len */
251 |         sym++;
252 |         if (--(count[len]) == 0) {
253 |             if (len == max) break;
254 |             len = lens[work[sym]];
255 |         }
256 | 
257 |         /* create new sub-table if needed */
258 |         if (len > root && (huff & mask) != low) {
259 |             /* if first time, transition to sub-tables */
260 |             if (drop == 0)
261 |                 drop = root;
262 | 
263 |             /* increment past last table */
264 |             next += min;            /* here min is 1 << curr */
265 | 
266 |             /* determine length of next table */
267 |             curr = len - drop;
268 |             left = (int)(1 << curr);
269 |             while (curr + drop < max) {
270 |                 left -= count[curr + drop];
271 |                 if (left <= 0) break;
272 |                 curr++;
273 |                 left <<= 1;
274 |             }
275 | 
276 |             /* check for enough space */
277 |             used += 1U << curr;
278 |             if ((type == LENS && used > ENOUGH_LENS) ||
279 |                 (type == DISTS && used > ENOUGH_DISTS))
280 |                 return 1;
281 | 
282 |             /* point entry in root table to sub-table */
283 |             low = huff & mask;
284 |             (*table)[low].op = (unsigned char)curr;
285 |             (*table)[low].bits = (unsigned char)root;
286 |             (*table)[low].val = (unsigned short)(next - *table);
287 |         }
288 |     }
289 | 
290 |     /* fill in remaining table entry if code is incomplete (guaranteed to have
291 |        at most one remaining entry, since if the code is incomplete, the
292 |        maximum code length that was allowed to get this far is one bit) */
293 |     if (huff != 0) {
294 |         here.op = (unsigned char)64;            /* invalid code marker */
295 |         here.bits = (unsigned char)(len - drop);
296 |         here.val = (unsigned short)0;
297 |         next[huff] = here;
298 |     }
299 | 
300 |     /* set return parameters */
301 |     *table += used;
302 |     *bits = root;
303 |     return 0;
304 | }
305 | 


--------------------------------------------------------------------------------
/zlib/inffast.c:
--------------------------------------------------------------------------------
  1 | /* inffast.c -- fast decoding
  2 |  * Copyright (C) 1995-2017 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | #include "zutil.h"
  7 | #include "inftrees.h"
  8 | #include "inflate.h"
  9 | #include "inffast.h"
 10 | 
 11 | #ifdef ASMINF
 12 | #  pragma message("Assembler code may have bugs -- use at your own risk")
 13 | #else
 14 | 
 15 | /*
 16 |    Decode literal, length, and distance codes and write out the resulting
 17 |    literal and match bytes until either not enough input or output is
 18 |    available, an end-of-block is encountered, or a data error is encountered.
 19 |    When large enough input and output buffers are supplied to inflate(), for
 20 |    example, a 16K input buffer and a 64K output buffer, more than 95% of the
 21 |    inflate execution time is spent in this routine.
 22 | 
 23 |    Entry assumptions:
 24 | 
 25 |         state->mode == LEN
 26 |         strm->avail_in >= 6
 27 |         strm->avail_out >= 258
 28 |         start >= strm->avail_out
 29 |         state->bits < 8
 30 | 
 31 |    On return, state->mode is one of:
 32 | 
 33 |         LEN -- ran out of enough output space or enough available input
 34 |         TYPE -- reached end of block code, inflate() to interpret next block
 35 |         BAD -- error in block data
 36 | 
 37 |    Notes:
 38 | 
 39 |     - The maximum input bits used by a length/distance pair is 15 bits for the
 40 |       length code, 5 bits for the length extra, 15 bits for the distance code,
 41 |       and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
 42 |       Therefore if strm->avail_in >= 6, then there is enough input to avoid
 43 |       checking for available input while decoding.
 44 | 
 45 |     - The maximum bytes that a single length/distance pair can output is 258
 46 |       bytes, which is the maximum length that can be coded.  inflate_fast()
 47 |       requires strm->avail_out >= 258 for each loop to avoid checking for
 48 |       output space.
 49 |  */
 50 | void ZLIB_INTERNAL inflate_fast(strm, start)
 51 | z_streamp strm;
 52 | unsigned start;         /* inflate()'s starting value for strm->avail_out */
 53 | {
 54 |     struct inflate_state FAR *state;
 55 |     z_const unsigned char FAR *in;      /* local strm->next_in */
 56 |     z_const unsigned char FAR *last;    /* have enough input while in < last */
 57 |     unsigned char FAR *out;     /* local strm->next_out */
 58 |     unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
 59 |     unsigned char FAR *end;     /* while out < end, enough space available */
 60 | #ifdef INFLATE_STRICT
 61 |     unsigned dmax;              /* maximum distance from zlib header */
 62 | #endif
 63 |     unsigned wsize;             /* window size or zero if not using window */
 64 |     unsigned whave;             /* valid bytes in the window */
 65 |     unsigned wnext;             /* window write index */
 66 |     unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
 67 |     unsigned long hold;         /* local strm->hold */
 68 |     unsigned bits;              /* local strm->bits */
 69 |     code const FAR *lcode;      /* local strm->lencode */
 70 |     code const FAR *dcode;      /* local strm->distcode */
 71 |     unsigned lmask;             /* mask for first level of length codes */
 72 |     unsigned dmask;             /* mask for first level of distance codes */
 73 |     code here;                  /* retrieved table entry */
 74 |     unsigned op;                /* code bits, operation, extra bits, or */
 75 |                                 /*  window position, window bytes to copy */
 76 |     unsigned len;               /* match length, unused bytes */
 77 |     unsigned dist;              /* match distance */
 78 |     unsigned char FAR *from;    /* where to copy match from */
 79 | 
 80 |     /* copy state to local variables */
 81 |     state = (struct inflate_state FAR *)strm->state;
 82 |     in = strm->next_in;
 83 |     last = in + (strm->avail_in - 5);
 84 |     out = strm->next_out;
 85 |     beg = out - (start - strm->avail_out);
 86 |     end = out + (strm->avail_out - 257);
 87 | #ifdef INFLATE_STRICT
 88 |     dmax = state->dmax;
 89 | #endif
 90 |     wsize = state->wsize;
 91 |     whave = state->whave;
 92 |     wnext = state->wnext;
 93 |     window = state->window;
 94 |     hold = state->hold;
 95 |     bits = state->bits;
 96 |     lcode = state->lencode;
 97 |     dcode = state->distcode;
 98 |     lmask = (1U << state->lenbits) - 1;
 99 |     dmask = (1U << state->distbits) - 1;
100 | 
101 |     /* decode literals and length/distances until end-of-block or not enough
102 |        input data or output space */
103 |     do {
104 |         if (bits < 15) {
105 |             hold += (unsigned long)(*in++) << bits;
106 |             bits += 8;
107 |             hold += (unsigned long)(*in++) << bits;
108 |             bits += 8;
109 |         }
110 |         here = lcode[hold & lmask];
111 |       dolen:
112 |         op = (unsigned)(here.bits);
113 |         hold >>= op;
114 |         bits -= op;
115 |         op = (unsigned)(here.op);
116 |         if (op == 0) {                          /* literal */
117 |             Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
118 |                     "inflate:         literal '%c'\n" :
119 |                     "inflate:         literal 0x%02x\n", here.val));
120 |             *out++ = (unsigned char)(here.val);
121 |         }
122 |         else if (op & 16) {                     /* length base */
123 |             len = (unsigned)(here.val);
124 |             op &= 15;                           /* number of extra bits */
125 |             if (op) {
126 |                 if (bits < op) {
127 |                     hold += (unsigned long)(*in++) << bits;
128 |                     bits += 8;
129 |                 }
130 |                 len += (unsigned)hold & ((1U << op) - 1);
131 |                 hold >>= op;
132 |                 bits -= op;
133 |             }
134 |             Tracevv((stderr, "inflate:         length %u\n", len));
135 |             if (bits < 15) {
136 |                 hold += (unsigned long)(*in++) << bits;
137 |                 bits += 8;
138 |                 hold += (unsigned long)(*in++) << bits;
139 |                 bits += 8;
140 |             }
141 |             here = dcode[hold & dmask];
142 |           dodist:
143 |             op = (unsigned)(here.bits);
144 |             hold >>= op;
145 |             bits -= op;
146 |             op = (unsigned)(here.op);
147 |             if (op & 16) {                      /* distance base */
148 |                 dist = (unsigned)(here.val);
149 |                 op &= 15;                       /* number of extra bits */
150 |                 if (bits < op) {
151 |                     hold += (unsigned long)(*in++) << bits;
152 |                     bits += 8;
153 |                     if (bits < op) {
154 |                         hold += (unsigned long)(*in++) << bits;
155 |                         bits += 8;
156 |                     }
157 |                 }
158 |                 dist += (unsigned)hold & ((1U << op) - 1);
159 | #ifdef INFLATE_STRICT
160 |                 if (dist > dmax) {
161 |                     strm->msg = (char *)"invalid distance too far back";
162 |                     state->mode = BAD;
163 |                     break;
164 |                 }
165 | #endif
166 |                 hold >>= op;
167 |                 bits -= op;
168 |                 Tracevv((stderr, "inflate:         distance %u\n", dist));
169 |                 op = (unsigned)(out - beg);     /* max distance in output */
170 |                 if (dist > op) {                /* see if copy from window */
171 |                     op = dist - op;             /* distance back in window */
172 |                     if (op > whave) {
173 |                         if (state->sane) {
174 |                             strm->msg =
175 |                                 (char *)"invalid distance too far back";
176 |                             state->mode = BAD;
177 |                             break;
178 |                         }
179 | #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
180 |                         if (len <= op - whave) {
181 |                             do {
182 |                                 *out++ = 0;
183 |                             } while (--len);
184 |                             continue;
185 |                         }
186 |                         len -= op - whave;
187 |                         do {
188 |                             *out++ = 0;
189 |                         } while (--op > whave);
190 |                         if (op == 0) {
191 |                             from = out - dist;
192 |                             do {
193 |                                 *out++ = *from++;
194 |                             } while (--len);
195 |                             continue;
196 |                         }
197 | #endif
198 |                     }
199 |                     from = window;
200 |                     if (wnext == 0) {           /* very common case */
201 |                         from += wsize - op;
202 |                         if (op < len) {         /* some from window */
203 |                             len -= op;
204 |                             do {
205 |                                 *out++ = *from++;
206 |                             } while (--op);
207 |                             from = out - dist;  /* rest from output */
208 |                         }
209 |                     }
210 |                     else if (wnext < op) {      /* wrap around window */
211 |                         from += wsize + wnext - op;
212 |                         op -= wnext;
213 |                         if (op < len) {         /* some from end of window */
214 |                             len -= op;
215 |                             do {
216 |                                 *out++ = *from++;
217 |                             } while (--op);
218 |                             from = window;
219 |                             if (wnext < len) {  /* some from start of window */
220 |                                 op = wnext;
221 |                                 len -= op;
222 |                                 do {
223 |                                     *out++ = *from++;
224 |                                 } while (--op);
225 |                                 from = out - dist;      /* rest from output */
226 |                             }
227 |                         }
228 |                     }
229 |                     else {                      /* contiguous in window */
230 |                         from += wnext - op;
231 |                         if (op < len) {         /* some from window */
232 |                             len -= op;
233 |                             do {
234 |                                 *out++ = *from++;
235 |                             } while (--op);
236 |                             from = out - dist;  /* rest from output */
237 |                         }
238 |                     }
239 |                     while (len > 2) {
240 |                         *out++ = *from++;
241 |                         *out++ = *from++;
242 |                         *out++ = *from++;
243 |                         len -= 3;
244 |                     }
245 |                     if (len) {
246 |                         *out++ = *from++;
247 |                         if (len > 1)
248 |                             *out++ = *from++;
249 |                     }
250 |                 }
251 |                 else {
252 |                     from = out - dist;          /* copy direct from output */
253 |                     do {                        /* minimum length is three */
254 |                         *out++ = *from++;
255 |                         *out++ = *from++;
256 |                         *out++ = *from++;
257 |                         len -= 3;
258 |                     } while (len > 2);
259 |                     if (len) {
260 |                         *out++ = *from++;
261 |                         if (len > 1)
262 |                             *out++ = *from++;
263 |                     }
264 |                 }
265 |             }
266 |             else if ((op & 64) == 0) {          /* 2nd level distance code */
267 |                 here = dcode[here.val + (hold & ((1U << op) - 1))];
268 |                 goto dodist;
269 |             }
270 |             else {
271 |                 strm->msg = (char *)"invalid distance code";
272 |                 state->mode = BAD;
273 |                 break;
274 |             }
275 |         }
276 |         else if ((op & 64) == 0) {              /* 2nd level length code */
277 |             here = lcode[here.val + (hold & ((1U << op) - 1))];
278 |             goto dolen;
279 |         }
280 |         else if (op & 32) {                     /* end-of-block */
281 |             Tracevv((stderr, "inflate:         end of block\n"));
282 |             state->mode = TYPE;
283 |             break;
284 |         }
285 |         else {
286 |             strm->msg = (char *)"invalid literal/length code";
287 |             state->mode = BAD;
288 |             break;
289 |         }
290 |     } while (in < last && out < end);
291 | 
292 |     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
293 |     len = bits >> 3;
294 |     in -= len;
295 |     bits -= len << 3;
296 |     hold &= (1U << bits) - 1;
297 | 
298 |     /* update state and return */
299 |     strm->next_in = in;
300 |     strm->next_out = out;
301 |     strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
302 |     strm->avail_out = (unsigned)(out < end ?
303 |                                  257 + (end - out) : 257 - (out - end));
304 |     state->hold = hold;
305 |     state->bits = bits;
306 |     return;
307 | }
308 | 
309 | /*
310 |    inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
311 |    - Using bit fields for code structure
312 |    - Different op definition to avoid & for extra bits (do & for table bits)
313 |    - Three separate decoding do-loops for direct, window, and wnext == 0
314 |    - Special case for distance > 1 copies to do overlapped load and store copy
315 |    - Explicit branch predictions (based on measured branch probabilities)
316 |    - Deferring match copy and interspersed it with decoding subsequent codes
317 |    - Swapping literal/length else
318 |    - Swapping window/direct else
319 |    - Larger unrolled copy loops (three is about right)
320 |    - Moving len -= 3 statement into middle of loop
321 |  */
322 | 
323 | #endif /* !ASMINF */
324 | 


--------------------------------------------------------------------------------
/zlib/deflate.h:
--------------------------------------------------------------------------------
  1 | /* deflate.h -- internal compression state
  2 |  * Copyright (C) 1995-2016 Jean-loup Gailly
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* WARNING: this file should *not* be used by applications. It is
  7 |    part of the implementation of the compression library and is
  8 |    subject to change. Applications should only use zlib.h.
  9 |  */
 10 | 
 11 | /* @(#) $Id$ */
 12 | 
 13 | #ifndef DEFLATE_H
 14 | #define DEFLATE_H
 15 | 
 16 | #include "zutil.h"
 17 | 
 18 | /* define NO_GZIP when compiling if you want to disable gzip header and
 19 |    trailer creation by deflate().  NO_GZIP would be used to avoid linking in
 20 |    the crc code when it is not needed.  For shared libraries, gzip encoding
 21 |    should be left enabled. */
 22 | #ifndef NO_GZIP
 23 | #  define GZIP
 24 | #endif
 25 | 
 26 | /* ===========================================================================
 27 |  * Internal compression state.
 28 |  */
 29 | 
 30 | #define LENGTH_CODES 29
 31 | /* number of length codes, not counting the special END_BLOCK code */
 32 | 
 33 | #define LITERALS  256
 34 | /* number of literal bytes 0..255 */
 35 | 
 36 | #define L_CODES (LITERALS+1+LENGTH_CODES)
 37 | /* number of Literal or Length codes, including the END_BLOCK code */
 38 | 
 39 | #define D_CODES   30
 40 | /* number of distance codes */
 41 | 
 42 | #define BL_CODES  19
 43 | /* number of codes used to transfer the bit lengths */
 44 | 
 45 | #define HEAP_SIZE (2*L_CODES+1)
 46 | /* maximum heap size */
 47 | 
 48 | #define MAX_BITS 15
 49 | /* All codes must not exceed MAX_BITS bits */
 50 | 
 51 | #define Buf_size 16
 52 | /* size of bit buffer in bi_buf */
 53 | 
 54 | #define INIT_STATE    42    /* zlib header -> BUSY_STATE */
 55 | #ifdef GZIP
 56 | #  define GZIP_STATE  57    /* gzip header -> BUSY_STATE | EXTRA_STATE */
 57 | #endif
 58 | #define EXTRA_STATE   69    /* gzip extra block -> NAME_STATE */
 59 | #define NAME_STATE    73    /* gzip file name -> COMMENT_STATE */
 60 | #define COMMENT_STATE 91    /* gzip comment -> HCRC_STATE */
 61 | #define HCRC_STATE   103    /* gzip header CRC -> BUSY_STATE */
 62 | #define BUSY_STATE   113    /* deflate -> FINISH_STATE */
 63 | #define FINISH_STATE 666    /* stream complete */
 64 | /* Stream status */
 65 | 
 66 | 
 67 | /* Data structure describing a single value and its code string. */
 68 | typedef struct ct_data_s {
 69 |     union {
 70 |         ush  freq;       /* frequency count */
 71 |         ush  code;       /* bit string */
 72 |     } fc;
 73 |     union {
 74 |         ush  dad;        /* father node in Huffman tree */
 75 |         ush  len;        /* length of bit string */
 76 |     } dl;
 77 | } FAR ct_data;
 78 | 
 79 | #define Freq fc.freq
 80 | #define Code fc.code
 81 | #define Dad  dl.dad
 82 | #define Len  dl.len
 83 | 
 84 | typedef struct static_tree_desc_s  static_tree_desc;
 85 | 
 86 | typedef struct tree_desc_s {
 87 |     ct_data *dyn_tree;           /* the dynamic tree */
 88 |     int     max_code;            /* largest code with non zero frequency */
 89 |     const static_tree_desc *stat_desc;  /* the corresponding static tree */
 90 | } FAR tree_desc;
 91 | 
 92 | typedef ush Pos;
 93 | typedef Pos FAR Posf;
 94 | typedef unsigned IPos;
 95 | 
 96 | /* A Pos is an index in the character window. We use short instead of int to
 97 |  * save space in the various tables. IPos is used only for parameter passing.
 98 |  */
 99 | 
100 | typedef struct internal_state {
101 |     z_streamp strm;      /* pointer back to this zlib stream */
102 |     int   status;        /* as the name implies */
103 |     Bytef *pending_buf;  /* output still pending */
104 |     ulg   pending_buf_size; /* size of pending_buf */
105 |     Bytef *pending_out;  /* next pending byte to output to the stream */
106 |     ulg   pending;       /* nb of bytes in the pending buffer */
107 |     int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
108 |     gz_headerp  gzhead;  /* gzip header information to write */
109 |     ulg   gzindex;       /* where in extra, name, or comment */
110 |     Byte  method;        /* can only be DEFLATED */
111 |     int   last_flush;    /* value of flush param for previous deflate call */
112 | 
113 |                 /* used by deflate.c: */
114 | 
115 |     uInt  w_size;        /* LZ77 window size (32K by default) */
116 |     uInt  w_bits;        /* log2(w_size)  (8..16) */
117 |     uInt  w_mask;        /* w_size - 1 */
118 | 
119 |     Bytef *window;
120 |     /* Sliding window. Input bytes are read into the second half of the window,
121 |      * and move to the first half later to keep a dictionary of at least wSize
122 |      * bytes. With this organization, matches are limited to a distance of
123 |      * wSize-MAX_MATCH bytes, but this ensures that IO is always
124 |      * performed with a length multiple of the block size. Also, it limits
125 |      * the window size to 64K, which is quite useful on MSDOS.
126 |      * To do: use the user input buffer as sliding window.
127 |      */
128 | 
129 |     ulg window_size;
130 |     /* Actual size of window: 2*wSize, except when the user input buffer
131 |      * is directly used as sliding window.
132 |      */
133 | 
134 |     Posf *prev;
135 |     /* Link to older string with same hash index. To limit the size of this
136 |      * array to 64K, this link is maintained only for the last 32K strings.
137 |      * An index in this array is thus a window index modulo 32K.
138 |      */
139 | 
140 |     Posf *head; /* Heads of the hash chains or NIL. */
141 | 
142 |     uInt  ins_h;          /* hash index of string to be inserted */
143 |     uInt  hash_size;      /* number of elements in hash table */
144 |     uInt  hash_bits;      /* log2(hash_size) */
145 |     uInt  hash_mask;      /* hash_size-1 */
146 | 
147 |     uInt  hash_shift;
148 |     /* Number of bits by which ins_h must be shifted at each input
149 |      * step. It must be such that after MIN_MATCH steps, the oldest
150 |      * byte no longer takes part in the hash key, that is:
151 |      *   hash_shift * MIN_MATCH >= hash_bits
152 |      */
153 | 
154 |     long block_start;
155 |     /* Window position at the beginning of the current output block. Gets
156 |      * negative when the window is moved backwards.
157 |      */
158 | 
159 |     uInt match_length;           /* length of best match */
160 |     IPos prev_match;             /* previous match */
161 |     int match_available;         /* set if previous match exists */
162 |     uInt strstart;               /* start of string to insert */
163 |     uInt match_start;            /* start of matching string */
164 |     uInt lookahead;              /* number of valid bytes ahead in window */
165 | 
166 |     uInt prev_length;
167 |     /* Length of the best match at previous step. Matches not greater than this
168 |      * are discarded. This is used in the lazy match evaluation.
169 |      */
170 | 
171 |     uInt max_chain_length;
172 |     /* To speed up deflation, hash chains are never searched beyond this
173 |      * length.  A higher limit improves compression ratio but degrades the
174 |      * speed.
175 |      */
176 | 
177 |     uInt max_lazy_match;
178 |     /* Attempt to find a better match only when the current match is strictly
179 |      * smaller than this value. This mechanism is used only for compression
180 |      * levels >= 4.
181 |      */
182 | #   define max_insert_length  max_lazy_match
183 |     /* Insert new strings in the hash table only if the match length is not
184 |      * greater than this length. This saves time but degrades compression.
185 |      * max_insert_length is used only for compression levels <= 3.
186 |      */
187 | 
188 |     int level;    /* compression level (1..9) */
189 |     int strategy; /* favor or force Huffman coding*/
190 | 
191 |     uInt good_match;
192 |     /* Use a faster search when the previous match is longer than this */
193 | 
194 |     int nice_match; /* Stop searching when current match exceeds this */
195 | 
196 |                 /* used by trees.c: */
197 |     /* Didn't use ct_data typedef below to suppress compiler warning */
198 |     struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
199 |     struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
200 |     struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
201 | 
202 |     struct tree_desc_s l_desc;               /* desc. for literal tree */
203 |     struct tree_desc_s d_desc;               /* desc. for distance tree */
204 |     struct tree_desc_s bl_desc;              /* desc. for bit length tree */
205 | 
206 |     ush bl_count[MAX_BITS+1];
207 |     /* number of codes at each bit length for an optimal tree */
208 | 
209 |     int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
210 |     int heap_len;               /* number of elements in the heap */
211 |     int heap_max;               /* element of largest frequency */
212 |     /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
213 |      * The same heap array is used to build all trees.
214 |      */
215 | 
216 |     uch depth[2*L_CODES+1];
217 |     /* Depth of each subtree used as tie breaker for trees of equal frequency
218 |      */
219 | 
220 |     uchf *l_buf;          /* buffer for literals or lengths */
221 | 
222 |     uInt  lit_bufsize;
223 |     /* Size of match buffer for literals/lengths.  There are 4 reasons for
224 |      * limiting lit_bufsize to 64K:
225 |      *   - frequencies can be kept in 16 bit counters
226 |      *   - if compression is not successful for the first block, all input
227 |      *     data is still in the window so we can still emit a stored block even
228 |      *     when input comes from standard input.  (This can also be done for
229 |      *     all blocks if lit_bufsize is not greater than 32K.)
230 |      *   - if compression is not successful for a file smaller than 64K, we can
231 |      *     even emit a stored file instead of a stored block (saving 5 bytes).
232 |      *     This is applicable only for zip (not gzip or zlib).
233 |      *   - creating new Huffman trees less frequently may not provide fast
234 |      *     adaptation to changes in the input data statistics. (Take for
235 |      *     example a binary file with poorly compressible code followed by
236 |      *     a highly compressible string table.) Smaller buffer sizes give
237 |      *     fast adaptation but have of course the overhead of transmitting
238 |      *     trees more frequently.
239 |      *   - I can't count above 4
240 |      */
241 | 
242 |     uInt last_lit;      /* running index in l_buf */
243 | 
244 |     ushf *d_buf;
245 |     /* Buffer for distances. To simplify the code, d_buf and l_buf have
246 |      * the same number of elements. To use different lengths, an extra flag
247 |      * array would be necessary.
248 |      */
249 | 
250 |     ulg opt_len;        /* bit length of current block with optimal trees */
251 |     ulg static_len;     /* bit length of current block with static trees */
252 |     uInt matches;       /* number of string matches in current block */
253 |     uInt insert;        /* bytes at end of window left to insert */
254 | 
255 | #ifdef ZLIB_DEBUG
256 |     ulg compressed_len; /* total bit length of compressed file mod 2^32 */
257 |     ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
258 | #endif
259 | 
260 |     ush bi_buf;
261 |     /* Output buffer. bits are inserted starting at the bottom (least
262 |      * significant bits).
263 |      */
264 |     int bi_valid;
265 |     /* Number of valid bits in bi_buf.  All bits above the last valid bit
266 |      * are always zero.
267 |      */
268 | 
269 |     ulg high_water;
270 |     /* High water mark offset in window for initialized bytes -- bytes above
271 |      * this are set to zero in order to avoid memory check warnings when
272 |      * longest match routines access bytes past the input.  This is then
273 |      * updated to the new high water mark.
274 |      */
275 | 
276 | } FAR deflate_state;
277 | 
278 | /* Output a byte on the stream.
279 |  * IN assertion: there is enough room in pending_buf.
280 |  */
281 | #define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
282 | 
283 | 
284 | #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
285 | /* Minimum amount of lookahead, except at the end of the input file.
286 |  * See deflate.c for comments about the MIN_MATCH+1.
287 |  */
288 | 
289 | #define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
290 | /* In order to simplify the code, particularly on 16 bit machines, match
291 |  * distances are limited to MAX_DIST instead of WSIZE.
292 |  */
293 | 
294 | #define WIN_INIT MAX_MATCH
295 | /* Number of bytes after end of data in window to initialize in order to avoid
296 |    memory checker errors from longest match routines */
297 | 
298 |         /* in trees.c */
299 | void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
300 | int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
301 | void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
302 |                         ulg stored_len, int last));
303 | void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
304 | void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
305 | void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
306 |                         ulg stored_len, int last));
307 | 
308 | #define d_code(dist) \
309 |    ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
310 | /* Mapping from a distance to a distance code. dist is the distance - 1 and
311 |  * must not have side effects. _dist_code[256] and _dist_code[257] are never
312 |  * used.
313 |  */
314 | 
315 | #ifndef ZLIB_DEBUG
316 | /* Inline versions of _tr_tally for speed: */
317 | 
318 | #if defined(GEN_TREES_H) || !defined(STDC)
319 |   extern uch ZLIB_INTERNAL _length_code[];
320 |   extern uch ZLIB_INTERNAL _dist_code[];
321 | #else
322 |   extern const uch ZLIB_INTERNAL _length_code[];
323 |   extern const uch ZLIB_INTERNAL _dist_code[];
324 | #endif
325 | 
326 | # define _tr_tally_lit(s, c, flush) \
327 |   { uch cc = (c); \
328 |     s->d_buf[s->last_lit] = 0; \
329 |     s->l_buf[s->last_lit++] = cc; \
330 |     s->dyn_ltree[cc].Freq++; \
331 |     flush = (s->last_lit == s->lit_bufsize-1); \
332 |    }
333 | # define _tr_tally_dist(s, distance, length, flush) \
334 |   { uch len = (uch)(length); \
335 |     ush dist = (ush)(distance); \
336 |     s->d_buf[s->last_lit] = dist; \
337 |     s->l_buf[s->last_lit++] = len; \
338 |     dist--; \
339 |     s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
340 |     s->dyn_dtree[d_code(dist)].Freq++; \
341 |     flush = (s->last_lit == s->lit_bufsize-1); \
342 |   }
343 | #else
344 | # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
345 | # define _tr_tally_dist(s, distance, length, flush) \
346 |               flush = _tr_tally(s, distance, length)
347 | #endif
348 | 
349 | #endif /* DEFLATE_H */
350 | 


--------------------------------------------------------------------------------
/zlib/crc32.c:
--------------------------------------------------------------------------------
  1 | /* crc32.c -- compute the CRC-32 of a data stream
  2 |  * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  *
  5 |  * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
  6 |  * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
  7 |  * tables for updating the shift register in one step with three exclusive-ors
  8 |  * instead of four steps with four exclusive-ors.  This results in about a
  9 |  * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
 10 |  */
 11 | 
 12 | /* @(#) $Id$ */
 13 | 
 14 | /*
 15 |   Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
 16 |   protection on the static variables used to control the first-use generation
 17 |   of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
 18 |   first call get_crc_table() to initialize the tables before allowing more than
 19 |   one thread to use crc32().
 20 | 
 21 |   DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
 22 |  */
 23 | 
 24 | #ifdef MAKECRCH
 25 | #  include <stdio.h>
 26 | #  ifndef DYNAMIC_CRC_TABLE
 27 | #    define DYNAMIC_CRC_TABLE
 28 | #  endif /* !DYNAMIC_CRC_TABLE */
 29 | #endif /* MAKECRCH */
 30 | 
 31 | #include "zutil.h"      /* for STDC and FAR definitions */
 32 | 
 33 | /* Definitions for doing the crc four data bytes at a time. */
 34 | #if !defined(NOBYFOUR) && defined(Z_U4)
 35 | #  define BYFOUR
 36 | #endif
 37 | #ifdef BYFOUR
 38 |    local unsigned long crc32_little OF((unsigned long,
 39 |                         const unsigned char FAR *, z_size_t));
 40 |    local unsigned long crc32_big OF((unsigned long,
 41 |                         const unsigned char FAR *, z_size_t));
 42 | #  define TBLS 8
 43 | #else
 44 | #  define TBLS 1
 45 | #endif /* BYFOUR */
 46 | 
 47 | /* Local functions for crc concatenation */
 48 | local unsigned long gf2_matrix_times OF((unsigned long *mat,
 49 |                                          unsigned long vec));
 50 | local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
 51 | local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
 52 | 
 53 | 
 54 | #ifdef DYNAMIC_CRC_TABLE
 55 | 
 56 | local volatile int crc_table_empty = 1;
 57 | local z_crc_t FAR crc_table[TBLS][256];
 58 | local void make_crc_table OF((void));
 59 | #ifdef MAKECRCH
 60 |    local void write_table OF((FILE *, const z_crc_t FAR *));
 61 | #endif /* MAKECRCH */
 62 | /*
 63 |   Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
 64 |   x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
 65 | 
 66 |   Polynomials over GF(2) are represented in binary, one bit per coefficient,
 67 |   with the lowest powers in the most significant bit.  Then adding polynomials
 68 |   is just exclusive-or, and multiplying a polynomial by x is a right shift by
 69 |   one.  If we call the above polynomial p, and represent a byte as the
 70 |   polynomial q, also with the lowest power in the most significant bit (so the
 71 |   byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
 72 |   where a mod b means the remainder after dividing a by b.
 73 | 
 74 |   This calculation is done using the shift-register method of multiplying and
 75 |   taking the remainder.  The register is initialized to zero, and for each
 76 |   incoming bit, x^32 is added mod p to the register if the bit is a one (where
 77 |   x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
 78 |   x (which is shifting right by one and adding x^32 mod p if the bit shifted
 79 |   out is a one).  We start with the highest power (least significant bit) of
 80 |   q and repeat for all eight bits of q.
 81 | 
 82 |   The first table is simply the CRC of all possible eight bit values.  This is
 83 |   all the information needed to generate CRCs on data a byte at a time for all
 84 |   combinations of CRC register values and incoming bytes.  The remaining tables
 85 |   allow for word-at-a-time CRC calculation for both big-endian and little-
 86 |   endian machines, where a word is four bytes.
 87 | */
 88 | local void make_crc_table()
 89 | {
 90 |     z_crc_t c;
 91 |     int n, k;
 92 |     z_crc_t poly;                       /* polynomial exclusive-or pattern */
 93 |     /* terms of polynomial defining this crc (except x^32): */
 94 |     static volatile int first = 1;      /* flag to limit concurrent making */
 95 |     static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
 96 | 
 97 |     /* See if another task is already doing this (not thread-safe, but better
 98 |        than nothing -- significantly reduces duration of vulnerability in
 99 |        case the advice about DYNAMIC_CRC_TABLE is ignored) */
100 |     if (first) {
101 |         first = 0;
102 | 
103 |         /* make exclusive-or pattern from polynomial (0xedb88320UL) */
104 |         poly = 0;
105 |         for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
106 |             poly |= (z_crc_t)1 << (31 - p[n]);
107 | 
108 |         /* generate a crc for every 8-bit value */
109 |         for (n = 0; n < 256; n++) {
110 |             c = (z_crc_t)n;
111 |             for (k = 0; k < 8; k++)
112 |                 c = c & 1 ? poly ^ (c >> 1) : c >> 1;
113 |             crc_table[0][n] = c;
114 |         }
115 | 
116 | #ifdef BYFOUR
117 |         /* generate crc for each value followed by one, two, and three zeros,
118 |            and then the byte reversal of those as well as the first table */
119 |         for (n = 0; n < 256; n++) {
120 |             c = crc_table[0][n];
121 |             crc_table[4][n] = ZSWAP32(c);
122 |             for (k = 1; k < 4; k++) {
123 |                 c = crc_table[0][c & 0xff] ^ (c >> 8);
124 |                 crc_table[k][n] = c;
125 |                 crc_table[k + 4][n] = ZSWAP32(c);
126 |             }
127 |         }
128 | #endif /* BYFOUR */
129 | 
130 |         crc_table_empty = 0;
131 |     }
132 |     else {      /* not first */
133 |         /* wait for the other guy to finish (not efficient, but rare) */
134 |         while (crc_table_empty)
135 |             ;
136 |     }
137 | 
138 | #ifdef MAKECRCH
139 |     /* write out CRC tables to crc32.h */
140 |     {
141 |         FILE *out;
142 | 
143 |         out = fopen("crc32.h", "w");
144 |         if (out == NULL) return;
145 |         fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
146 |         fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
147 |         fprintf(out, "local const z_crc_t FAR ");
148 |         fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
149 |         write_table(out, crc_table[0]);
150 | #  ifdef BYFOUR
151 |         fprintf(out, "#ifdef BYFOUR\n");
152 |         for (k = 1; k < 8; k++) {
153 |             fprintf(out, "  },\n  {\n");
154 |             write_table(out, crc_table[k]);
155 |         }
156 |         fprintf(out, "#endif\n");
157 | #  endif /* BYFOUR */
158 |         fprintf(out, "  }\n};\n");
159 |         fclose(out);
160 |     }
161 | #endif /* MAKECRCH */
162 | }
163 | 
164 | #ifdef MAKECRCH
165 | local void write_table(out, table)
166 |     FILE *out;
167 |     const z_crc_t FAR *table;
168 | {
169 |     int n;
170 | 
171 |     for (n = 0; n < 256; n++)
172 |         fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
173 |                 (unsigned long)(table[n]),
174 |                 n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
175 | }
176 | #endif /* MAKECRCH */
177 | 
178 | #else /* !DYNAMIC_CRC_TABLE */
179 | /* ========================================================================
180 |  * Tables of CRC-32s of all single-byte values, made by make_crc_table().
181 |  */
182 | #include "crc32.h"
183 | #endif /* DYNAMIC_CRC_TABLE */
184 | 
185 | /* =========================================================================
186 |  * This function can be used by asm versions of crc32()
187 |  */
188 | const z_crc_t FAR * ZEXPORT get_crc_table()
189 | {
190 | #ifdef DYNAMIC_CRC_TABLE
191 |     if (crc_table_empty)
192 |         make_crc_table();
193 | #endif /* DYNAMIC_CRC_TABLE */
194 |     return (const z_crc_t FAR *)crc_table;
195 | }
196 | 
197 | /* ========================================================================= */
198 | #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
199 | #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
200 | 
201 | /* ========================================================================= */
202 | unsigned long ZEXPORT crc32_z(crc, buf, len)
203 |     unsigned long crc;
204 |     const unsigned char FAR *buf;
205 |     z_size_t len;
206 | {
207 |     if (buf == Z_NULL) return 0UL;
208 | 
209 | #ifdef DYNAMIC_CRC_TABLE
210 |     if (crc_table_empty)
211 |         make_crc_table();
212 | #endif /* DYNAMIC_CRC_TABLE */
213 | 
214 | #ifdef BYFOUR
215 |     if (sizeof(void *) == sizeof(ptrdiff_t)) {
216 |         z_crc_t endian;
217 | 
218 |         endian = 1;
219 |         if (*((unsigned char *)(&endian)))
220 |             return crc32_little(crc, buf, len);
221 |         else
222 |             return crc32_big(crc, buf, len);
223 |     }
224 | #endif /* BYFOUR */
225 |     crc = crc ^ 0xffffffffUL;
226 |     while (len >= 8) {
227 |         DO8;
228 |         len -= 8;
229 |     }
230 |     if (len) do {
231 |         DO1;
232 |     } while (--len);
233 |     return crc ^ 0xffffffffUL;
234 | }
235 | 
236 | /* ========================================================================= */
237 | unsigned long ZEXPORT crc32(crc, buf, len)
238 |     unsigned long crc;
239 |     const unsigned char FAR *buf;
240 |     uInt len;
241 | {
242 |     return crc32_z(crc, buf, len);
243 | }
244 | 
245 | #ifdef BYFOUR
246 | 
247 | /*
248 |    This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
249 |    integer pointer type. This violates the strict aliasing rule, where a
250 |    compiler can assume, for optimization purposes, that two pointers to
251 |    fundamentally different types won't ever point to the same memory. This can
252 |    manifest as a problem only if one of the pointers is written to. This code
253 |    only reads from those pointers. So long as this code remains isolated in
254 |    this compilation unit, there won't be a problem. For this reason, this code
255 |    should not be copied and pasted into a compilation unit in which other code
256 |    writes to the buffer that is passed to these routines.
257 |  */
258 | 
259 | /* ========================================================================= */
260 | #define DOLIT4 c ^= *buf4++; \
261 |         c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
262 |             crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
263 | #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
264 | 
265 | /* ========================================================================= */
266 | local unsigned long crc32_little(crc, buf, len)
267 |     unsigned long crc;
268 |     const unsigned char FAR *buf;
269 |     z_size_t len;
270 | {
271 |     register z_crc_t c;
272 |     register const z_crc_t FAR *buf4;
273 | 
274 |     c = (z_crc_t)crc;
275 |     c = ~c;
276 |     while (len && ((ptrdiff_t)buf & 3)) {
277 |         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
278 |         len--;
279 |     }
280 | 
281 |     buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
282 |     while (len >= 32) {
283 |         DOLIT32;
284 |         len -= 32;
285 |     }
286 |     while (len >= 4) {
287 |         DOLIT4;
288 |         len -= 4;
289 |     }
290 |     buf = (const unsigned char FAR *)buf4;
291 | 
292 |     if (len) do {
293 |         c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
294 |     } while (--len);
295 |     c = ~c;
296 |     return (unsigned long)c;
297 | }
298 | 
299 | /* ========================================================================= */
300 | #define DOBIG4 c ^= *buf4++; \
301 |         c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
302 |             crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
303 | #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
304 | 
305 | /* ========================================================================= */
306 | local unsigned long crc32_big(crc, buf, len)
307 |     unsigned long crc;
308 |     const unsigned char FAR *buf;
309 |     z_size_t len;
310 | {
311 |     register z_crc_t c;
312 |     register const z_crc_t FAR *buf4;
313 | 
314 |     c = ZSWAP32((z_crc_t)crc);
315 |     c = ~c;
316 |     while (len && ((ptrdiff_t)buf & 3)) {
317 |         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
318 |         len--;
319 |     }
320 | 
321 |     buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
322 |     while (len >= 32) {
323 |         DOBIG32;
324 |         len -= 32;
325 |     }
326 |     while (len >= 4) {
327 |         DOBIG4;
328 |         len -= 4;
329 |     }
330 |     buf = (const unsigned char FAR *)buf4;
331 | 
332 |     if (len) do {
333 |         c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
334 |     } while (--len);
335 |     c = ~c;
336 |     return (unsigned long)(ZSWAP32(c));
337 | }
338 | 
339 | #endif /* BYFOUR */
340 | 
341 | #define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
342 | 
343 | /* ========================================================================= */
344 | local unsigned long gf2_matrix_times(mat, vec)
345 |     unsigned long *mat;
346 |     unsigned long vec;
347 | {
348 |     unsigned long sum;
349 | 
350 |     sum = 0;
351 |     while (vec) {
352 |         if (vec & 1)
353 |             sum ^= *mat;
354 |         vec >>= 1;
355 |         mat++;
356 |     }
357 |     return sum;
358 | }
359 | 
360 | /* ========================================================================= */
361 | local void gf2_matrix_square(square, mat)
362 |     unsigned long *square;
363 |     unsigned long *mat;
364 | {
365 |     int n;
366 | 
367 |     for (n = 0; n < GF2_DIM; n++)
368 |         square[n] = gf2_matrix_times(mat, mat[n]);
369 | }
370 | 
371 | /* ========================================================================= */
372 | local uLong crc32_combine_(crc1, crc2, len2)
373 |     uLong crc1;
374 |     uLong crc2;
375 |     z_off64_t len2;
376 | {
377 |     int n;
378 |     unsigned long row;
379 |     unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
380 |     unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
381 | 
382 |     /* degenerate case (also disallow negative lengths) */
383 |     if (len2 <= 0)
384 |         return crc1;
385 | 
386 |     /* put operator for one zero bit in odd */
387 |     odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
388 |     row = 1;
389 |     for (n = 1; n < GF2_DIM; n++) {
390 |         odd[n] = row;
391 |         row <<= 1;
392 |     }
393 | 
394 |     /* put operator for two zero bits in even */
395 |     gf2_matrix_square(even, odd);
396 | 
397 |     /* put operator for four zero bits in odd */
398 |     gf2_matrix_square(odd, even);
399 | 
400 |     /* apply len2 zeros to crc1 (first square will put the operator for one
401 |        zero byte, eight zero bits, in even) */
402 |     do {
403 |         /* apply zeros operator for this bit of len2 */
404 |         gf2_matrix_square(even, odd);
405 |         if (len2 & 1)
406 |             crc1 = gf2_matrix_times(even, crc1);
407 |         len2 >>= 1;
408 | 
409 |         /* if no more bits set, then done */
410 |         if (len2 == 0)
411 |             break;
412 | 
413 |         /* another iteration of the loop with odd and even swapped */
414 |         gf2_matrix_square(odd, even);
415 |         if (len2 & 1)
416 |             crc1 = gf2_matrix_times(odd, crc1);
417 |         len2 >>= 1;
418 | 
419 |         /* if no more bits set, then done */
420 |     } while (len2 != 0);
421 | 
422 |     /* return combined crc */
423 |     crc1 ^= crc2;
424 |     return crc1;
425 | }
426 | 
427 | /* ========================================================================= */
428 | uLong ZEXPORT crc32_combine(crc1, crc2, len2)
429 |     uLong crc1;
430 |     uLong crc2;
431 |     z_off_t len2;
432 | {
433 |     return crc32_combine_(crc1, crc2, len2);
434 | }
435 | 
436 | uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
437 |     uLong crc1;
438 |     uLong crc2;
439 |     z_off64_t len2;
440 | {
441 |     return crc32_combine_(crc1, crc2, len2);
442 | }
443 | 


--------------------------------------------------------------------------------
/zlib/zconf.h:
--------------------------------------------------------------------------------
  1 | /* zconf.h -- configuration of the zlib compression library
  2 |  * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /* @(#) $Id$ */
  7 | 
  8 | #ifndef ZCONF_H
  9 | #define ZCONF_H
 10 | 
 11 | /*
 12 |  * If you *really* need a unique prefix for all types and library functions,
 13 |  * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
 14 |  * Even better than compiling with -DZ_PREFIX would be to use configure to set
 15 |  * this permanently in zconf.h using "./configure --zprefix".
 16 |  */
 17 | #ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
 18 | #  define Z_PREFIX_SET
 19 | 
 20 | /* all linked symbols and init macros */
 21 | #  define _dist_code            z__dist_code
 22 | #  define _length_code          z__length_code
 23 | #  define _tr_align             z__tr_align
 24 | #  define _tr_flush_bits        z__tr_flush_bits
 25 | #  define _tr_flush_block       z__tr_flush_block
 26 | #  define _tr_init              z__tr_init
 27 | #  define _tr_stored_block      z__tr_stored_block
 28 | #  define _tr_tally             z__tr_tally
 29 | #  define adler32               z_adler32
 30 | #  define adler32_combine       z_adler32_combine
 31 | #  define adler32_combine64     z_adler32_combine64
 32 | #  define adler32_z             z_adler32_z
 33 | #  ifndef Z_SOLO
 34 | #    define compress              z_compress
 35 | #    define compress2             z_compress2
 36 | #    define compressBound         z_compressBound
 37 | #  endif
 38 | #  define crc32                 z_crc32
 39 | #  define crc32_combine         z_crc32_combine
 40 | #  define crc32_combine64       z_crc32_combine64
 41 | #  define crc32_z               z_crc32_z
 42 | #  define deflate               z_deflate
 43 | #  define deflateBound          z_deflateBound
 44 | #  define deflateCopy           z_deflateCopy
 45 | #  define deflateEnd            z_deflateEnd
 46 | #  define deflateGetDictionary  z_deflateGetDictionary
 47 | #  define deflateInit           z_deflateInit
 48 | #  define deflateInit2          z_deflateInit2
 49 | #  define deflateInit2_         z_deflateInit2_
 50 | #  define deflateInit_          z_deflateInit_
 51 | #  define deflateParams         z_deflateParams
 52 | #  define deflatePending        z_deflatePending
 53 | #  define deflatePrime          z_deflatePrime
 54 | #  define deflateReset          z_deflateReset
 55 | #  define deflateResetKeep      z_deflateResetKeep
 56 | #  define deflateSetDictionary  z_deflateSetDictionary
 57 | #  define deflateSetHeader      z_deflateSetHeader
 58 | #  define deflateTune           z_deflateTune
 59 | #  define deflate_copyright     z_deflate_copyright
 60 | #  define get_crc_table         z_get_crc_table
 61 | #  ifndef Z_SOLO
 62 | #    define gz_error              z_gz_error
 63 | #    define gz_intmax             z_gz_intmax
 64 | #    define gz_strwinerror        z_gz_strwinerror
 65 | #    define gzbuffer              z_gzbuffer
 66 | #    define gzclearerr            z_gzclearerr
 67 | #    define gzclose               z_gzclose
 68 | #    define gzclose_r             z_gzclose_r
 69 | #    define gzclose_w             z_gzclose_w
 70 | #    define gzdirect              z_gzdirect
 71 | #    define gzdopen               z_gzdopen
 72 | #    define gzeof                 z_gzeof
 73 | #    define gzerror               z_gzerror
 74 | #    define gzflush               z_gzflush
 75 | #    define gzfread               z_gzfread
 76 | #    define gzfwrite              z_gzfwrite
 77 | #    define gzgetc                z_gzgetc
 78 | #    define gzgetc_               z_gzgetc_
 79 | #    define gzgets                z_gzgets
 80 | #    define gzoffset              z_gzoffset
 81 | #    define gzoffset64            z_gzoffset64
 82 | #    define gzopen                z_gzopen
 83 | #    define gzopen64              z_gzopen64
 84 | #    ifdef _WIN32
 85 | #      define gzopen_w              z_gzopen_w
 86 | #    endif
 87 | #    define gzprintf              z_gzprintf
 88 | #    define gzputc                z_gzputc
 89 | #    define gzputs                z_gzputs
 90 | #    define gzread                z_gzread
 91 | #    define gzrewind              z_gzrewind
 92 | #    define gzseek                z_gzseek
 93 | #    define gzseek64              z_gzseek64
 94 | #    define gzsetparams           z_gzsetparams
 95 | #    define gztell                z_gztell
 96 | #    define gztell64              z_gztell64
 97 | #    define gzungetc              z_gzungetc
 98 | #    define gzvprintf             z_gzvprintf
 99 | #    define gzwrite               z_gzwrite
100 | #  endif
101 | #  define inflate               z_inflate
102 | #  define inflateBack           z_inflateBack
103 | #  define inflateBackEnd        z_inflateBackEnd
104 | #  define inflateBackInit       z_inflateBackInit
105 | #  define inflateBackInit_      z_inflateBackInit_
106 | #  define inflateCodesUsed      z_inflateCodesUsed
107 | #  define inflateCopy           z_inflateCopy
108 | #  define inflateEnd            z_inflateEnd
109 | #  define inflateGetDictionary  z_inflateGetDictionary
110 | #  define inflateGetHeader      z_inflateGetHeader
111 | #  define inflateInit           z_inflateInit
112 | #  define inflateInit2          z_inflateInit2
113 | #  define inflateInit2_         z_inflateInit2_
114 | #  define inflateInit_          z_inflateInit_
115 | #  define inflateMark           z_inflateMark
116 | #  define inflatePrime          z_inflatePrime
117 | #  define inflateReset          z_inflateReset
118 | #  define inflateReset2         z_inflateReset2
119 | #  define inflateResetKeep      z_inflateResetKeep
120 | #  define inflateSetDictionary  z_inflateSetDictionary
121 | #  define inflateSync           z_inflateSync
122 | #  define inflateSyncPoint      z_inflateSyncPoint
123 | #  define inflateUndermine      z_inflateUndermine
124 | #  define inflateValidate       z_inflateValidate
125 | #  define inflate_copyright     z_inflate_copyright
126 | #  define inflate_fast          z_inflate_fast
127 | #  define inflate_table         z_inflate_table
128 | #  ifndef Z_SOLO
129 | #    define uncompress            z_uncompress
130 | #    define uncompress2           z_uncompress2
131 | #  endif
132 | #  define zError                z_zError
133 | #  ifndef Z_SOLO
134 | #    define zcalloc               z_zcalloc
135 | #    define zcfree                z_zcfree
136 | #  endif
137 | #  define zlibCompileFlags      z_zlibCompileFlags
138 | #  define zlibVersion           z_zlibVersion
139 | 
140 | /* all zlib typedefs in zlib.h and zconf.h */
141 | #  define Byte                  z_Byte
142 | #  define Bytef                 z_Bytef
143 | #  define alloc_func            z_alloc_func
144 | #  define charf                 z_charf
145 | #  define free_func             z_free_func
146 | #  ifndef Z_SOLO
147 | #    define gzFile                z_gzFile
148 | #  endif
149 | #  define gz_header             z_gz_header
150 | #  define gz_headerp            z_gz_headerp
151 | #  define in_func               z_in_func
152 | #  define intf                  z_intf
153 | #  define out_func              z_out_func
154 | #  define uInt                  z_uInt
155 | #  define uIntf                 z_uIntf
156 | #  define uLong                 z_uLong
157 | #  define uLongf                z_uLongf
158 | #  define voidp                 z_voidp
159 | #  define voidpc                z_voidpc
160 | #  define voidpf                z_voidpf
161 | 
162 | /* all zlib structs in zlib.h and zconf.h */
163 | #  define gz_header_s           z_gz_header_s
164 | #  define internal_state        z_internal_state
165 | 
166 | #endif
167 | 
168 | #if defined(__MSDOS__) && !defined(MSDOS)
169 | #  define MSDOS
170 | #endif
171 | #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
172 | #  define OS2
173 | #endif
174 | #if defined(_WINDOWS) && !defined(WINDOWS)
175 | #  define WINDOWS
176 | #endif
177 | #if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
178 | #  ifndef WIN32
179 | #    define WIN32
180 | #  endif
181 | #endif
182 | #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
183 | #  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
184 | #    ifndef SYS16BIT
185 | #      define SYS16BIT
186 | #    endif
187 | #  endif
188 | #endif
189 | 
190 | /*
191 |  * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
192 |  * than 64k bytes at a time (needed on systems with 16-bit int).
193 |  */
194 | #ifdef SYS16BIT
195 | #  define MAXSEG_64K
196 | #endif
197 | #ifdef MSDOS
198 | #  define UNALIGNED_OK
199 | #endif
200 | 
201 | #ifdef __STDC_VERSION__
202 | #  ifndef STDC
203 | #    define STDC
204 | #  endif
205 | #  if __STDC_VERSION__ >= 199901L
206 | #    ifndef STDC99
207 | #      define STDC99
208 | #    endif
209 | #  endif
210 | #endif
211 | #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
212 | #  define STDC
213 | #endif
214 | #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
215 | #  define STDC
216 | #endif
217 | #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
218 | #  define STDC
219 | #endif
220 | #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
221 | #  define STDC
222 | #endif
223 | 
224 | #if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
225 | #  define STDC
226 | #endif
227 | 
228 | #ifndef STDC
229 | #  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
230 | #    define const       /* note: need a more gentle solution here */
231 | #  endif
232 | #endif
233 | 
234 | #if defined(ZLIB_CONST) && !defined(z_const)
235 | #  define z_const const
236 | #else
237 | #  define z_const
238 | #endif
239 | 
240 | #ifdef Z_SOLO
241 |    typedef unsigned long z_size_t;
242 | #else
243 | #  define z_longlong long long
244 | #  if defined(NO_SIZE_T)
245 |      typedef unsigned NO_SIZE_T z_size_t;
246 | #  elif defined(STDC)
247 | #    include <stddef.h>
248 |      typedef size_t z_size_t;
249 | #  else
250 |      typedef unsigned long z_size_t;
251 | #  endif
252 | #  undef z_longlong
253 | #endif
254 | 
255 | /* Maximum value for memLevel in deflateInit2 */
256 | #ifndef MAX_MEM_LEVEL
257 | #  ifdef MAXSEG_64K
258 | #    define MAX_MEM_LEVEL 8
259 | #  else
260 | #    define MAX_MEM_LEVEL 9
261 | #  endif
262 | #endif
263 | 
264 | /* Maximum value for windowBits in deflateInit2 and inflateInit2.
265 |  * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
266 |  * created by gzip. (Files created by minigzip can still be extracted by
267 |  * gzip.)
268 |  */
269 | #ifndef MAX_WBITS
270 | #  define MAX_WBITS   15 /* 32K LZ77 window */
271 | #endif
272 | 
273 | /* The memory requirements for deflate are (in bytes):
274 |             (1 << (windowBits+2)) +  (1 << (memLevel+9))
275 |  that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
276 |  plus a few kilobytes for small objects. For example, if you want to reduce
277 |  the default memory requirements from 256K to 128K, compile with
278 |      make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
279 |  Of course this will generally degrade compression (there's no free lunch).
280 | 
281 |    The memory requirements for inflate are (in bytes) 1 << windowBits
282 |  that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
283 |  for small objects.
284 | */
285 | 
286 |                         /* Type declarations */
287 | 
288 | #ifndef OF /* function prototypes */
289 | #  ifdef STDC
290 | #    define OF(args)  args
291 | #  else
292 | #    define OF(args)  ()
293 | #  endif
294 | #endif
295 | 
296 | #ifndef Z_ARG /* function prototypes for stdarg */
297 | #  if defined(STDC) || defined(Z_HAVE_STDARG_H)
298 | #    define Z_ARG(args)  args
299 | #  else
300 | #    define Z_ARG(args)  ()
301 | #  endif
302 | #endif
303 | 
304 | /* The following definitions for FAR are needed only for MSDOS mixed
305 |  * model programming (small or medium model with some far allocations).
306 |  * This was tested only with MSC; for other MSDOS compilers you may have
307 |  * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
308 |  * just define FAR to be empty.
309 |  */
310 | #ifdef SYS16BIT
311 | #  if defined(M_I86SM) || defined(M_I86MM)
312 |      /* MSC small or medium model */
313 | #    define SMALL_MEDIUM
314 | #    ifdef _MSC_VER
315 | #      define FAR _far
316 | #    else
317 | #      define FAR far
318 | #    endif
319 | #  endif
320 | #  if (defined(__SMALL__) || defined(__MEDIUM__))
321 |      /* Turbo C small or medium model */
322 | #    define SMALL_MEDIUM
323 | #    ifdef __BORLANDC__
324 | #      define FAR _far
325 | #    else
326 | #      define FAR far
327 | #    endif
328 | #  endif
329 | #endif
330 | 
331 | #if defined(WINDOWS) || defined(WIN32)
332 |    /* If building or using zlib as a DLL, define ZLIB_DLL.
333 |     * This is not mandatory, but it offers a little performance increase.
334 |     */
335 | #  ifdef ZLIB_DLL
336 | #    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
337 | #      ifdef ZLIB_INTERNAL
338 | #        define ZEXTERN extern __declspec(dllexport)
339 | #      else
340 | #        define ZEXTERN extern __declspec(dllimport)
341 | #      endif
342 | #    endif
343 | #  endif  /* ZLIB_DLL */
344 |    /* If building or using zlib with the WINAPI/WINAPIV calling convention,
345 |     * define ZLIB_WINAPI.
346 |     * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
347 |     */
348 | #  ifdef ZLIB_WINAPI
349 | #    ifdef FAR
350 | #      undef FAR
351 | #    endif
352 | #    include <windows.h>
353 |      /* No need for _export, use ZLIB.DEF instead. */
354 |      /* For complete Windows compatibility, use WINAPI, not __stdcall. */
355 | #    define ZEXPORT WINAPI
356 | #    ifdef WIN32
357 | #      define ZEXPORTVA WINAPIV
358 | #    else
359 | #      define ZEXPORTVA FAR CDECL
360 | #    endif
361 | #  endif
362 | #endif
363 | 
364 | #if defined (__BEOS__)
365 | #  ifdef ZLIB_DLL
366 | #    ifdef ZLIB_INTERNAL
367 | #      define ZEXPORT   __declspec(dllexport)
368 | #      define ZEXPORTVA __declspec(dllexport)
369 | #    else
370 | #      define ZEXPORT   __declspec(dllimport)
371 | #      define ZEXPORTVA __declspec(dllimport)
372 | #    endif
373 | #  endif
374 | #endif
375 | 
376 | #ifndef ZEXTERN
377 | #  define ZEXTERN extern
378 | #endif
379 | #ifndef ZEXPORT
380 | #  define ZEXPORT
381 | #endif
382 | #ifndef ZEXPORTVA
383 | #  define ZEXPORTVA
384 | #endif
385 | 
386 | #ifndef FAR
387 | #  define FAR
388 | #endif
389 | 
390 | #if !defined(__MACTYPES__)
391 | typedef unsigned char  Byte;  /* 8 bits */
392 | #endif
393 | typedef unsigned int   uInt;  /* 16 bits or more */
394 | typedef unsigned long  uLong; /* 32 bits or more */
395 | 
396 | #ifdef SMALL_MEDIUM
397 |    /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
398 | #  define Bytef Byte FAR
399 | #else
400 |    typedef Byte  FAR Bytef;
401 | #endif
402 | typedef char  FAR charf;
403 | typedef int   FAR intf;
404 | typedef uInt  FAR uIntf;
405 | typedef uLong FAR uLongf;
406 | 
407 | #ifdef STDC
408 |    typedef void const *voidpc;
409 |    typedef void FAR   *voidpf;
410 |    typedef void       *voidp;
411 | #else
412 |    typedef Byte const *voidpc;
413 |    typedef Byte FAR   *voidpf;
414 |    typedef Byte       *voidp;
415 | #endif
416 | 
417 | #if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
418 | #  include <limits.h>
419 | #  if (UINT_MAX == 0xffffffffUL)
420 | #    define Z_U4 unsigned
421 | #  elif (ULONG_MAX == 0xffffffffUL)
422 | #    define Z_U4 unsigned long
423 | #  elif (USHRT_MAX == 0xffffffffUL)
424 | #    define Z_U4 unsigned short
425 | #  endif
426 | #endif
427 | 
428 | #ifdef Z_U4
429 |    typedef Z_U4 z_crc_t;
430 | #else
431 |    typedef unsigned long z_crc_t;
432 | #endif
433 | 
434 | #ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
435 | #  define Z_HAVE_UNISTD_H
436 | #endif
437 | 
438 | #ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
439 | #  define Z_HAVE_STDARG_H
440 | #endif
441 | 
442 | #ifdef STDC
443 | #  ifndef Z_SOLO
444 | #    include <sys/types.h>      /* for off_t */
445 | #  endif
446 | #endif
447 | 
448 | #if defined(STDC) || defined(Z_HAVE_STDARG_H)
449 | #  ifndef Z_SOLO
450 | #    include <stdarg.h>         /* for va_list */
451 | #  endif
452 | #endif
453 | 
454 | #ifdef _WIN32
455 | #  ifndef Z_SOLO
456 | #    include <stddef.h>         /* for wchar_t */
457 | #  endif
458 | #endif
459 | 
460 | /* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
461 |  * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
462 |  * though the former does not conform to the LFS document), but considering
463 |  * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
464 |  * equivalently requesting no 64-bit operations
465 |  */
466 | #if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
467 | #  undef _LARGEFILE64_SOURCE
468 | #endif
469 | 
470 | #if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
471 | #  define Z_HAVE_UNISTD_H
472 | #endif
473 | #ifndef Z_SOLO
474 | #  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
475 | #    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
476 | #    ifdef VMS
477 | #      include <unixio.h>       /* for off_t */
478 | #    endif
479 | #    ifndef z_off_t
480 | #      define z_off_t off_t
481 | #    endif
482 | #  endif
483 | #endif
484 | 
485 | #if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
486 | #  define Z_LFS64
487 | #endif
488 | 
489 | #if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
490 | #  define Z_LARGE64
491 | #endif
492 | 
493 | #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
494 | #  define Z_WANT64
495 | #endif
496 | 
497 | #if !defined(SEEK_SET) && !defined(Z_SOLO)
498 | #  define SEEK_SET        0       /* Seek from beginning of file.  */
499 | #  define SEEK_CUR        1       /* Seek from current position.  */
500 | #  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
501 | #endif
502 | 
503 | #ifndef z_off_t
504 | #  define z_off_t long
505 | #endif
506 | 
507 | #if !defined(_WIN32) && defined(Z_LARGE64)
508 | #  define z_off64_t off64_t
509 | #else
510 | #  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
511 | #    define z_off64_t __int64
512 | #  else
513 | #    define z_off64_t z_off_t
514 | #  endif
515 | #endif
516 | 
517 | /* MVS linker does not support external names larger than 8 bytes */
518 | #if defined(__MVS__)
519 |   #pragma map(deflateInit_,"DEIN")
520 |   #pragma map(deflateInit2_,"DEIN2")
521 |   #pragma map(deflateEnd,"DEEND")
522 |   #pragma map(deflateBound,"DEBND")
523 |   #pragma map(inflateInit_,"ININ")
524 |   #pragma map(inflateInit2_,"ININ2")
525 |   #pragma map(inflateEnd,"INEND")
526 |   #pragma map(inflateSync,"INSY")
527 |   #pragma map(inflateSetDictionary,"INSEDI")
528 |   #pragma map(compressBound,"CMBND")
529 |   #pragma map(inflate_table,"INTABL")
530 |   #pragma map(inflate_fast,"INFA")
531 |   #pragma map(inflate_copyright,"INCOPY")
532 | #endif
533 | 
534 | #endif /* ZCONF_H */
535 | 


--------------------------------------------------------------------------------
/zlib/infback.c:
--------------------------------------------------------------------------------
  1 | /* infback.c -- inflate using a call-back interface
  2 |  * Copyright (C) 1995-2016 Mark Adler
  3 |  * For conditions of distribution and use, see copyright notice in zlib.h
  4 |  */
  5 | 
  6 | /*
  7 |    This code is largely copied from inflate.c.  Normally either infback.o or
  8 |    inflate.o would be linked into an application--not both.  The interface
  9 |    with inffast.c is retained so that optimized assembler-coded versions of
 10 |    inflate_fast() can be used with either inflate.c or infback.c.
 11 |  */
 12 | 
 13 | #include "zutil.h"
 14 | #include "inftrees.h"
 15 | #include "inflate.h"
 16 | #include "inffast.h"
 17 | 
 18 | /* function prototypes */
 19 | local void fixedtables OF((struct inflate_state FAR *state));
 20 | 
 21 | /*
 22 |    strm provides memory allocation functions in zalloc and zfree, or
 23 |    Z_NULL to use the library memory allocation functions.
 24 | 
 25 |    windowBits is in the range 8..15, and window is a user-supplied
 26 |    window and output buffer that is 2**windowBits bytes.
 27 |  */
 28 | int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
 29 | z_streamp strm;
 30 | int windowBits;
 31 | unsigned char FAR *window;
 32 | const char *version;
 33 | int stream_size;
 34 | {
 35 |     struct inflate_state FAR *state;
 36 | 
 37 |     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
 38 |         stream_size != (int)(sizeof(z_stream)))
 39 |         return Z_VERSION_ERROR;
 40 |     if (strm == Z_NULL || window == Z_NULL ||
 41 |         windowBits < 8 || windowBits > 15)
 42 |         return Z_STREAM_ERROR;
 43 |     strm->msg = Z_NULL;                 /* in case we return an error */
 44 |     if (strm->zalloc == (alloc_func)0) {
 45 | #ifdef Z_SOLO
 46 |         return Z_STREAM_ERROR;
 47 | #else
 48 |         strm->zalloc = zcalloc;
 49 |         strm->opaque = (voidpf)0;
 50 | #endif
 51 |     }
 52 |     if (strm->zfree == (free_func)0)
 53 | #ifdef Z_SOLO
 54 |         return Z_STREAM_ERROR;
 55 | #else
 56 |     strm->zfree = zcfree;
 57 | #endif
 58 |     state = (struct inflate_state FAR *)ZALLOC(strm, 1,
 59 |                                                sizeof(struct inflate_state));
 60 |     if (state == Z_NULL) return Z_MEM_ERROR;
 61 |     Tracev((stderr, "inflate: allocated\n"));
 62 |     strm->state = (struct internal_state FAR *)state;
 63 |     state->dmax = 32768U;
 64 |     state->wbits = (uInt)windowBits;
 65 |     state->wsize = 1U << windowBits;
 66 |     state->window = window;
 67 |     state->wnext = 0;
 68 |     state->whave = 0;
 69 |     return Z_OK;
 70 | }
 71 | 
 72 | /*
 73 |    Return state with length and distance decoding tables and index sizes set to
 74 |    fixed code decoding.  Normally this returns fixed tables from inffixed.h.
 75 |    If BUILDFIXED is defined, then instead this routine builds the tables the
 76 |    first time it's called, and returns those tables the first time and
 77 |    thereafter.  This reduces the size of the code by about 2K bytes, in
 78 |    exchange for a little execution time.  However, BUILDFIXED should not be
 79 |    used for threaded applications, since the rewriting of the tables and virgin
 80 |    may not be thread-safe.
 81 |  */
 82 | local void fixedtables(state)
 83 | struct inflate_state FAR *state;
 84 | {
 85 | #ifdef BUILDFIXED
 86 |     static int virgin = 1;
 87 |     static code *lenfix, *distfix;
 88 |     static code fixed[544];
 89 | 
 90 |     /* build fixed huffman tables if first call (may not be thread safe) */
 91 |     if (virgin) {
 92 |         unsigned sym, bits;
 93 |         static code *next;
 94 | 
 95 |         /* literal/length table */
 96 |         sym = 0;
 97 |         while (sym < 144) state->lens[sym++] = 8;
 98 |         while (sym < 256) state->lens[sym++] = 9;
 99 |         while (sym < 280) state->lens[sym++] = 7;
100 |         while (sym < 288) state->lens[sym++] = 8;
101 |         next = fixed;
102 |         lenfix = next;
103 |         bits = 9;
104 |         inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
105 | 
106 |         /* distance table */
107 |         sym = 0;
108 |         while (sym < 32) state->lens[sym++] = 5;
109 |         distfix = next;
110 |         bits = 5;
111 |         inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
112 | 
113 |         /* do this just once */
114 |         virgin = 0;
115 |     }
116 | #else /* !BUILDFIXED */
117 | #   include "inffixed.h"
118 | #endif /* BUILDFIXED */
119 |     state->lencode = lenfix;
120 |     state->lenbits = 9;
121 |     state->distcode = distfix;
122 |     state->distbits = 5;
123 | }
124 | 
125 | /* Macros for inflateBack(): */
126 | 
127 | /* Load returned state from inflate_fast() */
128 | #define LOAD() \
129 |     do { \
130 |         put = strm->next_out; \
131 |         left = strm->avail_out; \
132 |         next = strm->next_in; \
133 |         have = strm->avail_in; \
134 |         hold = state->hold; \
135 |         bits = state->bits; \
136 |     } while (0)
137 | 
138 | /* Set state from registers for inflate_fast() */
139 | #define RESTORE() \
140 |     do { \
141 |         strm->next_out = put; \
142 |         strm->avail_out = left; \
143 |         strm->next_in = next; \
144 |         strm->avail_in = have; \
145 |         state->hold = hold; \
146 |         state->bits = bits; \
147 |     } while (0)
148 | 
149 | /* Clear the input bit accumulator */
150 | #define INITBITS() \
151 |     do { \
152 |         hold = 0; \
153 |         bits = 0; \
154 |     } while (0)
155 | 
156 | /* Assure that some input is available.  If input is requested, but denied,
157 |    then return a Z_BUF_ERROR from inflateBack(). */
158 | #define PULL() \
159 |     do { \
160 |         if (have == 0) { \
161 |             have = in(in_desc, &next); \
162 |             if (have == 0) { \
163 |                 next = Z_NULL; \
164 |                 ret = Z_BUF_ERROR; \
165 |                 goto inf_leave; \
166 |             } \
167 |         } \
168 |     } while (0)
169 | 
170 | /* Get a byte of input into the bit accumulator, or return from inflateBack()
171 |    with an error if there is no input available. */
172 | #define PULLBYTE() \
173 |     do { \
174 |         PULL(); \
175 |         have--; \
176 |         hold += (unsigned long)(*next++) << bits; \
177 |         bits += 8; \
178 |     } while (0)
179 | 
180 | /* Assure that there are at least n bits in the bit accumulator.  If there is
181 |    not enough available input to do that, then return from inflateBack() with
182 |    an error. */
183 | #define NEEDBITS(n) \
184 |     do { \
185 |         while (bits < (unsigned)(n)) \
186 |             PULLBYTE(); \
187 |     } while (0)
188 | 
189 | /* Return the low n bits of the bit accumulator (n < 16) */
190 | #define BITS(n) \
191 |     ((unsigned)hold & ((1U << (n)) - 1))
192 | 
193 | /* Remove n bits from the bit accumulator */
194 | #define DROPBITS(n) \
195 |     do { \
196 |         hold >>= (n); \
197 |         bits -= (unsigned)(n); \
198 |     } while (0)
199 | 
200 | /* Remove zero to seven bits as needed to go to a byte boundary */
201 | #define BYTEBITS() \
202 |     do { \
203 |         hold >>= bits & 7; \
204 |         bits -= bits & 7; \
205 |     } while (0)
206 | 
207 | /* Assure that some output space is available, by writing out the window
208 |    if it's full.  If the write fails, return from inflateBack() with a
209 |    Z_BUF_ERROR. */
210 | #define ROOM() \
211 |     do { \
212 |         if (left == 0) { \
213 |             put = state->window; \
214 |             left = state->wsize; \
215 |             state->whave = left; \
216 |             if (out(out_desc, put, left)) { \
217 |                 ret = Z_BUF_ERROR; \
218 |                 goto inf_leave; \
219 |             } \
220 |         } \
221 |     } while (0)
222 | 
223 | /*
224 |    strm provides the memory allocation functions and window buffer on input,
225 |    and provides information on the unused input on return.  For Z_DATA_ERROR
226 |    returns, strm will also provide an error message.
227 | 
228 |    in() and out() are the call-back input and output functions.  When
229 |    inflateBack() needs more input, it calls in().  When inflateBack() has
230 |    filled the window with output, or when it completes with data in the
231 |    window, it calls out() to write out the data.  The application must not
232 |    change the provided input until in() is called again or inflateBack()
233 |    returns.  The application must not change the window/output buffer until
234 |    inflateBack() returns.
235 | 
236 |    in() and out() are called with a descriptor parameter provided in the
237 |    inflateBack() call.  This parameter can be a structure that provides the
238 |    information required to do the read or write, as well as accumulated
239 |    information on the input and output such as totals and check values.
240 | 
241 |    in() should return zero on failure.  out() should return non-zero on
242 |    failure.  If either in() or out() fails, than inflateBack() returns a
243 |    Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
244 |    was in() or out() that caused in the error.  Otherwise,  inflateBack()
245 |    returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
246 |    error, or Z_MEM_ERROR if it could not allocate memory for the state.
247 |    inflateBack() can also return Z_STREAM_ERROR if the input parameters
248 |    are not correct, i.e. strm is Z_NULL or the state was not initialized.
249 |  */
250 | int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
251 | z_streamp strm;
252 | in_func in;
253 | void FAR *in_desc;
254 | out_func out;
255 | void FAR *out_desc;
256 | {
257 |     struct inflate_state FAR *state;
258 |     z_const unsigned char FAR *next;    /* next input */
259 |     unsigned char FAR *put;     /* next output */
260 |     unsigned have, left;        /* available input and output */
261 |     unsigned long hold;         /* bit buffer */
262 |     unsigned bits;              /* bits in bit buffer */
263 |     unsigned copy;              /* number of stored or match bytes to copy */
264 |     unsigned char FAR *from;    /* where to copy match bytes from */
265 |     code here;                  /* current decoding table entry */
266 |     code last;                  /* parent table entry */
267 |     unsigned len;               /* length to copy for repeats, bits to drop */
268 |     int ret;                    /* return code */
269 |     static const unsigned short order[19] = /* permutation of code lengths */
270 |         {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
271 | 
272 |     /* Check that the strm exists and that the state was initialized */
273 |     if (strm == Z_NULL || strm->state == Z_NULL)
274 |         return Z_STREAM_ERROR;
275 |     state = (struct inflate_state FAR *)strm->state;
276 | 
277 |     /* Reset the state */
278 |     strm->msg = Z_NULL;
279 |     state->mode = TYPE;
280 |     state->last = 0;
281 |     state->whave = 0;
282 |     next = strm->next_in;
283 |     have = next != Z_NULL ? strm->avail_in : 0;
284 |     hold = 0;
285 |     bits = 0;
286 |     put = state->window;
287 |     left = state->wsize;
288 | 
289 |     /* Inflate until end of block marked as last */
290 |     for (;;)
291 |         switch (state->mode) {
292 |         case TYPE:
293 |             /* determine and dispatch block type */
294 |             if (state->last) {
295 |                 BYTEBITS();
296 |                 state->mode = DONE;
297 |                 break;
298 |             }
299 |             NEEDBITS(3);
300 |             state->last = BITS(1);
301 |             DROPBITS(1);
302 |             switch (BITS(2)) {
303 |             case 0:                             /* stored block */
304 |                 Tracev((stderr, "inflate:     stored block%s\n",
305 |                         state->last ? " (last)" : ""));
306 |                 state->mode = STORED;
307 |                 break;
308 |             case 1:                             /* fixed block */
309 |                 fixedtables(state);
310 |                 Tracev((stderr, "inflate:     fixed codes block%s\n",
311 |                         state->last ? " (last)" : ""));
312 |                 state->mode = LEN;              /* decode codes */
313 |                 break;
314 |             case 2:                             /* dynamic block */
315 |                 Tracev((stderr, "inflate:     dynamic codes block%s\n",
316 |                         state->last ? " (last)" : ""));
317 |                 state->mode = TABLE;
318 |                 break;
319 |             case 3:
320 |                 strm->msg = (char *)"invalid block type";
321 |                 state->mode = BAD;
322 |             }
323 |             DROPBITS(2);
324 |             break;
325 | 
326 |         case STORED:
327 |             /* get and verify stored block length */
328 |             BYTEBITS();                         /* go to byte boundary */
329 |             NEEDBITS(32);
330 |             if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
331 |                 strm->msg = (char *)"invalid stored block lengths";
332 |                 state->mode = BAD;
333 |                 break;
334 |             }
335 |             state->length = (unsigned)hold & 0xffff;
336 |             Tracev((stderr, "inflate:       stored length %u\n",
337 |                     state->length));
338 |             INITBITS();
339 | 
340 |             /* copy stored block from input to output */
341 |             while (state->length != 0) {
342 |                 copy = state->length;
343 |                 PULL();
344 |                 ROOM();
345 |                 if (copy > have) copy = have;
346 |                 if (copy > left) copy = left;
347 |                 zmemcpy(put, next, copy);
348 |                 have -= copy;
349 |                 next += copy;
350 |                 left -= copy;
351 |                 put += copy;
352 |                 state->length -= copy;
353 |             }
354 |             Tracev((stderr, "inflate:       stored end\n"));
355 |             state->mode = TYPE;
356 |             break;
357 | 
358 |         case TABLE:
359 |             /* get dynamic table entries descriptor */
360 |             NEEDBITS(14);
361 |             state->nlen = BITS(5) + 257;
362 |             DROPBITS(5);
363 |             state->ndist = BITS(5) + 1;
364 |             DROPBITS(5);
365 |             state->ncode = BITS(4) + 4;
366 |             DROPBITS(4);
367 | #ifndef PKZIP_BUG_WORKAROUND
368 |             if (state->nlen > 286 || state->ndist > 30) {
369 |                 strm->msg = (char *)"too many length or distance symbols";
370 |                 state->mode = BAD;
371 |                 break;
372 |             }
373 | #endif
374 |             Tracev((stderr, "inflate:       table sizes ok\n"));
375 | 
376 |             /* get code length code lengths (not a typo) */
377 |             state->have = 0;
378 |             while (state->have < state->ncode) {
379 |                 NEEDBITS(3);
380 |                 state->lens[order[state->have++]] = (unsigned short)BITS(3);
381 |                 DROPBITS(3);
382 |             }
383 |             while (state->have < 19)
384 |                 state->lens[order[state->have++]] = 0;
385 |             state->next = state->codes;
386 |             state->lencode = (code const FAR *)(state->next);
387 |             state->lenbits = 7;
388 |             ret = inflate_table(CODES, state->lens, 19, &(state->next),
389 |                                 &(state->lenbits), state->work);
390 |             if (ret) {
391 |                 strm->msg = (char *)"invalid code lengths set";
392 |                 state->mode = BAD;
393 |                 break;
394 |             }
395 |             Tracev((stderr, "inflate:       code lengths ok\n"));
396 | 
397 |             /* get length and distance code code lengths */
398 |             state->have = 0;
399 |             while (state->have < state->nlen + state->ndist) {
400 |                 for (;;) {
401 |                     here = state->lencode[BITS(state->lenbits)];
402 |                     if ((unsigned)(here.bits) <= bits) break;
403 |                     PULLBYTE();
404 |                 }
405 |                 if (here.val < 16) {
406 |                     DROPBITS(here.bits);
407 |                     state->lens[state->have++] = here.val;
408 |                 }
409 |                 else {
410 |                     if (here.val == 16) {
411 |                         NEEDBITS(here.bits + 2);
412 |                         DROPBITS(here.bits);
413 |                         if (state->have == 0) {
414 |                             strm->msg = (char *)"invalid bit length repeat";
415 |                             state->mode = BAD;
416 |                             break;
417 |                         }
418 |                         len = (unsigned)(state->lens[state->have - 1]);
419 |                         copy = 3 + BITS(2);
420 |                         DROPBITS(2);
421 |                     }
422 |                     else if (here.val == 17) {
423 |                         NEEDBITS(here.bits + 3);
424 |                         DROPBITS(here.bits);
425 |                         len = 0;
426 |                         copy = 3 + BITS(3);
427 |                         DROPBITS(3);
428 |                     }
429 |                     else {
430 |                         NEEDBITS(here.bits + 7);
431 |                         DROPBITS(here.bits);
432 |                         len = 0;
433 |                         copy = 11 + BITS(7);
434 |                         DROPBITS(7);
435 |                     }
436 |                     if (state->have + copy > state->nlen + state->ndist) {
437 |                         strm->msg = (char *)"invalid bit length repeat";
438 |                         state->mode = BAD;
439 |                         break;
440 |                     }
441 |                     while (copy--)
442 |                         state->lens[state->have++] = (unsigned short)len;
443 |                 }
444 |             }
445 | 
446 |             /* handle error breaks in while */
447 |             if (state->mode == BAD) break;
448 | 
449 |             /* check for end-of-block code (better have one) */
450 |             if (state->lens[256] == 0) {
451 |                 strm->msg = (char *)"invalid code -- missing end-of-block";
452 |                 state->mode = BAD;
453 |                 break;
454 |             }
455 | 
456 |             /* build code tables -- note: do not change the lenbits or distbits
457 |                values here (9 and 6) without reading the comments in inftrees.h
458 |                concerning the ENOUGH constants, which depend on those values */
459 |             state->next = state->codes;
460 |             state->lencode = (code const FAR *)(state->next);
461 |             state->lenbits = 9;
462 |             ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
463 |                                 &(state->lenbits), state->work);
464 |             if (ret) {
465 |                 strm->msg = (char *)"invalid literal/lengths set";
466 |                 state->mode = BAD;
467 |                 break;
468 |             }
469 |             state->distcode = (code const FAR *)(state->next);
470 |             state->distbits = 6;
471 |             ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
472 |                             &(state->next), &(state->distbits), state->work);
473 |             if (ret) {
474 |                 strm->msg = (char *)"invalid distances set";
475 |                 state->mode = BAD;
476 |                 break;
477 |             }
478 |             Tracev((stderr, "inflate:       codes ok\n"));
479 |             state->mode = LEN;
480 | 
481 |         case LEN:
482 |             /* use inflate_fast() if we have enough input and output */
483 |             if (have >= 6 && left >= 258) {
484 |                 RESTORE();
485 |                 if (state->whave < state->wsize)
486 |                     state->whave = state->wsize - left;
487 |                 inflate_fast(strm, state->wsize);
488 |                 LOAD();
489 |                 break;
490 |             }
491 | 
492 |             /* get a literal, length, or end-of-block code */
493 |             for (;;) {
494 |                 here = state->lencode[BITS(state->lenbits)];
495 |                 if ((unsigned)(here.bits) <= bits) break;
496 |                 PULLBYTE();
497 |             }
498 |             if (here.op && (here.op & 0xf0) == 0) {
499 |                 last = here;
500 |                 for (;;) {
501 |                     here = state->lencode[last.val +
502 |                             (BITS(last.bits + last.op) >> last.bits)];
503 |                     if ((unsigned)(last.bits + here.bits) <= bits) break;
504 |                     PULLBYTE();
505 |                 }
506 |                 DROPBITS(last.bits);
507 |             }
508 |             DROPBITS(here.bits);
509 |             state->length = (unsigned)here.val;
510 | 
511 |             /* process literal */
512 |             if (here.op == 0) {
513 |                 Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
514 |                         "inflate:         literal '%c'\n" :
515 |                         "inflate:         literal 0x%02x\n", here.val));
516 |                 ROOM();
517 |                 *put++ = (unsigned char)(state->length);
518 |                 left--;
519 |                 state->mode = LEN;
520 |                 break;
521 |             }
522 | 
523 |             /* process end of block */
524 |             if (here.op & 32) {
525 |                 Tracevv((stderr, "inflate:         end of block\n"));
526 |                 state->mode = TYPE;
527 |                 break;
528 |             }
529 | 
530 |             /* invalid code */
531 |             if (here.op & 64) {
532 |                 strm->msg = (char *)"invalid literal/length code";
533 |                 state->mode = BAD;
534 |                 break;
535 |             }
536 | 
537 |             /* length code -- get extra bits, if any */
538 |             state->extra = (unsigned)(here.op) & 15;
539 |             if (state->extra != 0) {
540 |                 NEEDBITS(state->extra);
541 |                 state->length += BITS(state->extra);
542 |                 DROPBITS(state->extra);
543 |             }
544 |             Tracevv((stderr, "inflate:         length %u\n", state->length));
545 | 
546 |             /* get distance code */
547 |             for (;;) {
548 |                 here = state->distcode[BITS(state->distbits)];
549 |                 if ((unsigned)(here.bits) <= bits) break;
550 |                 PULLBYTE();
551 |             }
552 |             if ((here.op & 0xf0) == 0) {
553 |                 last = here;
554 |                 for (;;) {
555 |                     here = state->distcode[last.val +
556 |                             (BITS(last.bits + last.op) >> last.bits)];
557 |                     if ((unsigned)(last.bits + here.bits) <= bits) break;
558 |                     PULLBYTE();
559 |                 }
560 |                 DROPBITS(last.bits);
561 |             }
562 |             DROPBITS(here.bits);
563 |             if (here.op & 64) {
564 |                 strm->msg = (char *)"invalid distance code";
565 |                 state->mode = BAD;
566 |                 break;
567 |             }
568 |             state->offset = (unsigned)here.val;
569 | 
570 |             /* get distance extra bits, if any */
571 |             state->extra = (unsigned)(here.op) & 15;
572 |             if (state->extra != 0) {
573 |                 NEEDBITS(state->extra);
574 |                 state->offset += BITS(state->extra);
575 |                 DROPBITS(state->extra);
576 |             }
577 |             if (state->offset > state->wsize - (state->whave < state->wsize ?
578 |                                                 left : 0)) {
579 |                 strm->msg = (char *)"invalid distance too far back";
580 |                 state->mode = BAD;
581 |                 break;
582 |             }
583 |             Tracevv((stderr, "inflate:         distance %u\n", state->offset));
584 | 
585 |             /* copy match from window to output */
586 |             do {
587 |                 ROOM();
588 |                 copy = state->wsize - state->offset;
589 |                 if (copy < left) {
590 |                     from = put + copy;
591 |                     copy = left - copy;
592 |                 }
593 |                 else {
594 |                     from = put - state->offset;
595 |                     copy = left;
596 |                 }
597 |                 if (copy > state->length) copy = state->length;
598 |                 state->length -= copy;
599 |                 left -= copy;
600 |                 do {
601 |                     *put++ = *from++;
602 |                 } while (--copy);
603 |             } while (state->length != 0);
604 |             break;
605 | 
606 |         case DONE:
607 |             /* inflate stream terminated properly -- write leftover output */
608 |             ret = Z_STREAM_END;
609 |             if (left < state->wsize) {
610 |                 if (out(out_desc, state->window, state->wsize - left))
611 |                     ret = Z_BUF_ERROR;
612 |             }
613 |             goto inf_leave;
614 | 
615 |         case BAD:
616 |             ret = Z_DATA_ERROR;
617 |             goto inf_leave;
618 | 
619 |         default:                /* can't happen, but makes compilers happy */
620 |             ret = Z_STREAM_ERROR;
621 |             goto inf_leave;
622 |         }
623 | 
624 |     /* Return unused input */
625 |   inf_leave:
626 |     strm->next_in = next;
627 |     strm->avail_in = have;
628 |     return ret;
629 | }
630 | 
631 | int ZEXPORT inflateBackEnd(strm)
632 | z_streamp strm;
633 | {
634 |     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
635 |         return Z_STREAM_ERROR;
636 |     ZFREE(strm, strm->state);
637 |     strm->state = Z_NULL;
638 |     Tracev((stderr, "inflate: end\n"));
639 |     return Z_OK;
640 | }
641 | 


--------------------------------------------------------------------------------
/zlib/crc32.h:
--------------------------------------------------------------------------------
  1 | /* crc32.h -- tables for rapid CRC calculation
  2 |  * Generated automatically by crc32.c
  3 |  */
  4 | 
  5 | local const z_crc_t FAR crc_table[TBLS][256] =
  6 | {
  7 |   {
  8 |     0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
  9 |     0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
 10 |     0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
 11 |     0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
 12 |     0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
 13 |     0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
 14 |     0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
 15 |     0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
 16 |     0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
 17 |     0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
 18 |     0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
 19 |     0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
 20 |     0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
 21 |     0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
 22 |     0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
 23 |     0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
 24 |     0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
 25 |     0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
 26 |     0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
 27 |     0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
 28 |     0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
 29 |     0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
 30 |     0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
 31 |     0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
 32 |     0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
 33 |     0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
 34 |     0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
 35 |     0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
 36 |     0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
 37 |     0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
 38 |     0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
 39 |     0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
 40 |     0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
 41 |     0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
 42 |     0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
 43 |     0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
 44 |     0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
 45 |     0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
 46 |     0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
 47 |     0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
 48 |     0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
 49 |     0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
 50 |     0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
 51 |     0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
 52 |     0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
 53 |     0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
 54 |     0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
 55 |     0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
 56 |     0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
 57 |     0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
 58 |     0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
 59 |     0x2d02ef8dUL
 60 | #ifdef BYFOUR
 61 |   },
 62 |   {
 63 |     0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
 64 |     0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
 65 |     0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
 66 |     0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
 67 |     0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
 68 |     0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
 69 |     0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
 70 |     0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
 71 |     0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
 72 |     0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
 73 |     0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
 74 |     0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
 75 |     0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
 76 |     0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
 77 |     0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
 78 |     0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
 79 |     0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
 80 |     0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
 81 |     0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
 82 |     0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
 83 |     0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
 84 |     0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
 85 |     0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
 86 |     0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
 87 |     0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
 88 |     0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
 89 |     0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
 90 |     0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
 91 |     0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
 92 |     0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
 93 |     0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
 94 |     0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
 95 |     0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
 96 |     0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
 97 |     0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
 98 |     0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
 99 |     0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
100 |     0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
101 |     0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
102 |     0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
103 |     0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
104 |     0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
105 |     0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
106 |     0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
107 |     0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
108 |     0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
109 |     0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
110 |     0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
111 |     0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
112 |     0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
113 |     0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
114 |     0x9324fd72UL
115 |   },
116 |   {
117 |     0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
118 |     0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
119 |     0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
120 |     0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
121 |     0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
122 |     0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
123 |     0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
124 |     0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
125 |     0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
126 |     0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
127 |     0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
128 |     0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
129 |     0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
130 |     0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
131 |     0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
132 |     0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
133 |     0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
134 |     0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
135 |     0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
136 |     0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
137 |     0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
138 |     0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
139 |     0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
140 |     0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
141 |     0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
142 |     0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
143 |     0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
144 |     0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
145 |     0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
146 |     0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
147 |     0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
148 |     0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
149 |     0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
150 |     0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
151 |     0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
152 |     0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
153 |     0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
154 |     0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
155 |     0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
156 |     0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
157 |     0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
158 |     0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
159 |     0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
160 |     0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
161 |     0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
162 |     0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
163 |     0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
164 |     0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
165 |     0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
166 |     0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
167 |     0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
168 |     0xbe9834edUL
169 |   },
170 |   {
171 |     0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
172 |     0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
173 |     0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
174 |     0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
175 |     0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
176 |     0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
177 |     0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
178 |     0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
179 |     0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
180 |     0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
181 |     0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
182 |     0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
183 |     0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
184 |     0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
185 |     0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
186 |     0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
187 |     0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
188 |     0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
189 |     0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
190 |     0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
191 |     0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
192 |     0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
193 |     0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
194 |     0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
195 |     0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
196 |     0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
197 |     0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
198 |     0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
199 |     0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
200 |     0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
201 |     0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
202 |     0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
203 |     0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
204 |     0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
205 |     0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
206 |     0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
207 |     0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
208 |     0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
209 |     0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
210 |     0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
211 |     0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
212 |     0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
213 |     0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
214 |     0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
215 |     0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
216 |     0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
217 |     0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
218 |     0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
219 |     0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
220 |     0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
221 |     0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
222 |     0xde0506f1UL
223 |   },
224 |   {
225 |     0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
226 |     0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
227 |     0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
228 |     0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
229 |     0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
230 |     0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
231 |     0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
232 |     0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
233 |     0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
234 |     0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
235 |     0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
236 |     0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
237 |     0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
238 |     0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
239 |     0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
240 |     0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
241 |     0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
242 |     0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
243 |     0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
244 |     0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
245 |     0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
246 |     0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
247 |     0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
248 |     0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
249 |     0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
250 |     0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
251 |     0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
252 |     0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
253 |     0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
254 |     0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
255 |     0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
256 |     0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
257 |     0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
258 |     0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
259 |     0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
260 |     0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
261 |     0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
262 |     0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
263 |     0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
264 |     0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
265 |     0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
266 |     0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
267 |     0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
268 |     0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
269 |     0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
270 |     0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
271 |     0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
272 |     0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
273 |     0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
274 |     0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
275 |     0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
276 |     0x8def022dUL
277 |   },
278 |   {
279 |     0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
280 |     0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
281 |     0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
282 |     0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
283 |     0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
284 |     0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
285 |     0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
286 |     0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
287 |     0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
288 |     0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
289 |     0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
290 |     0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
291 |     0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
292 |     0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
293 |     0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
294 |     0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
295 |     0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
296 |     0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
297 |     0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
298 |     0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
299 |     0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
300 |     0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
301 |     0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
302 |     0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
303 |     0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
304 |     0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
305 |     0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
306 |     0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
307 |     0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
308 |     0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
309 |     0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
310 |     0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
311 |     0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
312 |     0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
313 |     0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
314 |     0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
315 |     0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
316 |     0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
317 |     0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
318 |     0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
319 |     0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
320 |     0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
321 |     0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
322 |     0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
323 |     0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
324 |     0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
325 |     0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
326 |     0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
327 |     0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
328 |     0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
329 |     0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
330 |     0x72fd2493UL
331 |   },
332 |   {
333 |     0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
334 |     0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
335 |     0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
336 |     0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
337 |     0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
338 |     0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
339 |     0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
340 |     0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
341 |     0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
342 |     0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
343 |     0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
344 |     0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
345 |     0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
346 |     0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
347 |     0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
348 |     0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
349 |     0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
350 |     0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
351 |     0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
352 |     0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
353 |     0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
354 |     0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
355 |     0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
356 |     0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
357 |     0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
358 |     0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
359 |     0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
360 |     0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
361 |     0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
362 |     0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
363 |     0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
364 |     0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
365 |     0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
366 |     0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
367 |     0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
368 |     0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
369 |     0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
370 |     0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
371 |     0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
372 |     0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
373 |     0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
374 |     0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
375 |     0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
376 |     0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
377 |     0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
378 |     0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
379 |     0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
380 |     0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
381 |     0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
382 |     0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
383 |     0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
384 |     0xed3498beUL
385 |   },
386 |   {
387 |     0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
388 |     0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
389 |     0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
390 |     0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
391 |     0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
392 |     0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
393 |     0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
394 |     0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
395 |     0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
396 |     0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
397 |     0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
398 |     0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
399 |     0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
400 |     0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
401 |     0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
402 |     0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
403 |     0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
404 |     0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
405 |     0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
406 |     0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
407 |     0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
408 |     0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
409 |     0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
410 |     0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
411 |     0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
412 |     0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
413 |     0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
414 |     0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
415 |     0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
416 |     0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
417 |     0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
418 |     0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
419 |     0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
420 |     0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
421 |     0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
422 |     0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
423 |     0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
424 |     0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
425 |     0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
426 |     0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
427 |     0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
428 |     0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
429 |     0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
430 |     0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
431 |     0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
432 |     0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
433 |     0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
434 |     0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
435 |     0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
436 |     0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
437 |     0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
438 |     0xf10605deUL
439 | #endif
440 |   }
441 | };
442 | 


--------------------------------------------------------------------------------