Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/miniz_8c_source.html below:

NCBI C++ ToolKit: src/util/compress/api/miniz/miniz.c Source File

block_len = buf_len % 5552;

(

= 0;

+ 7 < block_len;

+= 8, ptr += 8)

s1 += ptr[0], s2 += s1;

s1 += ptr[1], s2 += s1;

s1 += ptr[2], s2 += s1;

s1 += ptr[3], s2 += s1;

s1 += ptr[4], s2 += s1;

s1 += ptr[5], s2 += s1;

s1 += ptr[6], s2 += s1;

s1 += ptr[7], s2 += s1;

(;

< block_len; ++

)

s1 += *ptr++, s2 += s1;

s1 %= 65521U, s2 %= 65521U;

(s2 << 16) + s1;

s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,

0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };

crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (

& 0xF)];

crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (

>> 4)];

0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,

0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,

0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,

0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,

0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,

0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,

0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,

0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,

0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,

0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,

0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,

0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,

0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,

0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,

0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,

0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,

0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,

0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,

0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,

0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,

0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,

0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,

0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,

0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,

0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,

0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,

0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,

0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,

0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,

0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,

0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,

0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,

0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,

0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,

0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,

0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,

0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D

(void)opaque, (

)items, (void)

;

(void)opaque, (

)address;

(void)opaque, (

)address, (void)items, (

)

;

(!pStream->

)

pStream->

= (

mz_internal_state *)pComp;

((!pStream) || (!pStream->

) || (!pStream->

) || (!pStream->

))

in_bytes, out_bytes;

orig_total_in, orig_total_out;

mz_status =

;

orig_total_in = pStream->

;

((flush) || (pStream->

!= orig_total_in) || (pStream->

!= orig_total_out))

(pStream->

)

(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);

memset(&stream, 0,

(stream));

((source_len | *pDest_len) > 0xFFFFFFFFU)

(status !=

)

m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed;

(!pStream->

)

pStream->

= (

mz_internal_state *)pDecomp;

pDecomp->m_dict_ofs = 0;

pDecomp->m_dict_avail = 0;

pDecomp->m_first_call = 1;

pDecomp->m_has_flushed = 0;

pDecomp->m_window_bits = window_bits;

pDecomp->m_dict_ofs = 0;

pDecomp->m_dict_avail = 0;

pDecomp->m_first_call = 1;

pDecomp->m_has_flushed = 0;

in_bytes, out_bytes, orig_avail_in;

((!pStream) || (!pStream->

))

(pState->m_window_bits > 0)

orig_avail_in = pStream->

;

first_call = pState->m_first_call;

pState->m_first_call = 0;

(pState->m_last_status < 0)

(pState->m_has_flushed && (flush !=

))

pState->m_has_flushed |= (flush ==

);

((flush ==

) && (first_call))

pState->m_last_status = status;

(pState->m_dict_avail)

memcpy(pStream->

, pState->m_dict + pState->m_dict_ofs,

);

pState->m_dict_avail -=

;

status =

(&pState->m_decomp, pStream->

, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);

pState->m_last_status = status;

pState->m_dict_avail = (

)out_bytes;

memcpy(pStream->

, pState->m_dict + pState->m_dict_ofs,

);

pState->m_dict_avail -=

;

(pStream->

)

memset(&stream, 0,

(stream));

((*pSource_len | *pDest_len) > 0xFFFFFFFFU)

(status !=

)

*pSource_len = *pSource_len - stream.

;

{

,

}, {

,

}, {

,

}, {

,

}, {

,

}, {

,

}, {

,

}, {

,

}, {

,

}, {

,

}

(

= 0;

<

(s_error_descs) /

(s_error_descs[0]); ++

)

(s_error_descs[

].m_err == err)

s_error_descs[

].m_pDesc;

257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,

273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,

277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,

279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,

281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,

282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,

283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,

284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285

0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0

0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,

11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13,

13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,

16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,

17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,

17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,

17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17

0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,

5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

7, 7, 7, 7, 7, 7, 7, 7

0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,

26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,

28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29

0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13

total_passes = 2, pass_shift, pass,

, hist[256 * 2];

(

= 0;

< num_syms;

++)

hist[256 + ((freq >> 8) & 0xFF)]++;

((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256]))

(pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)

*pHist = &hist[pass << 8];

(

= 0;

< 256;

++)

cur_ofs += pHist[

];

(

= 0;

< num_syms;

++)

pNew_syms[

[(pCur_syms[

].m_key >> pass_shift) & 0xFF]++] = pCur_syms[

];

pCur_syms = pNew_syms;

root,

,

, avbl, used, dpth;

[0].m_key +=

[1].m_key;

(

>=

||

[root].m_key <

[

].m_key)

[

].m_key =

[root].m_key;

[

- 2].m_key = 0;

[

].m_key =

[

[

].m_key].m_key + 1;

(root >= 0 && (

)

[root].m_key == dpth)

(code_list_len <= 1)

pNum_codes[max_code_size] += pNum_codes[

];

(

= max_code_size;

> 0;

--)

total += (((

)pNum_codes[

]) << (max_code_size -

));

(total != (1UL << max_code_size))

pNum_codes[max_code_size]--;

(

= max_code_size - 1;

> 0;

--)

pNum_codes[

+ 1] += 2;

(

= 0;

< table_len;

++)

num_used_syms = 0;

(

= 0;

< table_len;

++)

(

= 0;

< num_used_syms;

++)

num_codes[pSyms[

].m_key]++;

(

= 1, j = num_used_syms;

<= code_size_limit;

++)

(

= num_codes[

];

> 0;

--)

(j = 0,

= 2;

<= code_size_limit;

++)

next_code[

] = j = ((j + num_codes[

- 1]) << 1);

(

= 0;

< table_len;

++)

= next_code[code_size]++;

(

= code_size;

> 0;

--,

>>= 1)

rev_code = (rev_code << 1) | (

& 1);

[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };

num_lit_codes, num_dist_codes, num_bit_lengths;

, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;

(num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--)

(num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--)

memcpy(code_sizes_to_pack + num_lit_codes, &d->

[1][0], num_dist_codes);

total_code_sizes_to_pack = num_lit_codes + num_dist_codes;

num_packed_code_sizes = 0;

rle_repeat_count = 0;

(

= 0;

< total_code_sizes_to_pack;

++)

code_size = code_sizes_to_pack[

];

(++rle_z_count == 138)

(code_size != prev_code_size)

packed_code_sizes[num_packed_code_sizes++] = code_size;

(++rle_repeat_count == 6)

prev_code_size = code_size;

(rle_repeat_count)

(num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--)

num_bit_lengths =

(4, (num_bit_lengths + 1));

(

= 0; (

)

< num_bit_lengths;

++)

(packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;)

= packed_code_sizes[packed_code_sizes_index++];

(packed_code_sizes[packed_code_sizes_index++],

[

- 16]);

