/*     deflateBound() returns an upper bound on the compressed size after   deflation of sourceLen bytes.  It must be called after deflateInit()   or deflateInit2().  This would be used to allocate an output buffer   for deflation in a single pass, and so would be called before deflate().*/ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,                                     int bits,                                     int value));/*     deflatePrime() inserts bits in the deflate output stream.  The intent  is that this function is used to start off the deflate output with the  bits leftover from a previous deflate stream when appending to it.  As such,  this function can only be used for raw deflate, and must be used before the  first deflate() call after a deflateInit2() or deflateReset().  bits must be  less than or equal to 16, and that many of the least significant bits of  value will be inserted in the output.      deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source   stream state was inconsistent.*//*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. windowBits must be greater than or equal to the windowBits value   provided to deflateInit2() while compressing, or it must be equal to 15 if   deflateInit2() was not used. 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.     windowBits can also be -8..-15 for raw inflate. In this case, -windowBits   determines the window size. inflate() will then process raw deflate data,   not looking for a zlib or gzip header, not generating a check value, and not   looking for any check values for comparison at the end of the stream. This   is for use with other formats that use the deflate compressed data format   such as zip.  Those formats provide their own check values. If a custom   format is developed using the raw deflate format for compressed data, it is   recommended that a check value such as an adler32 or a crc32 be applied to   the uncompressed data as is done in the zlib, gzip, and zip formats.  For   most applications, the zlib format should be used as is. Note that comments   above on the use in deflateInit2() applies to the magnitude of windowBits.     windowBits can also be greater than 15 for optional gzip decoding. Add   32 to windowBits to enable zlib and gzip decoding with automatic header   detection, or add 16 to decode only the gzip format (the zlib format will   return a Z_DATA_ERROR.  If a gzip stream is being decoded, strm->adler is   a crc32 instead of an adler32.     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 Q_ZEXPORT 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 Q_ZEXPORT 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 inflateCopy 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 randomly accessing a large stream.  The   first pass through the stream can periodically record the inflate state,   allowing restarting inflate at those points when randomly accessing the   stream.     inflateCopy 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 Q_ZEXPORT 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).*//*ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits,                                        unsigned char FAR *window));     Initialize the internal stream state for decompression using inflateBack()   calls.  The fields zalloc, zfree and opaque in strm must be initialized   before the call.  If zalloc and zfree are Z_NULL, then the default library-   derived memory allocation routines are used.  windowBits is the base two   logarithm of the window size, in the range 8..15.  window is a caller   supplied buffer of that size.  Except for special applications where it is   assured that deflate was used with small window sizes, windowBits must be 15   and a 32K byte window must be supplied to be able to decompress general   deflate streams.     See inflateBack() for the usage of these routines.     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of   the paramaters are invalid, Z_MEM_ERROR if the internal state could not   be allocated, or Z_VERSION_ERROR if the version of the library does not   match the version of the header file.*/typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm,                                    in_func in, void FAR *in_desc,                                    out_func out, void FAR *out_desc));/*     inflateBack() does a raw inflate with a single call using a call-back   interface for input and output.  This is more efficient than inflate() for   file i/o applications in that it avoids copying between the output and the   sliding window by simply making the window itself the output buffer.  This   function trusts the application to not change the output buffer passed by   the output function, at least until inflateBack() returns.     inflateBackInit() must be called first to allocate the internal state   and to initialize the state with the user-provided window buffer.   inflateBack() may then be used multiple times to inflate a complete, raw   deflate stream with each call.  inflateBackEnd() is then called to free   the allocated state.     A raw deflate stream is one with no zlib or gzip header or trailer.   This routine would normally be used in a utility that reads zip or gzip   files and writes out uncompressed files.  The utility would decode the   header and process the trailer on its own, hence this routine expects   only the raw deflate stream to decompress.  This is different from the   normal behavior of inflate(), which expects either a zlib or gzip header and   trailer around the deflate stream.     inflateBack() uses two subroutines supplied by the caller that are then   called by inflateBack() for input and output.  inflateBack() calls those   routines until it reads a complete deflate stream and writes out all of the   uncompressed data, or until it encounters an error.  The function's   parameters and return types are defined above in the in_func and out_func   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the   number of bytes of provided input, and a pointer to that input in buf.  If   there is no input available, in() must return zero--buf is ignored in that   case--and inflateBack() will return a buffer error.  inflateBack() will call   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()   should return zero on success, or non-zero on failure.  If out() returns   non-zero, inflateBack() will return with an error.  Neither in() nor out()   are permitted to change the contents of the window provided to   inflateBackInit(), which is also the buffer that out() uses to write from.   The length written by out() will be at most the window size.  Any non-zero   amount of input may be provided by in().     For convenience, inflateBack() can be provided input on the first call by   setting strm->next_in and strm->avail_in.  If that input is exhausted, then   in() will be called.  Therefore strm->next_in must be initialized before   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in   must also be initialized, and then if strm->avail_in is not zero, input will   initially be taken from strm->next_in[0 .. strm->avail_in - 1].     The in_desc and out_desc parameters of inflateBack() is passed as the   first parameter of in() and out() respectively when they are called.  These   descriptors can be optionally used to pass any information that the caller-   supplied in() and out() functions need to do their job.     On return, inflateBack() will set strm->next_in and strm->avail_in to   pass back any unused input that was provided by the last in() call.  The   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR   if in() or out() returned an error, Z_DATA_ERROR if there was a format   error in the deflate stream (in which case strm->msg is set to indicate the   nature of the error), or Z_STREAM_ERROR if the stream was not properly   initialized.  In the case of Z_BUF_ERROR, an input or output error can be   distinguished using strm->next_in which will be Z_NULL only if in() returned   an error.  If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to   out() returning non-zero.  (in() will always be called before out(), so   strm->next_in is assured to be defined if out() returns non-zero.)  Note   that inflateBack() cannot return Z_OK.*/ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm));/*     All memory allocated by inflateBackInit() is freed.     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream   state was inconsistent.*/ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));/* Return flags indicating compile-time options.    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:     1.0: size of uInt     3.2: size of uLong     5.4: size of voidpf (pointer)     7.6: size of z_off_t    Compiler, assembler, and debug options:     8: DEBUG     9: ASMV or ASMINF -- use ASM code     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention     11: 0 (reserved)    One-time table building (smaller code, but not thread-safe if true):     12: BUILDFIXED -- build static block decoding tables when needed     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed     14,15: 0 (reserved)    Library content (indicates missing functionality):     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking                          deflate code when not needed)     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect                    and decode gzip streams (to avoid linking crc code)     18-19: 0 (reserved)    Operation variations (changes in library functionality):     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate     21: FASTEST -- deflate algorithm with only one, lowest compression level     22,23: 0 (reserved)    The sprintf variant used by gzprintf (zero is best):     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!     26: 0 = returns value, 1 = void -- 1 means inferred string length returned    Remainder:     27-31: 0 (reserved) */                        /* utility functions *//*     The following utility functions are implemented on top of the   basic stream-oriented functions. To simplify the interface, some   default options are assumed (compression level and memory usage,   standard memory allocation functions). The source code of these   utility functions can easily be modified if you need special options.*/ZEXTERN int Q_ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,                                 const Bytef *source, uLong sourceLen));/*     Compresses the source buffer into the destination buffer.  sourceLen is   the byte length of the source buffer. Upon entry, destLen is the total   size of the destination buffer, which must be at least the value returned   by compressBound(sourceLen). Upon exit, destLen is the actual size of the   compressed buffer.     This function can be used to compress a whole file at once if the   input file is mmap'ed.     compress returns Z_OK if success, Z_MEM_ERROR if there was not   enough memory, Z_BUF_ERROR if there was not enough room in the output   buffer.*/ZEXTERN int Q_ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,                                  const Bytef *source, uLong sourceLen,                                  int level));/*     Compresses the source buffer into the destination buffer. The level   parameter has the same meaning as in deflateInit.  sourceLen is the byte   length of the source buffer. Upon entry, destLen is the total size of the   destination buffer, which must be at least the value returned by   compressBound(sourceLen). Upon exit, destLen is the actual size of the