The dictionary should consist of strings (byte sequences) that are likely   to be encountered later in the data to be compressed, with the most commonly   used strings preferably put towards the end of the dictionary. Using a   dictionary is most useful when the data to be compressed is short and can be   predicted with good accuracy; the data can then be compressed better than   with the default empty dictionary.     Depending on the size of the compression data structures selected by   deflateInit or deflateInit2, a part of the dictionary may in effect be   discarded, for example if the dictionary is larger than the window size in   deflate or deflate2. Thus the strings most likely to be useful should be   put at the end of the dictionary, not at the front.     Upon return of this function, strm->adler is set to the Adler32 value   of the dictionary; the decompressor may later use this value to determine   which dictionary has been used by the compressor. (The Adler32 value   applies to the whole dictionary even if only a subset of the dictionary is   actually used by the compressor.)     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a   parameter is invalid (such as NULL dictionary) or the stream state is   inconsistent (for example if deflate has already been called for this stream   or if the compression method is bsort). deflateSetDictionary does not   perform any compression: this will be done by deflate().*/ZEXTERN int ZEXPORT zlib_fs_deflateCopy OF((z_streamp dest,					    z_streamp source));/*     Sets the destination stream as a complete copy of the source stream.     This function can be useful when several compression strategies will be   tried, for example when there are several ways of pre-processing the input   data with a filter. The streams that will be discarded should then be freed   by calling deflateEnd.  Note that deflateCopy duplicates the internal   compression state which can be quite large, so this strategy is slow and   can consume lots of memory.     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent   (such as zalloc being NULL). msg is left unchanged in both source and   destination.*/ZEXTERN int ZEXPORT zlib_fs_deflateReset OF((z_streamp strm));/*     This function is equivalent to deflateEnd followed by deflateInit,   but does not free and reallocate all the internal compression state.   The stream will keep the same compression level and any other attributes   that may have been set by deflateInit2.      deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source   stream state was inconsistent (such as zalloc or state being NULL).*/ZEXTERN int ZEXPORT zlib_fs_deflateParams OF((z_streamp strm,					      int level,					      int strategy));/*     Dynamically update the compression level and compression strategy.  The   interpretation of level and strategy is as in deflateInit2.  This can be   used to switch between compression and straight copy of the input data, or   to switch to a different kind of input data requiring a different   strategy. If the compression level is changed, the input available so far   is compressed with the old level (and may be flushed); the new level will   take effect only at the next call of deflate().     Before the call of deflateParams, the stream state must be set as for   a call of deflate(), since the currently available input may have to   be compressed and flushed. In particular, strm->avail_out must be non-zero.     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR   if strm->avail_out was zero.*//*   ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,                                     int  windowBits));     This is another version of inflateInit with an extra parameter. The   fields next_in, avail_in, zalloc, zfree and opaque must be initialized   before by the caller.     The windowBits parameter is the base two logarithm of the maximum window   size (the size of the history buffer).  It should be in the range 8..15 for   this version of the library. The default value is 15 if inflateInit is used   instead. If a compressed stream with a larger window size is given as   input, inflate() will return with the error code Z_DATA_ERROR instead of   trying to allocate a larger window.      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough   memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative   memLevel). msg is set to null if there is no error message.  inflateInit2   does not perform any decompression apart from reading the zlib header if   present: this will be done by inflate(). (So next_in and avail_in may be   modified, but next_out and avail_out are unchanged.)*/ZEXTERN int ZEXPORT zlib_fs_inflateSetDictionary OF((z_streamp strm,						     const Bytef *dictionary,						     uInt  dictLength));/*     Initializes the decompression dictionary from the given uncompressed byte   sequence. This function must be called immediately after a call of inflate   if this call returned Z_NEED_DICT. The dictionary chosen by the compressor   can be determined from the Adler32 value returned by this call of   inflate. The compressor and decompressor must use exactly the same   dictionary (see deflateSetDictionary).     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a   parameter is invalid (such as NULL dictionary) or the stream state is   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the   expected one (incorrect Adler32 value). inflateSetDictionary does not   perform any decompression: this will be done by subsequent calls of   inflate().*/ZEXTERN int ZEXPORT zlib_fs_inflateSync OF((z_streamp strm));/*     Skips invalid compressed data until a full flush point (see above the  description of deflate with Z_FULL_FLUSH) can be found, or until all  available input is skipped. No output is provided.    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR  if no more input was provided, Z_DATA_ERROR if no flush point has been found,  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success  case, the application may save the current current value of total_in which  indicates where valid compressed data was found. In the error case, the  application may repeatedly call inflateSync, providing more input each time,  until success or end of the input data.*/ZEXTERN int ZEXPORT zlib_fs_inflateReset OF((z_streamp strm));/*     This function is equivalent to inflateEnd followed by inflateInit,   but does not free and reallocate all the internal decompression state.   The stream will keep attributes that may have been set by inflateInit2.      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source   stream state was inconsistent (such as zalloc or state being NULL).*/                        /* checksum functions *//*     These functions are not related to compression but are exported   anyway because they might be useful in applications using the   compression library.*/ZEXTERN uLong ZEXPORT zlib_fs_adler32 OF((uLong adler, const Bytef *buf, uInt len));/*     Update a running Adler-32 checksum with the bytes buf[0..len-1] and   return the updated checksum. If buf is NULL, this function returns   the required initial value for the checksum.   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed   much faster. Usage example:     uLong adler = adler32(0L, Z_NULL, 0);     while (read_buffer(buffer, length) != EOF) {       adler = adler32(adler, buffer, length);     }     if (adler != original_adler) error();*/ZEXTERN uLong ZEXPORT zlib_fs_crc32   OF((uLong crc, const Bytef *buf, uInt len));/*     Update a running crc with the bytes buf[0..len-1] and return the updated   crc. If buf is NULL, this function returns the required initial value   for the crc. Pre- and post-conditioning (one's complement) is performed   within this function so it shouldn't be done by the application.   Usage example:     uLong crc = crc32(0L, Z_NULL, 0);     while (read_buffer(buffer, length) != EOF) {       crc = crc32(crc, buffer, length);     }     if (crc != original_crc) error();*/                        /* various hacks, don't look :) *//* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ZEXTERN int ZEXPORT zlib_fs_deflateInit_ OF((z_streamp strm, int level,                                     const char *version, int stream_size));ZEXTERN int ZEXPORT zlib_fs_inflateInit_ OF((z_streamp strm,                                     const char *version, int stream_size));ZEXTERN int ZEXPORT zlib_fs_deflateInit2_ OF((z_streamp strm, int  level, int  method,                                      int windowBits, int memLevel,                                      int strategy, const char *version,                                      int stream_size));ZEXTERN int ZEXPORT zlib_fs_inflateInit2_ OF((z_streamp strm, int  windowBits,                                      const char *version, int stream_size));#define zlib_fs_deflateInit(strm, level) \        zlib_fs_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))#define zlib_fs_inflateInit(strm) \        zlib_fs_inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))#define zlib_fs_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \        zlib_fs_deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\                      (strategy), ZLIB_VERSION, sizeof(z_stream))#define zlib_fs_inflateInit2(strm, windowBits) \        zlib_fs_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)    struct internal_state {int dummy;}; /* hack for buggy compilers */#endifZEXTERN const char   * ZEXPORT zlib_fs_zError           OF((int err));ZEXTERN int            ZEXPORT zlib_fs_inflateSyncPoint OF((z_streamp z));ZEXTERN const uLongf * ZEXPORT zlib_fs_get_crc_table    OF((void));#ifdef __cplusplus}#endif#endif /* _ZLIB_H */