(

= 0;

<= 143; ++

)

(;

<= 255; ++

)

(;

<= 279; ++

)

(;

<= 287; ++

)

[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };

(pLZ_codes = d->

; pLZ_codes < pLZ_code_buf_end; flags >>= 1)

= *pLZ_codes++ | 0x100;

s0, s1, n0, n1, sym, num_extra_bits;

match_len = pLZ_codes[0], match_dist = *(

*)(pLZ_codes + 1);

sym = (match_dist < 512) ? s0 : s1;

num_extra_bits = (match_dist < 512) ? n0 : n1;

TDEFL_PUT_BITS_FAST(match_dist &

[num_extra_bits], num_extra_bits);

(((

& 2) == 0) && (pLZ_codes < pLZ_code_buf_end))

(((

& 2) == 0) && (pLZ_codes < pLZ_code_buf_end))

*(

*)pOutput_buf = bit_buffer;

pOutput_buf += (bits_in >> 3);

bit_buffer >>= (bits_in & ~7);

= *pLZ_codes++ | 0x100;

match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));

(match_dist < 512)

saved_bit_buf, saved_bits_in;

(!comp_block_succeeded)

(

= 0;

< 4;

++)

(

= 2;

; --

, z ^= 0xFFFF)

((

-= bytes_to_copy) != 0)

c01 = TDEFL_READ_UNALIGNED_WORD(&d->

[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD2(s);

(max_match_len <= match_len)

(--num_probes_left == 0)

(TDEFL_READ_UNALIGNED_WORD2(q) != s01)

}

((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&

(TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));

*pMatch_dist = dist;

*pMatch_dist = dist;

((*pMatch_len = match_len =

(max_match_len, probe_len)) == max_match_len)

c01 = TDEFL_READ_UNALIGNED_WORD(&d->

[pos + match_len - 1]);

(max_match_len <= match_len)

(--num_probes_left == 0)

q = d->

+ probe_pos;

(probe_len = 0; probe_len < max_match_len; probe_len++)

(probe_len > match_len)

*pMatch_dist = dist;

((*pMatch_len = match_len = probe_len) == max_match_len)

c0 = d->

[pos + match_len];

c1 = d->

[pos + match_len - 1];

TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;

lookahead_size += num_bytes_to_process;

(num_bytes_to_process)

num_bytes_to_process -=

;

((!d->

) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE))

(lookahead_size >= 4)

cur_match_dist, cur_match_len = 1;

first_trigram = TDEFL_READ_UNALIGNED_WORD32(pCur_dict) & 0xFFFFFF;

(((cur_match_dist = (

)(lookahead_pos - probe_pos)) <= dict_size) && ((TDEFL_READ_UNALIGNED_WORD32(d->

+ (probe_pos &=

)) & 0xFFFFFF) == first_trigram))

}

((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&

(TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));

*pLZ_code_buf++ = (

)first_trigram;

*pLZ_flags = (

)(*pLZ_flags >> 1);

cur_match_len =

(cur_match_len, lookahead_size);

memcpy(&pLZ_code_buf[1], &cur_match_dist,

(cur_match_dist));

*pLZ_flags = (

)((*pLZ_flags >> 1) | 0x80);

d->

[1][(cur_match_dist < 512) ? s0 : s1]++;

*pLZ_code_buf++ = (

)first_trigram;

*pLZ_flags = (

)(*pLZ_flags >> 1);

(--num_flags_left == 0)

pLZ_flags = pLZ_code_buf++;

total_lz_bytes += cur_match_len;

lookahead_pos += cur_match_len;

(lookahead_size >= cur_match_len);

lookahead_size -= cur_match_len;

(lookahead_size)

*pLZ_code_buf++ = lit;

*pLZ_flags = (

)(*pLZ_flags >> 1);

(--num_flags_left == 0)

pLZ_flags = pLZ_code_buf++;

len_to_move, cur_match_dist, cur_match_len, cur_pos;

*pSrc_end = pSrc + num_bytes_to_process;

src_buf_left -= num_bytes_to_process;

(pSrc != pSrc_end)

d->

[dst_pos] = c;

d->

[dst_pos] = c;

(cur_match_len < d->m_lookahead_size)

(d->

[cur_pos + cur_match_len] != c)

cur_match_dist = cur_match_len = 0;

(cur_match_len >= 128)

len_to_move = cur_match_len;

(!cur_match_dist)

len_to_move = cur_match_len;

(d->

&& (flush !=

)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))

(!tdefl_compress_fast(d))

(((buf_len) && (!pBuf)) || (!pPut_buf_func))

new_capacity =

(128U, new_capacity << 1U);

}

(new_size > new_capacity);

*pOut_len = out_buf.

;

[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };

(window_bits > 0)

s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };

, bpl = w * num_chans, y, z;

(z = 41; z; --z)

(y = 0; y < h; ++y)

*pLen_out = out_buf.

- 41;

chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };

pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,

0x0a, 0x1a, 0x0a, 0x00, 0x00,

0x00, 0x0d, 0x49, 0x48, 0x44,

0x52, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x08,

0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x49, 0x44, 0x41,

pnghdr[25] = chans[num_chans];

pnghdr[33] = (

)(*pLen_out >> 24);

pnghdr[34] = (

)(*pLen_out >> 16);

pnghdr[35] = (

)(*pLen_out >> 8);

pnghdr[36] = (

)*pLen_out;

(

= 0;

< 4; ++

, c <<= 8)

memcpy(out_buf.

, pnghdr, 41);

(

= 0;

< 4; ++

, c <<= 8)

s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };

s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 };

s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 };

s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };

s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };

s_min_table_sizes[3] = { 257, 1, 4 };

num_bits, dist, counter, num_extra;

*pIn_buf_cur = pIn_buf_next, *

pIn_buf_end = pIn_buf_next + *pIn_buf_size;

*pOut_buf_cur = pOut_buf_next, *

pOut_buf_end = pOut_buf_next + *pOut_buf_size;

(((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))

*pIn_buf_size = *pOut_buf_size = 0;

num_bits =

->m_num_bits;

bit_buf =

->m_bit_buf;

counter =

->m_counter;

num_extra =

->m_num_extra;

dist_from_out_buf_start =

->m_dist_from_out_buf_start;

bit_buf = num_bits = dist = counter = num_extra =

->m_zhdr0 =

->m_zhdr1 = 0;

->m_z_adler32 =

->m_check_adler32 = 1;

counter = (((

->m_zhdr0 * 256 +

->m_zhdr1) % 31 != 0) || (

->m_zhdr1 & 32) || ((

->m_zhdr0 & 15) != 8));

counter |= (((1U << (8U + (

->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (

->m_zhdr0 >> 4)))));

counter |= ((

> 32768U) || ((out_buf_size_mask + 1) < (size_t)(

)));

->m_type =

->m_final >> 1;

(

->m_type == 0)

(counter = 0; counter < 4; ++counter)

((counter = (

->m_raw_header[0] | (

->m_raw_header[1] << 8))) != (

)(0xFFFF ^ (

->m_raw_header[2] | (

->m_raw_header[3] << 8))))

((counter) && (num_bits))

(pOut_buf_cur >= pOut_buf_end)

*pOut_buf_cur++ = (

)dist;

(pOut_buf_cur >= pOut_buf_end)

(pIn_buf_cur >= pIn_buf_end)

=

(

((

)(pOut_buf_end - pOut_buf_cur), (

)(pIn_buf_end - pIn_buf_cur)), counter);

(

->m_type == 3)

(

->m_type == 1)

*p =

->m_tables[0].m_code_size;

->m_table_sizes[0] = 288;

->m_table_sizes[1] = 32;

(

= 0;

<= 143; ++

)

(;

<= 255; ++

)

(;

<= 279; ++

)

(;

<= 287; ++

)

(counter = 0; counter < 3; counter++)

(11,

->m_table_sizes[counter],

[counter]);

->m_table_sizes[counter] += s_min_table_sizes[counter];

(counter = 0; counter <

->m_table_sizes[2]; counter++)

->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (

)s;

->m_table_sizes[2] = 19;

(; (

)

->m_type >= 0;

->m_type--)

tree_next, tree_cur;

, j, used_syms, total, sym_index, next_code[17], total_syms[16];

pTable = &

->m_tables[

->m_type];

(

= 0;

<

->m_table_sizes[

->m_type]; ++

)

used_syms = 0, total = 0;

next_code[0] = next_code[1] = 0;

(

= 1;

<= 15; ++

)

used_syms += total_syms[

];

next_code[

+ 1] = (total = ((total + total_syms[

]) << 1));

((65536 != total) && (used_syms > 1))

(tree_next = -1, sym_index = 0; sym_index <

->m_table_sizes[

->m_type]; ++sym_index)

cur_code = next_code[code_size]++;

(

= code_size;

> 0;

--, cur_code >>= 1)

rev_code = (rev_code << 1) | (cur_code & 1);

rev_code += (1 << code_size);

tree_cur = tree_next;

tree_cur -= ((rev_code >>= 1) & 1);

(!pTable->

[-tree_cur - 1])

tree_cur = tree_next;

tree_cur = pTable->

[-tree_cur - 1];

tree_cur -= ((rev_code >>= 1) & 1);

(

->m_type == 2)

(counter = 0; counter < (

->m_table_sizes[0] +

->m_table_sizes[1]);)

->m_len_codes[counter++] = (

)dist;

((dist == 16) && (!counter))

num_extra =

[dist - 16];

s +=

[dist - 16];

(

->m_len_codes + counter, (dist == 16) ?

->m_len_codes[counter - 1] : 0, s);

((

->m_table_sizes[0] +

->m_table_sizes[1]) != counter)

(

->m_tables[0].m_code_size,

->m_len_codes,

->m_table_sizes[0]);

(

->m_tables[1].m_code_size,

->m_len_codes +

->m_table_sizes[0],

->m_table_sizes[1]);

(((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))

(pOut_buf_cur >= pOut_buf_end)

*pOut_buf_cur++ = (

)counter;

code_len = sym2 >> 9;

sym2 =

->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];

bit_buf >>= code_len;

num_bits -= code_len;

code_len = sym2 >> 9;

sym2 =

->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)];

bit_buf >>= code_len;

num_bits -= code_len;

pOut_buf_cur[0] = (

)counter;

pOut_buf_cur[1] = (

)sym2;

((counter &= 511) == 256)

num_extra = s_length_extra[counter - 257];

counter = s_length_base[counter - 257];

counter += extra_bits;

num_extra = s_dist_extra[dist];

dist = s_dist_base[dist];

dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;

pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);

((

(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)

(pOut_buf_cur >= pOut_buf_end)

*pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];

((counter >= 9) && (counter <= dist))

*pSrc_end = pSrc + (counter & ~7);

memcpy(pOut_buf_cur, pSrc,

(

)*2);

}

((pSrc += 8) < pSrc_end);

((counter &= 7) < 3)

pOut_buf_cur[0] = pSrc[0];

pOut_buf_cur[1] = pSrc[1];

pOut_buf_cur += counter;

pOut_buf_cur[0] = pSrc[0];

pOut_buf_cur[1] = pSrc[1];

pOut_buf_cur[2] = pSrc[2];

pOut_buf_cur[0] = pSrc[0];

pOut_buf_cur[1] = pSrc[1];

pOut_buf_cur += counter;

}

(!(

->m_final & 1));

((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))

(counter = 0; counter < 4; ++counter)

->m_z_adler32 = (

->m_z_adler32 << 8) | s;

((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))

->m_num_bits = num_bits;

->m_counter = counter;

->m_num_extra = num_extra;

->m_dist_from_out_buf_start = dist_from_out_buf_start;

*pIn_buf_size = pIn_buf_cur - pIn_buf_next;

*pOut_buf_size = pOut_buf_cur - pOut_buf_next;

*ptr = pOut_buf_next;

buf_len = *pOut_buf_size;

, s1 =

->m_check_adler32 & 0xffff, s2 =

->m_check_adler32 >> 16;

block_len = buf_len % 5552;

(

= 0;

+ 7 < block_len;

+= 8, ptr += 8)

s1 += ptr[0], s2 += s1;

s1 += ptr[1], s2 += s1;

s1 += ptr[2], s2 += s1;

s1 += ptr[3], s2 += s1;

s1 += ptr[4], s2 += s1;

s1 += ptr[5], s2 += s1;

s1 += ptr[6], s2 += s1;

s1 += ptr[7], s2 += s1;

(;

< block_len; ++

)

s1 += *ptr++, s2 += s1;

s1 %= 65521U, s2 %= 65521U;

buf_len -= block_len;

->m_check_adler32 = (s2 << 16) + s1;

*pBuf =

, *pNew_buf;

src_buf_ofs = 0, out_buf_capacity = 0;

src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;

src_buf_ofs += src_buf_size;

*pOut_len += dst_buf_size;

new_out_buf_capacity = out_buf_capacity * 2;

(new_out_buf_capacity < 128)

new_out_buf_capacity = 128;

pNew_buf =

(pBuf, new_out_buf_capacity);

out_buf_capacity = new_out_buf_capacity;

in_buf_ofs = 0, dict_ofs = 0;

in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size =

- dict_ofs;

in_buf_ofs += in_buf_size;

((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (

)dst_buf_size, pPut_buf_user)))

*pIn_buf_size = in_buf_ofs;

FILE *mz_fopen(

*pFilename,

*pMode)

FILE *pFile =

;

fopen_s(&pFile, pFilename, pMode);

FILE *mz_freopen(

*pPath,

*pMode, FILE *pStream)

FILE *pFile =

;

(freopen_s(&pFile, pPath, pMode, pStream))

)

new_capacity = min_new_capacity;

(new_capacity < min_new_capacity)

pArray->

= pNew_p;

pArray->

= new_size;

orig_size = pArray->

;

memset(&tm, 0,

(tm));

tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;

tm.tm_mon = ((dos_date >> 5) & 15) - 1;

tm.tm_mday = dos_date & 31;

tm.tm_hour = (dos_time >> 11) & 31;

tm.tm_min = (dos_time >> 5) & 63;

tm.tm_sec = (dos_time << 1) & 62;

tm tm_struct;

tm *tm = &tm_struct;

errno_t err = localtime_s(tm, &time);

tm *tm = localtime(&time);

*pDOS_time = (

)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));

*pDOS_date = (

)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);

*pTime = file_stat.st_mtime;

memset(&

, 0,

(

));

.actime = access_time;

.modtime = modified_time;

!utime(pFilename, &

);

pE = pL +

(l_len, r_len);

(pL == pE) ? (l_len < r_len) : (

<

);

start = (

- 2U) >> 1U;

((child = (root << 1U) + 1U) >=

)

((child = (root << 1U) + 1U) >= end)

child += (((child + 1U) < end) &&

(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));

(

=

- 4;

>= 0; --

)

(s == record_sig)

cur_file_ofs =

(cur_file_ofs - (

(buf_u32) - 3), 0);

*pOfs = cur_file_ofs;

cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;

*pZip64_locator = (

*)zip64_end_of_central_dir_locator_u32;

*pZip64_end_of_central_dir = (

*)zip64_end_of_central_dir_header_u32;

zip64_end_of_central_dir_ofs = 0;

(zip64_total_num_of_disks != 1U)

cdir_entries_on_this_disk = (

)zip64_cdir_total_entries_on_this_disk;

cdir_size = (

)zip64_size_of_central_directory;

(((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))

(sort_central_dir)

total_header_size, disk_index, bit_flags, filename_size, ext_data_size;

comp_size, decomp_size, local_header_ofs;

(sort_central_dir)

extra_size_remaining = ext_data_size;

(extra_size_remaining)

(extra_size_remaining < (

(

) * 2))

((field_data_size +

(

) * 2) > extra_size_remaining)

pExtra_data +=

(

) * 2 + field_data_size;

extra_size_remaining = extra_size_remaining -

(

) * 2 - field_data_size;

}

(extra_size_remaining);

((disk_index ==

) || ((disk_index != num_this_disk) && (disk_index != 1)))

-= total_header_size;

p += total_header_size;

(sort_central_dir)

((!pZip) || (!pZip->

))

pFile =

(pFilename,

);

file_size = archive_size;

((!pZip) || (!pFile))

archive_size =

(pFile) - cur_file_ofs;

filename_len, attribute_mapping_id, external_attr;

(void)attribute_mapping_id;

*p = pCentral_dir_header;

(pFound_zip64_extra_data)

*pFound_zip64_extra_data =

;

((!p) || (!pStat))

(extra_size_remaining)

(extra_size_remaining < (

(

) * 2))

((field_data_size +

(

) * 2) > extra_size_remaining)

field_data_remaining = field_data_size;

(pFound_zip64_extra_data)

*pFound_zip64_extra_data =

;

(field_data_remaining <

(

))

field_data_remaining -=

(

);

(field_data_remaining <

(

))

field_data_remaining -=

(

);

(field_data_remaining <

(

))

field_data_remaining -=

(

);

pExtra_data +=

(

) * 2 + field_data_size;

extra_size_remaining = extra_size_remaining -

(

) * 2 - field_data_size;

}

(extra_size_remaining);

0 == memcmp(pA, pB,

);

(

= 0;

<

; ++

)

pE = pL +

(l_len, r_len);

(pL == pE) ? (

)(l_len - r_len) : (

-

);

*pIndex = file_index;

(

)index;

name_len, comment_len;

((!pZip) || (!pZip->

) || (!pName))

name_len = strlen(pName);

comment_len = pComment ? strlen(pComment) : 0;

(file_index = 0; file_index < pZip->

; file_index++)

(filename_len < name_len)

*pFile_comment = pFilename + filename_len + file_extra_len;

((file_comment_len != comment_len) || (!

(pComment, pFile_comment, file_comment_len,

)))

ofs = filename_len - 1;

((pFilename[ofs] ==

) || (pFilename[ofs] ==

) || (pFilename[ofs] ==

))

}

(--ofs >= 0);

filename_len -= ofs;

*pIndex = file_index;

needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;

((!pZip) || (!pZip->

) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->

))

(buf_size < needed_size)

(pZip->

(pZip->

, cur_file_ofs, pBuf, (

)needed_size) != needed_size)

read_buf_size = read_buf_avail = file_stat.

;

(pUser_read_buf)

(!user_read_buf_size)

pRead_buf = (

*)pUser_read_buf;

read_buf_size = user_read_buf_size;

(((

(

) ==

(

))) && (read_buf_size > 0x7FFFFFFF))

in_buf_size, out_buf_size = (size_t)(file_stat.

- out_buf_ofs);

read_buf_avail =

(read_buf_size, comp_remaining);

(pZip->

(pZip->

, cur_file_ofs, pRead_buf, (

)read_buf_avail) != read_buf_avail)

cur_file_ofs += read_buf_avail;

comp_remaining -= read_buf_avail;

in_buf_size = (size_t)read_buf_avail;

read_buf_avail -= in_buf_size;

read_buf_ofs += in_buf_size;

out_buf_ofs += out_buf_size;

comp_size, uncomp_size, alloc_size;

(((

(

) ==

(

))) && (alloc_size > 0x7FFFFFFF))

*pSize = (size_t)alloc_size;

read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;

*pRead_buf =

;

*pWrite_buf =

;

((!pZip) || (!pZip->

) || (!pCallback) || (!pZip->

))

read_buf_size = read_buf_avail = file_stat.

;

(pCallback(pOpaque, out_buf_ofs, pRead_buf, (

)file_stat.

) != file_stat.

)

(comp_remaining)

read_buf_avail =

(read_buf_size, comp_remaining);

(pZip->

(pZip->

, cur_file_ofs, pRead_buf, (

)read_buf_avail) != read_buf_avail)

(pCallback(pOpaque, out_buf_ofs, pRead_buf, (

)read_buf_avail) != read_buf_avail)

cur_file_ofs += read_buf_avail;

out_buf_ofs += read_buf_avail;

comp_remaining -= read_buf_avail;

read_buf_avail =

(read_buf_size, comp_remaining);

(pZip->

(pZip->

, cur_file_ofs, pRead_buf, (

)read_buf_avail) != read_buf_avail)

cur_file_ofs += read_buf_avail;

comp_remaining -= read_buf_avail;

in_buf_size = (size_t)read_buf_avail;

read_buf_avail -= in_buf_size;

read_buf_ofs += in_buf_size;

(pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)

((out_buf_ofs += out_buf_size) > file_stat.

)

(file_crc32 != file_stat.

)

((!pZip) || (!pZip->

))

pState->

= pZip;

copied_to_caller = 0;

((!pState) || (!pState->

) || (!pState->

->

) || (!pvBuf))

memcpy( pvBuf, pState->

, copied_to_caller );

copied_to_caller = 0;

memcpy( (

*)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy );

copied_to_caller += to_copy;

copied_to_caller;

status = pState->

;

pFile =

(pDst_filename,

);

*pCentral_dir_header;

local_header_filename_len, local_header_extra_len, local_header_crc32;

local_header_comp_size, local_header_uncomp_size;

has_data_descriptor = (local_header_bit_flags & 8) != 0;

(local_header_filename_len != strlen(file_stat.

))

handle_failure;

(local_header_filename_len)

handle_failure;

(memcmp(file_stat.

, file_data_array.

, local_header_filename_len) != 0)

handle_failure;

((local_header_extra_len) && ((local_header_comp_size ==

) || (local_header_uncomp_size ==

)))

extra_size_remaining = local_header_extra_len;

handle_failure;

field_id, field_data_size, field_total_size;

(extra_size_remaining < (

(

) * 2))

handle_failure;

field_total_size = field_data_size +

(

) * 2;

(field_total_size > extra_size_remaining)

handle_failure;

(field_data_size <

(

) * 2)

handle_failure;

local_header_uncomp_size =

(pSrc_field_data);

found_zip64_ext_data_in_ldir =

;

pExtra_data += field_total_size;

extra_size_remaining -= field_total_size;

}

(extra_size_remaining);

((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))

comp_size = 0, uncomp_size = 0;

num_descriptor_uint32s = ((pState->

) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;

handle_failure;

pSrc = has_id ? (descriptor_buf +

(

)) : descriptor_buf;

((pState->

) || (found_zip64_ext_data_in_ldir))

handle_failure;

((local_header_crc32 != file_stat.

) || (local_header_comp_size != file_stat.

) || (local_header_uncomp_size != file_stat.

))

handle_failure;

(uncomp_crc32 != file_stat.

)

(found_index !=

)

((!pMem) || (!

))

((

(

) ==

(

)) && (new_size > 0x7FFFFFFF))

(new_capacity < new_size)

pState->

= pNew_block;

(0 != (initial_allocation_size =

(initial_allocation_size, size_to_reserve_at_beginning)))

(size_to_reserve_at_beginning)

= (size_t)

(

(

), size_to_reserve_at_beginning);

size_to_reserve_at_beginning -=

;

}

(size_to_reserve_at_beginning);

(pState->

)

(pLocal_header_ofs)

(

*pZip,

*pDst,

filename_size,

extra_size,

uncomp_size,

comp_size,

uncomp_crc32,

method,

bit_flags,

dos_time,

dos_date)

*pExtra,

extra_size,

*pComment,

comment_size,

*user_extra_data,

user_extra_data_len)

(local_header_ofs > 0xFFFFFFFF)

(!

(pZip, central_dir_header, filename_size, (

)(extra_size + user_extra_data_len), comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))

(*pArchive_name ==

)

(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32,

,

, 0,

, 0);

*user_extra_data,

user_extra_data_len,

*user_extra_data_central,

user_extra_data_central_len)

method = 0, dos_time = 0, dos_date = 0;

level, ext_attributes = 0, num_alignment_padding_bytes;

archive_name_size;

store_data_uncompressed;

((

)level_and_flags < 0)

level = level_and_flags & 0xF;

((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))

(last_modified !=

)

uncomp_size = buf_size;

(uncomp_size <= 3)

store_data_uncompressed =

;

archive_name_size = strlen(pArchive_name);

((archive_name_size) && (pArchive_name[archive_name_size - 1] ==

))

((buf_size) || (uncomp_size))

((!store_data_uncompressed) && (buf_size))

local_dir_header_ofs += num_alignment_padding_bytes;

cur_archive_file_ofs += num_alignment_padding_bytes;

pExtra_data = extra_data;

(!

(pZip, local_dir_header, (

)archive_name_size, (

)(extra_size + user_extra_data_len), 0, 0, 0, method, bit_flags, dos_time, dos_date))

(pZip->

(pZip->

, local_dir_header_ofs, local_dir_header,

(local_dir_header)) !=

(local_dir_header))

cur_archive_file_ofs +=

(local_dir_header);

(pZip->

(pZip->

, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)

cur_archive_file_ofs += archive_name_size;

(pExtra_data !=

)

(pZip->

(pZip->

, cur_archive_file_ofs, extra_data, extra_size) != extra_size)

cur_archive_file_ofs += extra_size;

(!

(pZip, local_dir_header, (

)archive_name_size, (

)user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))

(pZip->

(pZip->

, local_dir_header_ofs, local_dir_header,

(local_dir_header)) !=

(local_dir_header))

cur_archive_file_ofs +=

(local_dir_header);

(pZip->

(pZip->

, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)

cur_archive_file_ofs += archive_name_size;

(user_extra_data_len > 0)

(pZip->

(pZip->

, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)

cur_archive_file_ofs += user_extra_data_len;

(store_data_uncompressed)

cur_archive_file_ofs += buf_size;

comp_size = buf_size;

.m_pZip = pZip;

.m_cur_archive_file_ofs = cur_archive_file_ofs;

.m_comp_size = 0;

comp_size =

.m_comp_size;

cur_archive_file_ofs =

.m_cur_archive_file_ofs;

(pExtra_data ==

)

(pZip->

(pZip->

, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)

cur_archive_file_ofs += local_dir_footer_size;

(pExtra_data !=

)

comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,

user_extra_data_central, user_extra_data_central_len))

*user_extra_data,

user_extra_data_len,

*user_extra_data_central,

user_extra_data_central_len)

method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;

local_dir_header_ofs, cur_archive_file_ofs = pZip->

, uncomp_size = 0, comp_size = 0;

archive_name_size;

file_ofs = 0, cur_archive_header_file_ofs;

((

)level_and_flags < 0)

level = level_and_flags & 0xF;

archive_name_size = strlen(pArchive_name);

cur_archive_file_ofs += num_alignment_padding_bytes;

local_dir_header_ofs = cur_archive_file_ofs;

(max_size && level)

pExtra_data = extra_data;

(!

(pZip, local_dir_header, (

)archive_name_size, (

)(extra_size + user_extra_data_len), 0, 0, 0, method, gen_flags, dos_time, dos_date))

(pZip->

(pZip->

, cur_archive_file_ofs, local_dir_header,

(local_dir_header)) !=

(local_dir_header))

cur_archive_file_ofs +=

(local_dir_header);

(pZip->

(pZip->

, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)

cur_archive_file_ofs += archive_name_size;

(pZip->

(pZip->

, cur_archive_file_ofs, extra_data, extra_size) != extra_size)

cur_archive_file_ofs += extra_size;

(!

(pZip, local_dir_header, (

)archive_name_size, (

)user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))

(pZip->

(pZip->

, cur_archive_file_ofs, local_dir_header,

(local_dir_header)) !=

(local_dir_header))

cur_archive_file_ofs +=

(local_dir_header);

(pZip->

(pZip->

, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)

cur_archive_file_ofs += archive_name_size;

(user_extra_data_len > 0)

(pZip->

(pZip->

, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)

cur_archive_file_ofs += user_extra_data_len;

cur_archive_file_ofs +=

;

uncomp_size = file_ofs;

comp_size = uncomp_size;

.m_pZip = pZip;

.m_cur_archive_file_ofs = cur_archive_file_ofs;

.m_comp_size = 0;

uncomp_size = file_ofs;

comp_size =

.m_comp_size;

cur_archive_file_ofs =

.m_cur_archive_file_ofs;

(pExtra_data ==

)

(pZip->

(pZip->

, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)

cur_archive_file_ofs += local_dir_footer_size;

(pExtra_data !=

)

uncomp_crc32, method, gen_flags, dos_time, dos_date))

cur_archive_header_file_ofs = local_dir_header_ofs;

(pZip->

(pZip->

, cur_archive_header_file_ofs, local_dir_header,

(local_dir_header)) !=

(local_dir_header))

(pExtra_data !=

)

cur_archive_header_file_ofs +=

(local_dir_header);

(pZip->

(pZip->

, cur_archive_header_file_ofs, pArchive_name, archive_name_size) != archive_name_size)

cur_archive_header_file_ofs += archive_name_size;

(pZip->

(pZip->

, cur_archive_header_file_ofs, extra_data, extra_size) != extra_size)

cur_archive_header_file_ofs += extra_size;

(pExtra_data !=

)

uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,

user_extra_data_central, user_extra_data_central_len))

(pBuf, 1,

, pSrc_file);

*user_extra_data,

user_extra_data_len,

*user_extra_data_central,

user_extra_data_central_len)

user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);

memset(&file_modified_time, 0,

(file_modified_time));

pFile_time = &file_modified_time;

pSrc_file =

(pSrc_filename,

);

status =

(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags,

, 0,

, 0);

((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start))

(pLocal_header_ofs)

((pExt) && (ext_len))

extra_size_remaining = ext_len;

*pExtra_data = pExt;

field_id, field_data_size, field_total_size;

(extra_size_remaining < (

(

) * 2))

field_total_size = field_data_size +

(

) * 2;

(field_total_size > extra_size_remaining)

pExtra_data += field_total_size;

extra_size_remaining -= field_total_size;

}

(extra_size_remaining);

, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;

src_archive_bytes_remaining, local_dir_header_ofs;

cur_src_file_ofs, cur_dst_file_ofs;

orig_central_dir_size;

*pSrc_central_header;

src_filename_len, src_comment_len, src_ext_len;

local_header_filename_size, local_header_extra_len;

local_header_comp_size, local_header_uncomp_size;

src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;

src_archive_bytes_remaining = local_header_filename_size + local_header_extra_len + src_file_stat.

;

((local_header_extra_len) && ((local_header_comp_size ==

) || (local_header_uncomp_size ==

)))

extra_size_remaining = local_header_extra_len;

pExtra_data = (

*)file_data_array.

;

field_id, field_data_size, field_total_size;

(extra_size_remaining < (

(

) * 2))

field_total_size = field_data_size +

(

) * 2;

(field_total_size > extra_size_remaining)

(field_data_size <

(

) * 2)

local_header_uncomp_size =

(pSrc_field_data);

found_zip64_ext_data_in_ldir =

;

pExtra_data += field_total_size;

extra_size_remaining -= field_total_size;

}

(extra_size_remaining);

(!pState->m_zip64)

cur_dst_file_ofs += num_alignment_padding_bytes;

local_dir_header_ofs = cur_dst_file_ofs;

(pZip->m_file_offset_alignment)

((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);

(src_archive_bytes_remaining)

(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf,

) !=

)

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

cur_src_file_ofs +=

;

(pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf,

) !=

)

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

cur_dst_file_ofs +=

;

src_archive_bytes_remaining -=

;

((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))

(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (

(

) * 6)) != (

(

) * 6))

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

(pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf,

(

) * 4) !=

(

) * 4)

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

(pZip->m_pState->m_zip64)

src_crc32 = pSrc_descriptor[0];

src_comp_size = pSrc_descriptor[1];

src_uncomp_size = pSrc_descriptor[2];

(pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf,

) !=

)

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

cur_src_file_ofs +=

;

cur_dst_file_ofs +=

;

pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);

orig_central_dir_size = pState->m_central_dir.m_size;

(pState->m_zip64)

pZip->m_total_files++;

pZip->m_archive_size = cur_dst_file_ofs;

central_dir_ofs, central_dir_size;

central_dir_ofs = 0;

central_dir_size = 0;

((!ppBuf) || (!pSize))

((!pZip) || (!pZip->

))

((

)level_and_flags < 0)

((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) >

))

created_new_archive =

;

status =

(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);

((!status) && (created_new_archive))

(void)ignoredStatus;

((!pZip_filename) || (!pArchive_name))

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

((!pZip) || (!pZip->

))

((!pZip) || (!pZip->

))

((!pZip) || (!pZip->

))

((!pZip) || (!pZip->

))

(filename_buf_size)

pFilename[0] =

;

(filename_buf_size)

=

(

, filename_buf_size - 1);

pFilename[

] =

;

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

strategy

Block allocation strategies.

unsigned int

A callback function used to compare two keys in a database.

for(len=0;yy_str[len];++len)

if(yy_accept[yy_current_state])

mz_zip_reader_extract_iter_state * mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)

static tdefl_sym_freq * tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)

#define MZ_WRITE_LE32(p, v)

void * tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)

mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)

static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes, const char *user_extra_data, mz_uint user_extra_data_len)

mz_bool mz_zip_is_zip64(mz_zip_archive *pZip)

static const mz_uint8 s_tdefl_len_extra[256]

mz_bool mz_zip_reader_end(mz_zip_archive *pZip)

mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)

mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)

mz_zip_type mz_zip_get_type(mz_zip_archive *pZip)

static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)

static const mz_uint16 s_tdefl_len_sym[256]

mz_bool mz_zip_end(mz_zip_archive *pZip)

static int tdefl_flush_block(tdefl_compressor *d, int flush)

mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)

mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)

#define MZ_WRITE_LE16(p, v)

mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void *callback_opaque, mz_uint64 max_size, const time_t *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)

static void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)

static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)

static void tdefl_start_dynamic_block(tdefl_compressor *d)

mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)

static void mz_write_le64(mz_uint8 *p, mz_uint64 v)

#define TINFL_GET_BYTE(state_index, c)

#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size)

@ TDEFL_MAX_SUPPORTED_HUFF_CODESIZE

static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)

size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip)

static int mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)

static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, mz_uint file_index, const mz_uint8 *pCentral_dir_header, mz_zip_archive_file_stat *pStat, mz_bool *pFound_zip64_extra_data)

void * tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)

mz_uint32 tdefl_get_adler32(tdefl_compressor *d)

mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)

static mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)

#define TDEFL_RLE_ZERO_CODE_SIZE()

static void mz_write_le32(mz_uint8 *p, mz_uint32 v)

static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)

mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)

size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)

mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip)

#define MZ_FREOPEN(f, m, s)

static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)

static const mz_uint8 s_tdefl_small_dist_sym[512]

tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)

static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)

@ MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS

@ MZ_ZIP_CDH_FILENAME_LEN_OFS

@ MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR

@ MZ_ZIP_LOCAL_DIR_HEADER_SIG

@ MZ_ZIP_CDH_FILE_DATE_OFS

@ MZ_ZIP_LDH_BIT_FLAG_OFS

@ MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS

@ MZ_ZIP_CDH_VERSION_NEEDED_OFS

@ MZ_ZIP_DATA_DESCRIPTER_SIZE64

@ MZ_ZIP_CDH_LOCAL_HEADER_OFS

@ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG

@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8

@ MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS

@ MZ_ZIP_CDH_COMPRESSED_SIZE_OFS

@ MZ_ZIP_DATA_DESCRIPTER_SIZE32

@ MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS

@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG

@ MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS

@ MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS

@ MZ_ZIP_ECDH_CDIR_SIZE_OFS

@ MZ_ZIP_LDH_FILENAME_LEN_OFS

@ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE

@ MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG

@ MZ_ZIP_LDH_FILE_TIME_OFS

@ MZ_ZIP64_ECDH_VERSION_NEEDED_OFS

@ MZ_ZIP_CDH_EXTRA_LEN_OFS

@ MZ_ZIP_LDH_FILE_DATE_OFS

@ MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS

@ MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS

@ MZ_ZIP_LDH_COMPRESSED_SIZE_OFS

@ MZ_ZIP_CDH_FILE_TIME_OFS

@ MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID

@ MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS

@ MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID

@ MZ_ZIP_CENTRAL_DIR_HEADER_SIG

@ MZ_ZIP_ECDH_COMMENT_SIZE_OFS

@ MZ_ZIP64_ECDH_CDIR_SIZE_OFS

@ MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS

@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION

@ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG

@ MZ_ZIP_CDH_DISK_START_OFS

@ MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS

@ MZ_ZIP_CDH_INTERNAL_ATTR_OFS

@ MZ_ZIP_LDH_VERSION_NEEDED_OFS

@ MZ_ZIP_ECDH_CDIR_OFS_OFS

@ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG

@ MZ_ZIP_LDH_EXTRA_LEN_OFS

@ MZ_ZIP_CDH_EXTERNAL_ATTR_OFS

@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED

@ MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS

@ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE

@ MZ_ZIP_LOCAL_DIR_HEADER_SIZE

@ MZ_ZIP64_ECDH_CDIR_OFS_OFS

@ MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS

@ MZ_ZIP_CDH_BIT_FLAG_OFS

@ MZ_ZIP_CDH_COMMENT_LEN_OFS

@ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE

@ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE

@ MZ_ZIP_DATA_DESCRIPTOR_ID

@ MZ_ZIP_CDH_VERSION_MADE_BY_OFS

@ MZ_ZIP_ECDH_NUM_THIS_DISK_OFS

@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED

@ MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS

const char * mz_version(void)

size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)

int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)

mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)

static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)

static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)

mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)

mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)

unsigned char mz_validate_uint32[sizeof(mz_uint32)==4 ? 1 :-1]

mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)

#define TINFL_MEMCPY(d, s, l)

static mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)

#define TINFL_GET_BITS(state_index, b, n)

mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)

mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, FILE *pFile, mz_uint flags)

static const mz_uint8 s_tdefl_small_dist_extra[512]

tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)

mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)

static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)

mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, time_t *last_modified, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)

static mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index)

static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)

mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip)

mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)

#define TINFL_HUFF_DECODE(state_index, sym, pHuff)

void * miniz_def_alloc_func(void *opaque, size_t items, size_t size)

static time_t mz_zip_dos_to_time_t(int dos_time, int dos_date)

mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)

mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)

tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)

mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)

mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)

static const mz_uint8 s_tdefl_large_dist_extra[128]

void * tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)

static void mz_zip_time_t_to_dos_time(time_t time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)

tinfl_decompressor * tinfl_decompressor_alloc()

static const mz_uint s_tdefl_num_probes[11]

mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)

static mz_bool tdefl_compress_normal(tdefl_compressor *d)

mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, FILE *pFile, mz_uint flags)

static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)

static void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)

const char * mz_zip_get_error_string(mz_zip_error mz_err)

static mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)

mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, FILE *pSrc_file, mz_uint64 max_size, const time_t *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)

mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, FILE *pFile, mz_uint64 archive_size, mz_uint flags)

void * mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)

void miniz_def_free_func(void *opaque, void *address)

static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)

static mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)

static void tdefl_start_static_block(tdefl_compressor *d)

static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)

mz_bool mz_zip_writer_end(mz_zip_archive *pZip)

static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, mz_uint32 ext_attributes)

#define TINFL_MEMSET(p, c, l)

mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)

static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)

tdefl_compressor * tdefl_compressor_alloc()

mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)

mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)

mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)

void mz_zip_zero_struct(mz_zip_archive *pZip)

static mz_uint32 mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, mz_uint64 *pComp_size, mz_uint64 *pLocal_header_ofs)

static void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)

mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, FILE *pFile, mz_uint flags)

mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip)

size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state *pState, void *pvBuf, size_t buf_size)

static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)

static void mz_write_le16(mz_uint8 *p, mz_uint16 v)

void * mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)

static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)

static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)

static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)

mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)

static void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)

mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)

#define TINFL_CR_RETURN(state_index, result)

#define TINFL_CR_RETURN_FOREVER(state_index, result)

static const mz_uint8 * mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)

mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)

#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE

mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)

mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)

static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)

mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)

void tdefl_compressor_free(tdefl_compressor *pComp)

mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip)

static mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)

unsigned char mz_validate_uint64[sizeof(mz_uint64)==8 ? 1 :-1]

mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)

static const mz_uint mz_bitmasks[17]

mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)

#define MZ_FILE_STAT_STRUCT

static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[]

static void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)

void * mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)

static mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)

mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)

static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)

size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)

tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)

#define MZ_SWAP_UINT32(a, b)

static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)

static const mz_uint8 s_tdefl_large_dist_sym[128]

static mz_bool mz_zip_get_file_modified_time(const char *pFilename, time_t *pTime)

mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)

mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)

mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)

static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)

static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index)

static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, uint32_t ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)

mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state *pState)

static mz_bool mz_zip_set_file_times(const char *pFilename, time_t access_time, time_t modified_time)

static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)

mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)

static mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)

unsigned char mz_validate_uint16[sizeof(mz_uint16)==2 ? 1 :-1]

void * miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)

#define MZ_WRITE_LE64(p, v)

mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)

tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)

mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)

static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)

void * mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)

mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip)

#define TINFL_SKIP_BITS(state_index, n)

FILE * mz_zip_get_cfile(mz_zip_archive *pZip)

#define TDEFL_RLE_PREV_CODE_SIZE()

mz_zip_reader_extract_iter_state * mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)

mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)

mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)

mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)

static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)

void tinfl_decompressor_free(tinfl_decompressor *pDecomp)

#define TDEFL_PUT_BITS(b, l)

void * tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)

static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

@ MZ_ZIP_FLAG_ASCII_FILENAME

@ MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE

@ MZ_ZIP_FLAG_WRITE_ZIP64

@ MZ_ZIP_FLAG_WRITE_ALLOW_READING

@ MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY

@ MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG

@ MZ_ZIP_FLAG_COMPRESSED_DATA

@ MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY

@ MZ_ZIP_FLAG_CASE_SENSITIVE

@ MZ_ZIP_FLAG_IGNORE_PATH

int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len)

size_t(* mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

int mz_deflateReset(mz_streamp pStream)

int mz_inflateInit(mz_streamp pStream)

int mz_inflate(mz_streamp pStream, int flush)

int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)

mz_ulong mz_compressBound(mz_ulong source_len)

@ TDEFL_MAX_HUFF_SYMBOLS_0

@ TDEFL_LZ_DICT_SIZE_MASK

@ TDEFL_MAX_HUFF_SYMBOLS_1

@ TDEFL_MAX_HUFF_SYMBOLS_2

int mz_deflateEnd(mz_streamp pStream)

@ TINFL_STATUS_ADLER32_MISMATCH

@ TINFL_STATUS_NEEDS_MORE_INPUT

@ TINFL_STATUS_HAS_MORE_OUTPUT

@ TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS

#define TINFL_LZ_DICT_SIZE

#define MZ_CLEAR_OBJ(obj)

@ TDEFL_FORCE_ALL_RAW_BLOCKS

@ TDEFL_GREEDY_PARSING_FLAG

@ TDEFL_FORCE_ALL_STATIC_BLOCKS

@ TDEFL_WRITE_ZLIB_HEADER

@ TDEFL_NONDETERMINISTIC_PARSING_FLAG

int(* tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser)

#define tinfl_get_adler32(r)

@ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF

@ TINFL_FLAG_HAS_MORE_INPUT

@ TINFL_FLAG_COMPUTE_ADLER32

@ TINFL_FLAG_PARSE_ZLIB_HEADER

#define MZ_DEFAULT_WINDOW_BITS

int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)

int mz_deflateInit(mz_streamp pStream, int level)

int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)

int mz_inflateReset(mz_streamp pStream)

size_t(* mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

@ TDEFL_LEVEL1_HASH_SIZE_MASK

@ MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE

@ MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE

int mz_inflateInit2(mz_streamp pStream, int window_bits)

int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)

int mz_inflateEnd(mz_streamp pStream)

int mz_deflate(mz_streamp pStream, int flush)

#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED

@ TDEFL_STATUS_PUT_BUF_FAILED

const char * mz_error(int err)

mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)

@ MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED

mz_bool(* tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser)

@ MZ_ZIP_UNSUPPORTED_METHOD

@ MZ_ZIP_UNSUPPORTED_FEATURE

@ MZ_ZIP_FILE_OPEN_FAILED

@ MZ_ZIP_WRITE_CALLBACK_FAILED

@ MZ_ZIP_CRC_CHECK_FAILED

@ MZ_ZIP_FILE_CLOSE_FAILED

@ MZ_ZIP_FILE_CREATE_FAILED

@ MZ_ZIP_VALIDATION_FAILED

@ MZ_ZIP_FILE_STAT_FAILED

@ MZ_ZIP_INVALID_FILENAME

@ MZ_ZIP_COMPRESSION_FAILED

@ MZ_ZIP_UNSUPPORTED_ENCRYPTION

@ MZ_ZIP_UNSUPPORTED_MULTIDISK

@ MZ_ZIP_ARCHIVE_TOO_LARGE

@ MZ_ZIP_DECOMPRESSION_FAILED

@ MZ_ZIP_FILE_WRITE_FAILED

@ MZ_ZIP_INVALID_PARAMETER

@ MZ_ZIP_INVALID_HEADER_OR_CORRUPTED

@ MZ_ZIP_UNSUPPORTED_CDIR_SIZE

@ MZ_ZIP_FILE_READ_FAILED

@ MZ_ZIP_FAILED_FINDING_CENTRAL_DIR

@ MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE

@ MZ_ZIP_FILE_SEEK_FAILED

mz_uint32 tinfl_bit_buf_t

const struct ncbi::grid::netcache::search::fields::SIZE size

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

static PCRE2_SIZE * offsets

static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

struct mz_internal_state * state

const unsigned char * next_in

mz_uint32 m_external_attr

mz_uint16 m_version_needed

mz_uint16 m_version_made_by

mz_uint64 m_central_dir_ofs

mz_uint64 m_local_header_ofs

mz_uint16 m_internal_attr

char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE]

char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE]

mz_uint64 m_central_directory_file_ofs

mz_zip_error m_last_error

mz_file_needs_keepalive m_pNeeds_keepalive

mz_file_write_func m_pWrite

mz_zip_internal_state * m_pState

mz_realloc_func m_pRealloc

mz_file_read_func m_pRead

mz_uint64 m_file_offset_alignment

mz_bool m_zip64_has_extended_info_fields

mz_zip_array m_sorted_central_dir_offsets

mz_uint64 m_file_archive_start_ofs

mz_zip_array m_central_dir_offsets

mz_zip_array m_central_dir

mz_uint64 m_cur_archive_file_ofs

mz_uint m_saved_match_dist

mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE]

mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]

mz_uint m_output_flush_remaining

mz_uint m_wants_to_finish

tdefl_status m_prev_return_status

mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE+TDEFL_MAX_MATCH_LEN - 1]

tdefl_put_buf_func_ptr m_pPut_buf_func

mz_uint m_output_flush_ofs

mz_uint16 m_next[TDEFL_LZ_DICT_SIZE]

mz_uint8 * m_pOutput_buf_end

mz_uint m_saved_match_len

mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]

mz_uint m_lz_code_buf_dict_pos

mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE]

mz_uint8 * m_pLZ_code_buf

mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]

mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE]

mz_int16 m_tree[TINFL_MAX_HUFF_SYMBOLS_0 *2]

mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0]

mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4