From ded94ad1efeb16c721a5ec75f74a6d9a647fd2cf Mon Sep 17 00:00:00 2001 From: Don Gagne Date: Wed, 1 Jul 2020 07:51:01 -0700 Subject: [PATCH] Revert "Remove windows only zlib" --- libs/zlib/windows/include/zconf.h | 332 +++++++ libs/zlib/windows/include/zlib.h | 1357 ++++++++++++++++++++++++++++ libs/zlib/windows/lib/libz.a | Bin 0 -> 77534 bytes libs/zlib/windows/lib/libz.dll.a | Bin 0 -> 43738 bytes libs/zlib/windows/lib/zlib-bcc.lib | Bin 0 -> 6656 bytes libs/zlib/windows/lib/zlib.def | 75 ++ libs/zlib/windows/lib/zlib.lib | Bin 0 -> 14778 bytes 7 files changed, 1764 insertions(+) create mode 100644 libs/zlib/windows/include/zconf.h create mode 100644 libs/zlib/windows/include/zlib.h create mode 100644 libs/zlib/windows/lib/libz.a create mode 100644 libs/zlib/windows/lib/libz.dll.a create mode 100644 libs/zlib/windows/lib/zlib-bcc.lib create mode 100644 libs/zlib/windows/lib/zlib.def create mode 100644 libs/zlib/windows/lib/zlib.lib diff --git a/libs/zlib/windows/include/zconf.h b/libs/zlib/windows/include/zconf.h new file mode 100644 index 000000000..03a9431c8 --- /dev/null +++ b/libs/zlib/windows/include/zconf.h @@ -0,0 +1,332 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + */ +#ifdef Z_PREFIX +# define deflateInit_ z_deflateInit_ +# define deflate z_deflate +# define deflateEnd z_deflateEnd +# define inflateInit_ z_inflateInit_ +# define inflate z_inflate +# define inflateEnd z_inflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateSetDictionary z_deflateSetDictionary +# define deflateCopy z_deflateCopy +# define deflateReset z_deflateReset +# define deflateParams z_deflateParams +# define deflateBound z_deflateBound +# define deflatePrime z_deflatePrime +# define inflateInit2_ z_inflateInit2_ +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateCopy z_inflateCopy +# define inflateReset z_inflateReset +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# define uncompress z_uncompress +# define adler32 z_adler32 +# define crc32 z_crc32 +# define get_crc_table z_get_crc_table +# define zError z_zError + +# define alloc_func z_alloc_func +# define free_func z_free_func +# define in_func z_in_func +# define out_func z_out_func +# define Byte z_Byte +# define uInt z_uInt +# define uLong z_uLong +# define Bytef z_Bytef +# define charf z_charf +# define intf z_intf +# define uIntf z_uIntf +# define uLongf z_uLongf +# define voidpf z_voidpf +# define voidp z_voidp +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# ifdef VMS +# include /* for off_t */ +# endif +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +#if defined(__OS400__) +# define NO_vsnprintf +#endif + +#if defined(__MVS__) +# define NO_vsnprintf +# ifdef FAR +# undef FAR +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/libs/zlib/windows/include/zlib.h b/libs/zlib/windows/include/zlib.h new file mode 100644 index 000000000..022817927 --- /dev/null +++ b/libs/zlib/windows/include/zlib.h @@ -0,0 +1,1357 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.3, July 18th, 2005 + + Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.3" +#define ZLIB_VERNUM 0x1230 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumualte before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + the value returned by deflateBound (see below). If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit 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 inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, + Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() stop + if and when it gets to the next deflate block boundary. When decoding the + zlib or gzip format, this will cause inflate() to return immediately after + the header and before the first block. When doing a raw inflate, inflate() + will go ahead and process the first block, and will return when it gets to + the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 + if inflate() is currently decoding the last block in the deflate stream, + plus 128 if inflate() returned immediately after decoding an end-of-block + code or decoding the complete header up to just before the first byte of the + deflate stream. The end-of-block will not be indicated until all of the + uncompressed data from that block has been written to strm->next_out. The + number of unused bits may in general be greater than seven, except when + bit 7 of data_type is set, in which case the number of unused bits will be + less than eight. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster approach + may be used for the single inflate() call. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the only effect of the flush parameter in this implementation + is on the return value of inflate(), as noted below, or when it returns early + because Z_BLOCK is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the adler32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the adler32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() will decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically. Any information + contained in the gzip header is not retained, so applications that need that + information should instead use raw inflate, see inflateInit2() below, or + inflateBack() and perform their own processing of the gzip header and + trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may then + call inflateSync() to look for a good compression block if a partial recovery + of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), + no header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as + Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy + parameter only affects the compression ratio but not the correctness of the + compressed output even if it is not set appropriately. Z_FIXED prevents the + use of dynamic Huffman codes, allowing for a simpler decoder for special + applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + 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. In addition, the + current implementation of deflate will use at most the window size minus + 262 bytes of the provided dictionary. + + 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.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + 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 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 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 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 deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + 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 deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader 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 null strm). 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 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 that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called + immediately after inflateInit2() or inflateReset() and before any call of + inflate() to set the dictionary. The application must insure that the + dictionary that was used for compression is provided. + + 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 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 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 inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK can be used to + force inflate() to return immediately after header processing is complete + and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When + any of extra, name, or comment are not Z_NULL and the respective field is + not present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp 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_streamp 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_streamp 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 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 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 + compressed buffer. + + compress2 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, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before + a compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses 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 large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress 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, or Z_DATA_ERROR if the input data was corrupted or incomplete. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h", or 'R' for run-length encoding + as in "wb1R". (See the description of deflateInit2 for more information + about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). The number of + uncompressed bytes written is limited to 4095. The caller should assure that + this limit is not exceeded. If it is exceeded, then gzprintf() will return + return an error (0) with nothing written. In this case, there may also be a + buffer overflow with unpredictable consequences, which is possible only if + zlib was compiled with the insecure functions sprintf() or vsprintf() + because the secure snprintf() or vsnprintf() functions were not available. +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read again later. + Only one character of push-back is allowed. gzungetc() returns the + character pushed, or -1 on failure. gzungetc() will fail if a + character has been pushed but not read yet, or if c is -1. The pushed + character will be discarded if the stream is repositioned with gzseek() + or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns 1 if file is being read directly without decompression, otherwise + zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + + /* 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 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 adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); +/* + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is NULL, this function returns the required initial + value for the 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(); +*/ + +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + +/* + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* 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 deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/libs/zlib/windows/lib/libz.a b/libs/zlib/windows/lib/libz.a new file mode 100644 index 0000000000000000000000000000000000000000..876f8983043bdb282cd4f14a8853e7d9437e03cf GIT binary patch literal 77534 zcmc${30%zG_c%UNqb4mgD5Ak&q!0~B*;-W;p%f|Yn?|K3k)D((dV3pWjmJYCYnH4f zN?It%(n5=+WJx20Qi+=1x$pPPD4yr@dA{Gz=llOpubF%9x!bwto^$Sg8!^K(%sXIK z--+zrA1-$i*J!H2)G1sxTb~H(`O9W=xyF;o6drvk6p9UnLVHJkl?o{o=~wkLg(Ce< z`$(buH@_Z`pZER$`FD>3h4Odb+xisBUw!X#D3pKrrBaqtWZ&Ux6e{}aEOPhs;rWJ5 zoJ&Fe&&0G7pIe_5p90H%d!5KT`Vp@)63N@9D*ZjQpd* zd_5tue^g{xAfG^lh6M)m{SYeL*Ea~cA)&s($n}u|;lBJ(&oIxG;Rp*kdLuU?SPFql zgoH+rA>a~zKVC$50E)`@}%|{4tUPw4Wgl||_NEnIn^$Y_ag2Q|x z15wQ)f`3%n$JdYN$@g{e8@PQGE`z$oy{Cb=Bt4H<<%BSv}qh514*QSQL;mEryr z_rPF+z0wLuyfXYxY?lN(tPO_DBp#CK5|4yM65j%n#S)*SK_otceG=IEN8?B^sDuR} zAg8io%smnBB*DnjJ3EBwnWa?zB?)@Ah!o}L8P2CjRB%Fw#Mnt}+~g^SY_@?uvTp|Z zVD8vlef_CZry?6?guL+a=xaxn2Qx>Z90x~*fM}EneBU*E0w#Z$5Vi%t17uV%0~89I zLh+d3t^0n#AoRai#GUC4RcZRg$=UC9bl>Rgt)=5?4*)G6aQ81kPn7M2f{? z>~{O>p7fWszy48~3P}|a zg5*i?js+q$qsWp&N1?bQ#|U@j=wo&q8i<$y;0dW`TxkMX!_+yAC?Qsa zlsNGVF%?N>Gjij^L{#u0S8$V+_lBv|wG3-SV!0iC667cpWgthLGQkh5BccpG-4NTK zD%E*!5(&T34j3V*6gEW;>B(PwXnl;(t7 zJ`-|Z0C_q>X-fn*T?-%{4GDrYj-Z2z74S8r-h?Mubwo+#H&EH8n@~On8zc>Cx(wAo z^gI4Uznz4BS55$;6ewUpU0eYIlaA^EW&R`D5p7VgSX$!$0sTNc4VfDip$aqat(wrX zuQI7}gx+o6z7kji!)f@ggs8fn$kS<6PnZg(#GKCvJWC|WY zWQt8P=vSSVN&63_hWt@8G2u(4{Jl;i`9@}+hyyN#G8n$wp)3;9vquLcXy;LIkhK5! z{5Q2+N0u$pa_I<@L?R6O5b{ev2xATqvH<^f#vmE3{ycJZrx0@psi6Q1AhQ)P;`!@Q zkiitvSo|0T1&{lCTk#w;7ugD)q;m5BX8#}93dokSM_(~=yr|YW=~futa?JtW|t?AWj<=g z5-zM7o}Qs_?A47!lOJX_{#mTJ#^5W3vGt_V9?fL6`YhEI>-A=?r0?bVBvDW+Ie2v9)$esfpLxyE zd#uqCU9rX2?%}s3o)_ocUzk3PPsu*=LO<)F*|EC0RlBQauDn@x^jm9X#R^fN#rK+E z1FJ;;v!$6HkHht7mam7(PjHOfEft`D9hmpqZDJ#;IPOFx~a~m9xBSxokn^`;1FB_N%Z-DlUV6)ROwx~zy&exUa153$nDF=>>( z7Y-`^X1SB`vHS>qQ^05HuJ*j0wS!EY3Tf>&!j?0!D30&|Ia%)C4I znSV&#)vsThbGBOKTp9Fe>v@mHBbAjgJIfB=%&#_D^tsOdlYds3zjOBSXA0>iwuTpN z9*y!W+_gD@R$DH4mJAX2Wv7&fj5d4`uxNLr z%3XPD<*cg%&`n6j+%GWRMaJf8=w&IfO32{|E_d#hoez0cz(6riR=ktAj z*Z%DN?!b{15q)>AluK1mI$&a`)|B9{7&gF}(r3fm8@tt`GGC;PyRgnkD?{b?t>rsZ za~{3E()=`fMBNkRhvgL;&0jqH)N$!qK(OHP@OuMu;+AP&ZL5zw9};POMYF+$o*24< zA-*$R!OvBh+E0AYcUxeZS4V|7$aD4s-oQ04`lfs+SFLgs(B|h~k~j9$_CL`+(4%yo zb>N&Qk-@X(t|&`;>QY(br(9?HaeDPshqUa}TL-gh*FU&uEfS~evp!$HzB&Ke9sQk` z9F8Bk%;{rTdTpmd)jeJ3TE`pyHKQg(`CZDK>v>a7E5L2nxR9|^bCfS1-l|fdRoBNw z*es`q^xurDHF$%U;iLiwy>YZ#JfGREk-u#`;o?-Z$IPC-x#sqqto*Xgjm@1UHLWjI z?9VM?)}M$-~CeK&=$7U#S@;9sX52%8$Z1% zZE55PY72ZX-gv*-Jp=buF%zKL0sczm$B^eN{Y%WjadC#46W)eD!LV} zatwX1?;F(G-ZC~TBcJUe&Q(GAsGDMog!StGWc*wgp^ z9^n8b%3W6*Zq;nut26kHLw%&9Th=uVUdoY56Jg?BwLM7-lB;U_rQR(n@2r2fv!wHj zYn4~n(1x`^wdszghvMy*F6pl}aPTM%#^X>U&hKWUW}XP@@@;Twh#sv};_PEoI{!#o z67|KQ&6*?bo|x>>l|A-cJ?HF)Qj^Pig8qki7nL@i=GYX!)o>`)wTk%`5b67(ZLP_~ zD>fWMzLwI^DP#N7K4&}FUJ}|Y3a#~B%WaPF=x%9vb0fd2J36WK(ae;RyPbxc1zCzo z``0*TUoiGPand$fFuiYT^2p-Obfv_SG^V{;0jW^BmUrPa29-CRvRg79Pn}yj&k@ z^QAOsp`pMkD)OS6_x!5P5=KLP`Q7xpUxo2i&*%2vb541bFynS;${(0nR=kzlD0xMm z(U6-a8r%dmH68P0dw=;<$C%vCwTt6QyzGYGGKyQ?Ix6{(6Ka>9?$J1e%ao?Y_!u&}hrtF|k5 zRC7bk_4;h}@1-YHO$3{@V=g9{T;-I8c4(9YPPb|>kBaPCmLBB$wACf%)>I{j537xA z+ApLjWqv%=|M29yCY!^$I6IO4PhF8u4SpCezcj~6?&(P-#islcg^STbTEam4KA8&# zsBN2G#;8o#t6JZ@SjFe-5G9A5)%3o42m8*nc2y2NqRp}{el>Jhe}XR5o*&={rPtsb>CbKtyJQG=da%`>VR zzs-2-j^gQ8JCvu*_+V+G9KUhaqG`D^d>6>gTrz06VaRU>rWzJJoE_9%)Rtz zxBlCpib>C?{U&dJ9mF}YEp>D^w|PwQGCgg(d0wN|jY%0fa$f^mqlGg<=kl7d!)vdN zv-0?^yQ=RjomSQ=y@J)3#_zxVWy0A%r%ucj?hkE$vt(7;(qZBICO-{hjoukK&VJ$Q zuup^dvwwdSvF0fjW1nHWejr`-w-H_sqL1=p*X|r(sPGFVv$KJc`L# z*l7I1rOtu9Y~y>sr583GU1E^bQtOHhwwlN%ogjwfLb+b>$ ze{QJA+uhhN_vE>GC5LWpgO)13{i&aFF<;U0uEolY_l8vDKG3@=ci(i+xunSNE4NQD zAGc$$j%eqBS;zOBcJ$f%`R&Nvw_=~~>L|)S^x$mF!94?v4jf+F`3EN?J$XQ%$bECO zxWE5a*0NuJ3MN!^x81V5UUh3A{$Sg?KVmmOX*b6=%%NfFqY4ufefA4(s4dyhaDG^9 z+2f~ij(2y)dmmqzFimsNCe^S<8&gVOr0%`OK6#(!cj{~K(bLgun$m3h>z?a>Cgkks z!n0>I<3633*fjb0>ctU9%}lNwyQ$le(qb{~@TsooBY*78`Li_qX8N1K3YT+Em}X%2 zHe6A8a_{2w3ye!%j5!w;`{L&VMpk9H+h|-K-)us!`P+%{rHFZMLWX=JWh|2z3*+D)UC= z+-KD*K2MIUd+x;aUUJBJ@PbbLV~y&En4POS&Y0iMT~~MZM3KJ*JuE^yBUH)5Soe1rt@= z-|c^R&p?&Hlv zdu_(*k94tjKKP<7WX}4X^e;ufoiKf*nfra^{L({H#$6dDyrsG4P|EtTV+LDyU5jR$ z$?e$I%4~16IXQEQ`tM6jPL9ghK9pP0ei&QvV6{5q znwi=fGRnsx;lTp}w{^*fJ71ogRPvX{B`5Py#DIeE5Jb0&kyY_Uy?fV6ZCKHq1 zFWIT<=wW%8tJtAZcXHmaYY#phe^yNdFw6^MY+hS3)$LWvk_v)dFy+AtsF@^xMKhHpC2|MosI&DR&E{0&vt4(W_nWQoVcu$Q?9+Xrw&l}CvksqyYbSm+7`D^w z@da&%8*1;U zc;SQ8sWC=o>nq)~3xY3UtD`GF+_@Q2Ido~?3y14p4O4H4TYJ*BDzIe0MYYJ&u7~rl z8W+Y;W4luiyxyn5Q8r953|`3EdSam8#{5-}XN|8789(Q0#jcNWG^O1QnHSd0Q9Uwj z!UZjxS>+abOM|}^v^^0WPx4MEP~9JAUXk01WF^4Y7V)`#f}1r-TJ19-_!K0zmQyS%r%N|S zJ-D`eU*`2=3>~@5gYJD2>4hpa7cVG_I1@vnH!TUU>zC&_^mK-w-ptic&9+mYtWroW zXJevUr|e3BLN(pS>vac?!GVYf+D_+dyy4`@*>C?0deZu>Td&0z4=4?f0vR z(O%Dn)@eM}o3o`Ny5-wLJKuR1J(o;NUwHpWHiiE%OaH~(x?^TDt9Mr&ExWn0qO$dy zMWASfL2%9Yv;K)zk3BL=Eopk;ljVoLKGoOG{h4ZX@q#|9W{i!ZrbBaMg4cE%W0=ijui`@EzWgnuGYV z+O(m+`{bX0=lxkbV#SdIaw~WCJ)oqJ+N5S^5~k>%(1+qYVE2u=8(w5asjs^*E=?sv z%Vb(`-&afer0pl6V{Vj%Cq?3BJQ)>NsMf0$1bI2y}e%0J<+ z?OEzEuzgOT^}JcZkx$afR?Mxbba`r8r|dVidiuxI>@xu33omf3OzUY?7hZhH-ih1wOo6wBI6IXFIu^*l2IIr|5RgW_nqE)|}4f z#?3EVYf8?f+pDCf#mqY>(A&Bxne||9e*c9IHKUkoT0<*5o6UAiNUK^rHN8Qdm7HGH zM-abfgI4m=-zlk@=k+?Dq#Bm&Z-{hr6Z3eihh`>q_gvHt?vCgDx#f_?%M%x^*g2_@ zo}U`)k2kiIzA2~`a30^f=Q9Z&@o| z(P)!nc1!EGCADK`d|YeaN8}Y_nQyPR>4_t&aF@nrs!%P<^!TVo!40FDe4~_Gsw1*m z?fULHv2B2G&wbas6s6f!T$|udFFdl|;m)-zH^(C>JdH%5NoCR=wY{}f$qS0^ruKVR z-&y{pvt(zOSCwnf+J>Q~j_I{a?c)y(RO`Qlp)qPO$0+pi%u!~)`*sDLh=v6K=MtsS z^Gl6UHLa2l_o{sElHUv z*lgIjKS?p`Lbl_YlP7$Qrwfv8M<%ECRZ8zHW~P-Sx;MMoTeb4kR@Ru@sXq z@z!jVTplkpuR78!cCTTT^;W$Gg=3WTTiIIi@vF=>4+(I|T4oX1nC!x)F+0O8*oA*8xxS+P)**q3l`ft${b2Tb-NpPwZ-|+4Cq(Fz_rWI0eHFknutzrH8TZ$<#{r8^N;yY6AV#{l-)cm9R@k#!= zhf=g(-Ac>ssy+0zvgPiy2aR3pVpD^%_g!@9x_C%w*6Dbo_2XHb^HUTxJ`EddHA#^h z8Ez9=e|ce0>6a)gfuXnC#mJJ*s`=&h4UDg_0PwsjUU+U#|G62$QObX$gx-$NGQ;FY zxmgV{;wf@9Om6C^sU`T^C!5DOrphl~+nHsMh6|)K2_yN@LH{*Nzme z@Ah1mDle~n_t!d9&#AW`w4gJ_XS9iV(qJK**3?HCTaOy-#m8A=aTH_O{K!a zxm~qhH4V+9)U)fatDY$RuDw}cVv=+*CbX1uHLygZ!@R+2`m(ObsHeU`>9=BBT0b}_ zO>MU^TAitscHwaULmxMr+?~9W(-nsFpPIj7s(k#zU^%OtrHV=?pDL8(H_?RA7yH-` zOi&xJFq2U>eVgjugi4jg&Gkw{zWUIscRKVvsMlB7)p{mN`$*`}SH;%D|BM_q%wwpo z)m;O^e-yYDOEbezf`#3Y)E=gmCi@JKZ{-}YOTcZX=y_#n< z&+57Hw((Wdi+60DrrdGW#PY+8SsUY(XXH*>G*fPYui^4ROQs(9Eo92$0z(7MR4Ui` zM!f#+N0%m51ihWykNS)g^m_Z~)NLomG;_PP^_CTn@|tHiGG)vJDdpdbv=^9nn)S9B_P?pp2Sz{e8nHH(e{_xcu$@t~lsoGR?{x99C!Ajy zW4S5BsIxY>bGs-geIsv095*S`e-N zVqs3qBbOJ(jmy{$bxZx;Z(MS8(*?JtBm-C7Z}Q7SX1lnbow%}oidO9N_ElG2TzK%| zW%#k0h8dS!-*ndmz0UNX^eRfVPqX%1qYtmxjCX$?bb9a6>e)E)#VgVK#EPcVhMV68 zx?b-Zkooa@S$R?SUfx0RVujSsAk5mN`+d4=smQ;#aiztB+=?Oh<*w=_o!eu& zedYJa9plU=>=fw?-gA7`fxSMCr+1Hh`+3*%*jtCPi#iU*oPBV>XuzI7I@cafP7mSi zi|jMtcW&0){Vip`39%{qTWsAGx2o1J-}V3x+#LJIJKVhe2}YZUB`rl$GtZV(ww&OQJ8A#i_(;n>}z{Z`O)s5J{tTrt!Yj4IoCT1xex;GC`vuHUI-F52EoV|af-wZFktT6aZ zhUtl%D;w@%7wc z{BcgQ!F#0tnc4onr<88v{nO8V*ygp@d1~#)Nuz_@pZ-y0boJI{o#x-@_M1blKliDE z1%SDgH!?r3sDAdmE^_h`Z>H0N!On*okLh=IG7qVnpXpdtw=Va#f6Hg^#H&IF_ zE-(t*`_5e@Vd=*gGhgrBrR=Eg-!B43)muU73?cq8EB zxQ@d%dk@`o8L2<^#X)EL^>aenioVcyJ~BP=+sf~`no|yy&KHilGVahG&0Ax}u1~qv zWj$EVj2+Ev-L~VTO=J7->Pu#hI%%?mJ9K*ncDTJlef5JCXYQP24#x1u;&Kr)sHP9WyVZkEzbl^UZ}UmBb@)PtFf9_ODt$u6#|>&fwv#)3w{>1^c)A zB~3I*)ZMw{{bfrJN0kmm?yz|$>yCeVaIJes-8-uZnV946gZ$r(36)#*(I%_dZes0| zud({xv)?QZGD$g5At?HqXBaSO?Pf;UE4Qg7uJsGj<~xc_+ZvNcr{Rg=1E)3*q-`+m z$euOkj}fBboPCSenBmW>&P{ebf9L(ujOmMCmo2wm5OZGqZtx?o=_7cLH(4p&o+Nq` zx^?RYo%aVHZeRHI!iHB)?$efVr=8fQBp5z9xIuMe9zA{9@s-z2>yP&NzAb)V%7mmxB#8=t>Sl!{+Zlc3)R~W!=VpjG}t}4ra~0v1f8l8V&Ae6?<&;sOmz$ z2#+W#GweZH_nq+K-<^+s8riJ5$GYpRaq8@T%kQq9_d((QC(Qe)rMA$g!>sY^#I*~} zb`CRe(7y1vX@BL7OJ55`%Ciq|8T?Vr>#$v*;*8%H=ERRNe6nZ9z9|zXbT80$yt?mT zW9|1XZmaqm)DMhIHJot2-{v`|mI#TW8 z)%?S*)R;o!1F7Ay9F2Xi4O0x2x3U%nZ}b~@V%FnT`Qt-s$M34RI!B2X_whnz!|o%h zbJl5Hm@v$ue3s3(;H7$^Cv61_{gaO0J)b(9uW~=i@2cmn+CB=O;A{##p`1@|8Ys*F zQ$XS77Lb7C><~I68O_mz6Fp3bs-7Tjui%es%a`YClhGI%a_0KgjEviPO?2FVm`-q8 z?D=$v67dq9-4PGRDj6F;!2yu%=u{d$P*6zYRxmQ)RA3RVouD)&E0`*$>R?*P?6EJ-z4 z+y7>{{}(j>6F$qB33=;+W)p0QQq>A z*$HCoGk@5>lD~+?_6n>Tj@%ZIhkTiY4D;b+SP6CqBsK0O1J$U^XKc+5lY6P$Jk zVs}F9A-(#epW+`R;+J!uY?r9rk5c**{P`(9ng3(d>j_>^q2tpcN_mep@);17hL7cn zNMb%=_n^~LfrGPj#+e#w**7>`s-jea7{KTEEKf@3UzSJG_fvVF6aJ<=U@Tc)9<{84 zWHTy{k-&ljs`zD&0dSf7CGI9_9;}hLQILrmt=DPNUgmbYJsa+kK@wB44_mb1|8vL!XSb?9gQMQ zg>NoUNMe3HFI@;>^H4)dE1e^3&{)Q^U>W$(&rTj*W5@@c1r>-F!o61 z9~BtVrIL6TIA_x77QWK#|OUb|AW)d=tc+*Uuo|F z_jlm#gF4RVu!*|_Xy&t=Ciq5WY)XP?2~YTa@mctMOGbubBDE1P#F>1^W4`GPiYd_@ z(vbXs)mBNYsSv}J3p(y(Nv*(G(%TVOLBwF($+XQ}h0SLcSs4*`52Sa9a3>n|F}~aq zbD{}4so1c{VVKjB9=#*{7=&BV5^@>w-#}*Zfi{>G zjgc|U92+S3M(3*lom~(~6b(P^MbDwEhZi=KmiHG*Lo2!7s634xB?@CX^JW2y`WPoYz5!M{9#bq5J_n_p~5|5 znMXWrFM_!wg+J!!3{kI%49DguTVO4?z z{%~1ksjEfY@`Pf>u6&{EqAqN?k;oBdKRw06$rJ`k^j;F;2z`BwB{oBH2MjSkVpx$C z8fzhOYBK}*P?X5WRibrwLwsO5HmfP2XWsLF%^Rc-qz;qbFC+5iNb_E9+Gf!sZ^)70 zzepWg0Yn>91B~d~PZe1HYawWG^tXllQ~_Bbv5+swH>$=kk^fJH{Ii96_BrthK2vE5YTCf2>{WCrv4X&5b7d&{k;dL?t%xI zf&WEqMo1a-Q*8*D5-mifNE>|?c>a?TVocktdq~y|q}HNrxYk9KAUY0E&+PxExqns) z8K)#hQ>qjoLnNoBp%SDrH4;2OZoWBXf{2N^ZE!J@hHNJoaA!C(33e_a59yf&3nm!q zj0_9c8Ig?mBY>I_#)wDvZg2}zXeDpl!YCnk%@W+g5`1R3g$+1kaSKOq20&(XS)+b* zS+=}jJ4Pb~sp%y-X_5Kw{^U=W_zRnkO5*?}Nd$WYMnf69@)#LqbCoJZ>wtb)A%!B} z9^R&AS$U#KfQM=mS5VRQJ2rG-93W63cAaY&Uxi?U;3gBTh~N%Jg3c~R{BSTTf=;-> zI}iYF?p%Hy7OnylBOR-Oq!3DKaKl7!eV5iHL(yL|uo_!M1$3RLEZf?V^U;&VZa1 zA)AEq2qEsE0$n;y_cL4yq~q)CWER)L4!2+$TXJ;3pty2$bPM3tZw)d}1b=Y8^(nSLteFKeG|VCkvQM!k z`jm*ixPv7&K(q}i1(ZUjVxrchJmTRrnK)pQnENo~gmKp-9LF2tu1wW3bO zZJD~^G;E!U?kDUHX3HdGzxQfd5BZMfa6ra&Br+b^TgI{J32j(7jS-K|xAz=B5i$WK z*?@jy(55is{-tM@bOtj~cO4N~WWhwhe<+;L5XywaGZK*25S5RHOX0ob5&H=I*ZnA( z3Na*Y)AWdJ7|Ci$CJV+aq*NT>XabDy;&8wbZsF*FgNB_#Fmr|R90qvNyPB}(=Dgd~(k)Q)C%^wKa0k&rs0I};`!RDR_08=Hu3(#+8gM9T2ddZd}0F@Btv*g29#8C#4#`GVW}H zEXid+5(r(vdN5z31lFNc+&Q|)nzUBVe2SnzET|NNfm1B9CTvzhTg+;b&G6m>#gsyc zaYnVq?QKAMfv2>_qn+^BLGBOoVzl?6f)m=--%Ds)(?{@)5_uDM4#n;Hz2y~5E>?=& zL1vd&je^MZxNl+;;Qk+2b<;lZ-$scyHRU0dhoZ^GwT6D?M`?_Naln$Mi&z`drU1mM zo}t)x)HJ)0m`iGjJ6jf6lU8#Oh&Q?mOhHYG#16MNl@51$<&wAn%D~)1vB%gaERv78 z2Vjvr(R4t{yN3>lt3`96j*@2kkw#<&Nw%Z;pewQa#g=uZszk2<@=naaKu=L-U{t{v zB1qCL7Fm$|A3zj~@REM)7t;=X7T>(cB7jWHBb`vv;S-Le1#w#++`$8NK!}I9t*jkI zA*ksj`VBYcf2^*e7b(<%R5org0}Xmupm#Xx78vn)NT~+cU=}dXn`Dj+fR32ZJZR!U zk|>iQ3W|WsGcxF=n0#J6oq9i^oQNiilnNyFj>P;CX#kNEUq@O{UnofMRm@iv+*F6X z7V7P;`G=jftPrx32FpZNLRJW}zOq6B zz(d-ro<;q``e;k*6K>jO1*3HpNl}D-%7MCwMW0YtPVnssK#~rK*c}kOLnB0WB-1D+ zA%~9e<^r@xQXllJh)Tf>Kc8u%eP)rny@Gdk++46aHqccs08O$4g&mKq5bC9nMmY5Q z(K8X&$&up-l1vy06UY%{*Amj&2yWUH5HCR>eIy3B5F4%2zyJUiSu}AN4iJOgNWK=N zVG;vg2$rpskhLJjgnTxn)j@%fk^?COP$k9SoLVN?Aq96mjuoXQpW5?05VeHCbG=C=r<)`%nC3(P~sPy$V`h%d(GuHhC7qKv38dq^n8=0*c?=7e=BGAB$E z4h)xO-}B8H6{tH0=Mj?z#LqhZY_Q^H!0-9svSn1G9%MYHac_%QY!jix$QWP|+u1kb z3G9;^*YW#e9nk#5o&+}+Z20G<58T|QcR%%q#QQj$pZSppY(RWMd>P#KcYFc;{b7$e zn8e-@Jqx_|0c}V_a#-^PgjZsm!G06+3So5AzNigQx&#=FgVjYiI+9u3!4xGWo8E|< zEBFdL%(WSDyXo1l^pkIksGxR45{wcd4j~t1A_Dr+(j1{rh~rR@LhKr7KY2J?f!n~` zgip^zsSB_+!5Y+Bu;ZKmckxY^6!fs?Wc^WlAsJ?Z{HjBH@i>}{`0bD*O!gxANJG%{ z4{3=CNVht)Eb6L6%^!(QkcLP`Tv!kK1>@3EJjnD0TBt_T8XhnRy*Y%UsB`i@&yK4~PP(CZa8PDJcb%X>4*g9OS_g-g_Z+S+?ey(8h?bM-(|3 zC6r^#%r)rItoUt!F=xb|K>;zEumjpB)`WtVAC0a-w?@&;$7k#Ymx5ct1V3UOz8qN+ zf_@B!9R&m=w9}MFQikGTC?4MqpYMp#$YCDBqBdO%<>5{Xq%r|)rr|LQAQvJX zh6*x!TA9O|kVBIQ@*`r3(3q1<)8n-#kr`k~Gf@QZD~ZL2VVF&6x&-his0Uz z5@S;%aD$O^M<7B^d(E(jFXt-@cM*Ht##Is5;0ZU^cqk3cyV1ImJK|l>;k}h5rU2EE zy`gkgCD{f@G0V$X-8%4rKhi>)YPRz;!bMnDH680J3Cgd#}QQ8bhk5|$C90|i2_uW2HV0t?VcMOHfE zE-D>S1HFdq#VSeDU`36nWX#G2&KFs!M8qZJisC^%V>|u$V`4i4_=93Q7xC$dgRDi$ zfWD4Qrih9l5Dki`9fnHVuR}{yMDJvyCJ?Mh(Jkb?tPLSZ(85GVe)tzVbH(JVaqvnU z*l7dVa)zp8$&N)bpPWs=@TGTubQQ@1c3-zLA_CT9R^aQHuxz#tEt_%0gak+pAX+qI zqII%$d|2A)Bk1_XpNxkyxnfu+`5ZAE7MRfT854e1pN5}^jnH>*z}jx0`ZS3kxTzJH zeHbgEYQQU9fT_aT&?E##bHG*EwioVTBh^0Rj}iT4%O^INgNn!*H32!aB?dDhEkN`* zurLcUpAKJj%1Zd1LO^c7UJ{31s3UP#Ww?47ZWuHO8P5tJGM+$&J1xV#l;M=YE|KwU z03y?d%5WECxEdL50CbsTyy*auX~Sf={W9Eau!aT%^^P*gM+Wg_P$EEFA|A1PNI<6m zH;I6*0yLR`Zpu=eQ>0Mz30ylsrUWz-B$|Zc0h&nQQe?Ob0FgA;07TO42V3JLvvm%RgIIj?tojAB?iWmg41?Yig!ih$ zygm669KxW_Hi;kVi{khZ4Jg48n3cXO(fioshm1o$2;KuDeNvl1NmF^ltKC21AZVY& zFDXm%V)KtU?tbJ$;y*A5Izf8j7v+pTmxy2VL(+pDzm|Ta7*Hn3N1Ez}6d_4PzMM`X ziB#c|C)5cPna{5n@-g)usnDC-!6A~orDffh_2y&n)%1` z@IRh~@A=HT^ig-85b}ZZp3l4cAzKt;XwdT=azCWm1kRf$O$!wz^i=ljckkE5dp={? z6P7*-FOeGQ)8;=t)$YDJJXlgA$#e6vBVhmT^-II425j>4MDNbP_1|Cdcn5`1XxY zgWZk-w9){h_f}$Sx#=?Q*z2X-qcD#4gyK+{3Y0+jg+Uqg_CokY6E}4Vn#(~42T+j= z`n4yPwr%gu809MMcjY9l0w~$1XA7cWdFnm*MeX+E^WU=LC`UvK`5|=m7kh`oi1{cH z3B^Gpyk7q&L6WBD8~Ef4`4YMRRl4B}<6pk*I%%r$6hgdzNcSQb2BFdAUrDzI4DgV2 zze58(_&CFt{eK|cY)M7f#A*>6{o4WJUo5b>#>P|hCh6->VbAsT4A$d?M1-=fJpi>lHF!R8~S{N9-Rh%bohF}_>Ttd$^;(?D*)|m2}}b#lM*_N0-;O-FNI?%u@XER zAPN=X5d^YCBVjozz)S>_i(9Zd`ffbT=PhA9lLfMF05eTCtP&e#QGq6yz@z2=84$rn zvW%~vkPCBO9hgR=^#M&tVh2lvMqK{j%ubkQ!de}A=$Z}dkZ7@6M{sj|fuPeU;zfd( zm}~QEi>zTd3~LC^Y}f=-E3#%IUy(H$zyp#4NZ2vvARny3Yr=l^VCXYpaV(JzuArL{ zL(f8;r~n>oUn~}M(j)r_zS8-MMD9(of^Nl_R*1E}87iTfP`u_1%0+4YbEtwk95Si~ zuR3jgnV_2vi=0qLv{sP|te4KNac3QvS&N<7P6^)r0$%0pr!S*_s3Zf49&cw`3Wx-)~y;B28!g&f6 zFR_CMpmLa%C5lNy+=?&s*}7E-_9wnk_T z2#P{21Lcs5`S>~`B>uR?5~wm0cW}glc!_yfkSil&DkSA#;WiZwxUB&r!VPh> zVU<&pTPSFjha@aGIy0gYV&Us7xot=frK{m+JBtHn;>&@j{DHU=s5GB}J0T?=ETxx74wIiP-H=%;e67XRor4&I^UHyM^JxNkhcns zyI{67{!Ap#L`q5j-)qO;O25cL2Ze%wlQjc(C-i2p$hitC_^%Q-dUm zHxzBEL=*KTcJV--V7CXgFEA19uo9H;N8^z!V8<{xMa_su@*?=A6v<3@zeYvSMT;3D zSyYtrLk0NJYr94gj&DV3BUE38tM9f!5N(dJdIEy@inuduR7NZ?uHnzb4ieF3EX#W% z$GEc19Ksn_4w(|pUQ2MWt+9k>n-%gLL|q}aXFK|xAC09Y0syK?7omUQ0W~037D3~N zq8JcBlF_tldlsQyT!=>Qc}V{Q2altV6sQYEJ@{`d^iN7Y0|@5TfX3MN24SH$ftE{r zg5bp}X#XP{fwR$mm@+;OP9`!EP9cmnZ6=}f`LO+j{1HsF88QxLve-mCQb*7^7UT!@ zOq!TGs4*MZE$Eodh~EpO;gRZsjya5Y7Z?QzI+iiwC(sb!&xrSi^eCSx;NtUG_-rP= zRNc4$4&D`j1xTm^Ap}A+q3eOV!Sc6+|FDTi=m$O^)6H&&9-$TY8gh!&KUDPoc zz!sw&8O*oD_oCJSi-iJ&28+<9hgdzGXul=hSUy~Ch=gv9Fl~qtQz1Lz;MN2H;AEBu zSQRid1oIN2fE?Ueli0q5$Xi!{pNM=GHQGFVs4@rw{3jieCft)uR2hg6_H-*OQazES zMtT@m-1HFwU8AKZsuNgeNtA(NYxQ3k0%!iM!RE#EX|KktHG!7(>J-?X6}<;5fJdm{ z3z=wt7c=;AmQdG?i7#eR-BhS<>i7zEstZ&18Qi&Bp&pTryU;NgIEBc_kWwq5(oG)` z3U`Bl(CSWSTvG2H@lS5H(|Mu^39Jd$n!6(dlS z5h@aLnb((yqcT~-f{ew=WVULezKDguUHFefh>0NZXxL74{t_3YhG@V>6e42Ve=Y-|!Fk5=QW)7B&FF)FTu~zJMe)UBR90@JLIcUH@*sB1NZvjKQw&{^7{B&iqwB0ijx2kR!{fvbBT^|-h- z{QoFq9YBvU=@vOrr=~p8zTytj`~rSuBMZm|0t0OA<9bEg>zEPDLlLX}FudtlyliPo6PAEMh@Dov}|polZsk ziYE94r)&O4{DPzN$o#T_Q!oLbEdwVL{fG=;CV|*C9^9X4`-N@SaEtLUDn$+O?-}MO zV;Ji9z^MI440ESbYY2u#=u5ec^2|rJ_7zh zPX^V-t=X`BNLV`-6Dfy1NGKbc*~}cXSI6#yATq94sG~fM^Wg~heb^wh9S^;b0u1id zBXw|Fbz^%r2nKLY)B(LZ$=S>~Bzut~Dg!*|vbt_9A&ky+sv`_-(2yN;4ewPAq#*9B zrc~(BpyNaePL}g8m<(i)a*0L@NIqTv6DGs>L0z|!pc5F429SSACvo~8#0S-nsH;c> z$NvTEHDN^01is_W`hvIgyca5h8;KBwD%=m#X82blXmy60oA+EnsQ|a;fdt75O4t&^ zl9|9Xr?=@tPDM4Az~(~OS-AvUDVILG-`6X88mkytKUDcgwWD0a1x3feZXBt#@4aGaY1Jv zV(h@!It+Z!m3JyIcIU!nMUfi#|DAOO60GTkH0p4&TSfF1(kA1CG!mp0()xjn0ii6R z4P5RAVi^frftg^&&&w6k22*-P1vKiNCE5JzFlW^H3+GY=`EnS*#F$FZsl->7G+oT7 z^Rz_TV4x40ppd4ZoQZk?#3xCA&;ZBM;F8Vy$4!+`UC0dVH6At|STKzOEP%neJi>>; z_!2=hJPZxk0ixq!91>!p0wP)GAvJ0XM#g+vqRIfkkbZnV4ON9`eJK{kCs&*lh=zsn z2^kZOS)3H5xWB6yLsBuuRtzdaR!&+Hl&peE2FnXgV!=dG0aB_BH-!*G6V1(gix~oB2Ui|=b@npO|TnEMAw0pMW{>XKC-zWI*k=Z6LgQ| z>j=7M!##rTIWT|fUdA6R==SHU3%XbF8FAfc2u>u8fYW@q869dCf}2}{ zM)(q9u?th-P@kaT3^Dvg6yoztai{V4a#JL=)N&w^xHSVQA!9pyo+X^)lAs}ibP$8j zqvOlrhPVn!1xS>P%yJ%#by1jZo^bqNSR4sv;%US>m`G6HEmSua+O331Gg{fAmcWI* zgT%7dm$;%`P#~7033FAfCGJ+D61Zs`@WmBG!_q%?P#<7Xe{%fz5T_8?i{zUqZSJtDczXu3^*MQa|1IpH$W9t;Xo4*17d>sA`2c-@11DoS!Cgg zJVh3Kf&{6?- ztdPec8ptCSZ?Lw-*U|sVB<>`!U{ORLw^k7}_A$P-S^>L-PA}os=#n5~qYw1GMb-p8 zaJhtf8?)x&_O1!JLPu2!jMhrSoG@peZmI4a%$g6UAB&-K#GDM(bxj|*%mhiGzS7wb zJ{5Q7;qzITvny`ZdnSJkNCX@hM=vM=MT;D-dnfJ#u~he&u>sAWrMaV${;mXj9zGR= z4Cb?Xmk`0io#2)uBLS@dLti3UAds%tIH}-fl|7So6_r4K9zO%V7pkQCMd{*Nxz~I$^4QR+si-btDgqbOnb0!iY(D3=@vP{lE6!JwB@HT>PF%CS(GE9VBYhC=;D( zMpI2RwuwXykdO!gVhI;5m>>{ABgAAvkOG2}0GsWAZ7KHjSTE=FVy#tAwF%w{DDhGi zNWCCOMLjBGyr7;^&}!cAv)0~wCS26h%kPi((}5@Jve)%l&wAGFdDa>V5_FQAyqjY0 zlcREOWTS9=>_tdYOl`{Ts@rV>c4nno-l3rF}? zOV?Wq!YjT=kqP$70rZZ@7fB0C&{DG|PP1Bz*qoo(V026`NU~aM3SPKY6jWaqYHh_VmdNX|r$U`1FTx8WYz>bQbC39z}%ciD}TLacjtEC7{ zUq-&2Q*LVJuT8*klp^cqf?J`!qBK7TvND%cU zn%TY_E@Z6wef&c-UHf%TH~gdP&FRPbtxjQXRz=-};!c%`2*tmL(jSCS7}`8y)pF7^ zr-qGH#UvwJPAla)Dywx`rBz#GR@7NjYpeyb5f`*7N(GP8gECI!5i zbuITsCovgpV4`53ml2PxH>1r5am9PJ5Or%q=tYP+e0ZWh68~s9TJa8}{XST;^zIV9 z{r5N1?Y-RNYO2MlkTRa@iT3^$_=Mn_?i*~-4Z(b16PE%-3!HC(Ygx@cE#sOE_2*%}kD_b2CU%^k;GmjhOu4jWT*b0ml_^XT>&3@XzVGgZB zNTo)&KL?7`m#ype?d-}F?0|LE_)rglIf`aCbTqLcv>iHPKTeNB-;g<;k;oh+Nnwt^ z6QU9ZEFN9avNUh(XM*RynYw=F?7uVgLjLNsL?goKA5+6CJ`;XObux^VF9=WM2#UVE z87uu*h)MBBqa%DG%bY@Ck~IaNm=I*n(^jo;NAy?enUm<2*BG4)2V}%C(j+xMn_35f z3pH318#xS~y2zY3JABEAo0j9%e6dW^%$PMbFZA(>_tXfyy|u*VnU{X4F8Mi0iX=R9 zI?NMp6xpBBdYrQoY8xRObw6K+W0Cbi#UeSKTj?Xq;)*(B)#ubrvDS%U>n7<7@YUJg zXCoh=Ksj+yXbar@(**8Xc&X;TaM$P*DEDKhkGx`Z$g-8_>(}+;vC3tvx?b`*9FM&; z{vn!e^Vq84{*m=&mCIwNhTYz_g=<)?+C|V)X6O~R6T^|-B(rvrv;PCz8dLnC+1k)r zY!6!%szr(zwuU6pGC5ldUZGWTp8kqf5H{bo)=v%Ssf-sVi}(oAntM(9&Ct1gwDalP|Ay!YM&UU-Y}!q>V!gcq(< zyihcZt=746s`I{7a%z#aP6jfoQ;n}3(~s`6?h%q;-aKBKwxf4-c7fC2>+cb!IEqnJ zS*%-SG#po~24bUKzB#x-Qy)H1+Yssjt1Lhcj~@CF=viLXxJ<~F!;mg4KJ z@O9WrMr^(?c*WDRm{$1qRKYD|>an09whe}TqgZ5LU0A&6Q8Dj5U$HwPD=sfnU%31= z!e+@sChnihhVp{B$T3vF-PKU42GM(Lvhnt5I$|iDAXM||>g5ve~;h!5h0xn)3fhOanAAK|nuq_>IW>)F}O(Oejet zFJ#rP^miaoEdxZONLN7kLPilE;bpARIz7k=Jhh7%KY~4a{lb!mrB{|!E$0J6Ba5?= zINfFNWI!E@hNjx}5Vc}^e3C&#>4_34RYhvi>WkmE(_@LEmJj9{*}#zLWO~o;%A73) zo9fMf9qOvN+!erx5=8TOy0Ajh6i~Klpx(v^@RS^UnCp zl-OFDXH5>9`}_0DmXhcVMV|?0n8AcK^jh&VFo!H7@~M=og=@*=V7%?u;+oN5l^2nO zcZ;`Yg!B}4!OdqD`eZc@mG24{v&anXG`VPQ6f!KFZi?g%!)3VHIz||ms;96W`>4r# zlKHZvcbPw0n1Ni2*%DruW0f~plZ&kJ)0m)Um@R68T9x6o%4-Uq%h`&DH6y&@bJfRQ zX+6ps@3F4&v03W3%JX7p(p#McvC8lmMKBZMhg)OvW3rWa*pIz$u%9=+i2WpgG~1w% zgtFJqOB=26Ro3LP(9(v`(&rq0j5htczOSvsy~c15w{H z#?*0d zc5QdKw)4<@ZNy zrzzX?0ZzX4u5G1ji@LV;uI+Z$mhE@q{u!IjcN=T_Q&h@>S>b5EY1mFyesiz|m2C|+ zUFP4p;jUyaQkUvS*mT?r(jC8>v1z}Zu3rngNjk=}*!0(d>`-gJ?XK-?#s~fNT5S4j zm=2}!@+3Cx_cR(e+V&wfUB21qxahbM*LI6*>vU~l_`R;BOxAQ;KI+F$J3rcZF;F6dV7c#Ir$)4tEMo zul=sWru}|%s$)9=#B1CaVd$3m9yT5B%Wr8dxlGTY66%h8_AK&?|L6doQosv9viv}v zXCn~zk^F9?_jo->gp2oKe&^%2oBpE0sP9$smnn(%scpErcHaDX;ZoXFd`OPpC4k6D z$9?AEBNEbapH_TCzB%sGj?cZ|MtqX6dptjuKh!<$^GiJP`}y35&+>jgoABAx&*wRO zoI8hg33uUhF9^`NqbFD2Ff%-7FQ|&=^&VmNg2=efeo1FoqL0YqZNgWFIaKbyil&^( z_xSH0Dfd6jZZ$D9#!j_;BtPvVJA=+o`&@8{&sf(-FkgF!CYHqie!no{bM+xUiw^Nw z)z9Z}nnrW3?ytX9J9Bo!oThWmmK;1DRi4GO>f@SMwoihBlKA|Pd}?Pcm|s8dik7CC z;du+@*M?_aF1I*eeQoW+IZe&@oSE-&8hX;4aM`?B5^QGEwXUzD`D0Uqs0g^ zKU-35K+h6APV}n6v*xvi>>OAs4!KF4%ijpxqO^W?zOY$k%4Uw zH))-#+RM=oyo!%_=-Max%xsu<#eBi})s0Panw#x{OIYCto`EP|&1rVEMgs9$v5SwW zH&Rp(kYC-vDzEOPo4>8c?8E7eY+@pC0~B&Yo+1>p}5R4b|!|0=@VNLuns0ZQq# zXI|diEbg!RE!Ume%p5K*K{fmeX@fCquaz-Pb! zU?ngH*b1Bq{0gWC-T{sQHULwA7lH2p9l%0hA20-13rql>1I`5Q2Id1F0w)2t0G9!; z0T%#|0?U9e0WYuu7zuO%Il%3}OyCV*DDXqzVqiN^0Q?tl4e&9L2AIG_z*9g7_zf@* zhylj|{{~zF>;#H|2Y_pV13(JU4wM5=0N(N7!1=%G$R=1pU+0ANnSoP^nf*@Jlw<~f-6 zVcv(?jM?CY zWBxnl_c6bZxeId_<_OFYm=9q-g!u!^A7Flt`8j4PW-8_?%vG2bm=&1anBADCVV;Kh zYs_C`UV(W9=DV2hVjhcmEapv^H(^f2oQnAp=1Z90#r!U2CuS#RD`qR^UoiiIXoC`0PQ;vu`8?+Hm}g<0g?SI=J(vqH7hryb`4Q%D%;A`~V%~~bi&=~LI_B$`7h+zB z`55M7nAc%mhuMeOhbf$)6bJxyKn73^AE*R!fw@2yFbyaI76Cq>3aNi6?#VMqnLV78rkpeGFf%l}qUsB*9De#FDctHyN zJ%v7G@yQs`qT)Fy?#lA`_{&ELVmi9j+i3>XBQ0HgxP0xo~`CMElPDJcW^ zrSkLJzcl+d@SxwIgMR5>^Bep%zaf9;&-gokYE(FC*sx4~NAo+z{vB)ovJUzkchK+n zulb$uHNWh?^LOIk`SVEorwpLo)6xbG95hIpQ<_YgMNpez|AyMXqwL=>`zLry{0R;d ze-1t!)4{7_9)#XQoCl%%5a-vR|M;&%KOIobpPYGu%wuE@N(8E8be?}XH1vqn z)qKxXA$8`V&x*GjYvqA9qw~Z%!dO!>MG4sGRGERz31Cx|i^EKnKiHg*X-y&fl^UB9 z6gD?V_GYY)ythZoj@{eC4)-k*L1$;8)-e;hwH}p=e(cPjk8}@;^!bf-F~OrW=ulM> zm65tR&HSk6UBN@QT^Vbci-+{#-v|v~*ckj;G%Q>E{{RJ-F~C12Q-4$8A!1*OYIJ^E zkZ)5!&)aUhM}01ZjvF{CqOHY^XR!D~|vNp7dYe`UEWmucdDu$z+bY84noQKjvA9PDAN7pL(Qbbnw zY-cScJ{v^FRL)oSJch+uo6XC$io|!314g(a8cwy(sg?Xm1V8G17eG2USzGk3yXJibktB& z`9->TR`7(b_maC}$;I1Slgy{1qY>^jR&|nu=!f1TrCXvpyHYnM_dPR3@MhCNdPD_? zeBH28DpPv?i4W?Cr~Dvj(vaoOI2O$EE^&6`(>#4SEY;j^pYse&Em zEmFjSP3o3Fns+^nABEkuQUi0tz4CXZ$PBb_DXrG@gg@rn_Si~jD)Q)RO5rowc4E-2 z+qPpS@R&Pr+7uRD;4^!B-l7+$ZLzy4oyp-aNbi3wgE2Z^aQWqicsG{=pHZ}Gx^;`R z0SrXO9KCwRH?AXx3KRkijOzb5 z2QWIHFb^;RuoRJmVm*)!~(T9+2_9M#`evG#BL##b?5B#ks)-?-)i)^3nIFZz&lizfR2@N+ z~H}Po$;e7==;&L(!#5c-l$Ur=bYi^c(B${wW@|Jf$IUNW} z&+Q}oGs5|i{i(}x?Ueva1J(+x2aFC&=B~{9Bfk}f25Qyn0a+d=DB5b{{6|-@mN%o1{l-1v?H(k2-Y-8oArxEhi19_`T1?@om4dBg+Z7 zyNJiCWE7GM)*qB5o4G;Fw|RC4DW{P#b033JxEG7j(GBg6H1+hIzc1t5w=M30$juc0 zU$z+?kK29_t9okD5u{Y>MP9ocN4I2vtpHmD;TjPHto3tZLQhQNm=Uc})4eq^H+(>< zWv&TejjmBMy)`mHd>~VK%RSQ3HA)|8jm-8Q$W`7&SY@iUM&=qk%dCW~9#A!0BQ<98ypwMOP(l9!s9Vcucqt!87_%b>kQy&_P>VpXkK zGwd~MmKvZV62f{&#%}WybTlfghhzj_omteUKJgIQIgAnaNnu62Q(3J0ZkAYd_X)-K zsRY7|r0bE!-9qPM!GP^i8DTE!i%2<)&ifw{G2k&P4hU1NH?_010zrIXs@mIDv}nz- zeWN9g0PqMU06fg!yHeAe7U36O(ff+%MVL=3?s2{H;gumhe_2wntDDQU$WX41mkRI# z^^F+#mO*=c)|GziJg!eMZ>gqT5x#ole1^N?8ZPAG>Mir`8hn>d68e}PtgMfe+=>Ry z5Lth2knjky;ysGlW0|Qu%$qk%hXPi&oimNkePm65Dkd3~OCIgNez8_c0tl6fV#jqC zN2|R`>!-}C6IymI{-tJ{N)EY64rHOw(t=HWYNp-()atggC5vz;!_NA{li2M~#^3RW6xI|y~~e69f$#H{sq zOMSdgAqZ6hMvAU$wyPl?M)WT%uB`QI>j-1ryjFq|sL<%lyos5}t@Xv5jq7^|B9^v0 zu*CTRIqgtbAHs?8}?B?!$oS1M0XUTLZZDBg12LTP~;k+jM-qA$r@=dN2+ zpc`(H`cTGuDC0U+mrg#ba^8TYe|t(83X?D43DOi$;l@aMFg4Jf=iMcFm^Y{TP@}{c@8{i)bjVO9JVo8aZIH-Ymlhq5^e6L7n-6tb9tXyM;1o$6QmPu(%iB z?CX~HuWxa$5xqp_MQw@L0+j)~RW-)WC5Xa=?3maCrsBsGg^7V`e+k)ik_z>#G@M)s zIh`WyB4-<0Kcp_X<7IYiBgt4N_t#r%1$WU~N`(G&dux)v$Xu`6T?LT!oQyVe>9_?? z$u5$I`EuF@$RcP!!^}L=W~qf#<}lNI<#c*4`aX%TTG@BHd+;RmVfPF}X@0;cLMC`X&`K z_l>qR{l$9pe8&w6jTN<>t6F>2?aXgtqF6=4D*`B5Z-2R3Wy+GDBgK9K(8f~Tgc9VB@g zKqM*ykeQDrHKga(RPOrNt`Zy97MN&PtWXCS$p> zEx7DAk;nb28EvFCGkk$PXU!!s?(L(tNP#PSU)L-bL!#d_pn@~@~jmD#&o zqdjt9;B~{S=q5f9Qkk*KrS^|JZif~#HW4p1Uv%VV*({-|g$%4kdOlB=lI`4*$bmt| z+Qnel+`>F&MXwh!{@d1|{nlYdXOG?>8B}j3Zjjh}zU28f8QC-JiRS0b7&6(BS(fQe zFeb;8}#paQ`%g%HbI^2rO^UK&VJffzG-^13(Q83Q)YWr#*(YY+4;G_ z-bDbZvcc+$Z?Nux%S?=pOmQ06=u~U3G^f0=X#{YVlN43cpDgEyWG5f%g0(p3BbuHA zR7><9q@(No*>iYJk6L6~&8(IbZBOybbM!vCEpKtF=b*rVJagqw94}+7xn$BpC&Pa z!Oi{4{LGs~>RbWYzxDhqEHdS1l;ZKat8)jU<*UAV(QBu9BKcU+R6Hy-|K?=Z7a{qWqWQJemT>NHHc_H>k=nW6D}~6l!E2j%(Q!c|4%Fo6KLS8B6&!NyRVo zcHAqxW4ldzWv(&q*(_FX`yI?7sr{Oy3B8X>iKQUI=9H!2DR7d$#Gs_aUq}$Z7vh3Q%ke5H zet}*j_l7VrnSRRv99c^TG9%A6+O`m`_z5F=G(BBy=p?i!)yy_u0n6)TyWUzSYv<4> zatighq^@ecewAAPZIg|_b!u~2B=M(araf72t`fJpZA#f>g|2QNGCEf2<0vj6;&5-3 zq-*ZvN*ON6C>yZ1hfYq`tlD*g>ic-3T`s2s=UD|GNWr+JG8jhy#2auczc!hWk;j8t z%bKyHn4*T$72XtTd$&C(LmjtUDT-*jN$Oy9-X!H^t8klL^r&x0?+UP{u5(SMFBOxo z(H51;6Y){ml+##&-`pfPLe=JDu$y75mG^LU>i4VEL5aE7MG}W~6WPd6XaO6N?~$-` zlVC@0hk+o@>xS*^`Lf>ZRJgWL)4A?ZGFO|)Ty`PKMyjo(rGyTQ&Q2Mg<*uPlm6!Rc z-h{eUHBc@43kuWfE+Bmw;!XOvQs0MoYri7wbh8KH>Cv*2_L`~~I?u>~A?na%!sQ^k(#8Is5kb-uAZGWqLN z2q8z==ub-fwBA&e>qU>}R#kb*Y8NY^?zC|10*J-_LWStaH+Kp-V9!vz-8aNeD;A~8 zM!pzmtUFx|i|aP`L%J`H^tUzAW#aSCK)UZxqz{&jPSv*m1f&m+{fL_PM{%;fJ$b9D zr0jd>><>cj6ouS%TN5yq9*iUEe>9?G8u*V#6vvr|5NBEfp8ougCeF0jm5HSIXCcMZ zSfld0Rn@VOg9g<~2cb#c({k03T#M|v%TK1ca*H%7FiN9gxp?vuJs0s)KRYZU{vH`0 z=T9y0)pz zKJ?dJuI)Y7_8^)!`s-+ptOJyDfag-zc8zOmN9RI^yUVq0c5Uytw*9Vc)X7eaPhFef zL8l^Ps~3aI@o>o#?pS{&aam?SiJ+bDHFpBlJvW)iwxWyRO;Vb@|NZ zIktv{r&c*c!NLvIfbK^#PvqE1%k6))tYdLPMA%5XF>95=7*)Xtt6o>?2d zwvhr}KCiZEj%dPYyM9_pd_~QqrBO6F8n1QYx@sIs`6G<74Vo~Qx6Esp%@xm?4icF(n zg>xKEQ>2vky@4-(l;-9qXK?`tAd$wz|8T!j&o|c;nLlUF?7-}}T9LdzH1p~JC}1@- zuVGF=zeePEH#IG2@<;>O{`2NHx763qn>BCF{BQsjtOaN$U5?M3CO3dIF+_)6Q^3|~ zO5ACZ^2=-*rAPJJ%W0T}z=gmhpbn64&dPe@PjJ|e=gNX*V~4o=?X3G`CF}`xS-$9U z^-+R2J6p`m(^0o2Z{^WJo(zDh%ma@B^+#-Uc1pn&HQpKtTIc5%bJ%SS_`Q2UsMnODFK#Ak}uze`X* z8)!c_+@0^p_m(_Sp22}fqz1u=T=C%KrYKw zxqBdpXcBu1ta<|av7MpLV>|9ms$3P4SJbkneV@7jBm6)1LmKK$j+SBeqtXvbk-Nv_ zieXI%a$1nuZND>3e-r&z*$R`ku_mZnRCk!0+jpp&E5koBr^r%!bq`;;pzMHeq&e0f z`TVTwk|S>!(Q*4D2U3kyKbMb}a+PlPDB%$DWCgKyvmt zHuZl1qhAXlN)~{KoQe6c`{O&*7@sz0Pfo`CH!)r z6!&hvGqLbb1DHys-RK#XIs*G5fV!n^^9&V9PXAm01f<=INdo@WKqc^v?!@xbMJ}@NGaD?mfhp^ri!#DD9`7%v3nNe+f{6`(^6G zq|e^~fcdnInCZX`Ko#!QY~%-DYv`Tr;R)ARjJz}b9%ocx)x`Y#7g#{COS+S-3T zFbeno5FZ5kF9nz;rmZLc(byLQ=i&Yn`Lm$$UkRL!`+iKp=Ne!v?*An|)a9Q79OEga zD#KFG!M+gq4&VPs{%~f0J#Z@SyD$acD}gb%-zPrPcmHJotAwWB$ zzDs#70hlA)(rk)+&k>{pNBhy`}deqUK6+o_b0@c_M8kH?aA;bd3F1@;69h{ zPuuMe@AcE^)9%C+e6<7RxZfkbwEqm?MBG2K+kYwU^KrjoxBu0+VT5T9VhTM)f$_LM zBfhl1(9AIEzr}9Al!6}UenzTmSK zpx>t5Vz>WwxG%*0n%({jaG!Aw z_%7`~4ama%L%aPK;V#0x-ERN6xN~v;7pAn=YM>JL$HbTRKT`jH%5MMJgb5P z4JgAMBfg|J9mvN0Z+81H!CiuTr``Syxbtv7fSC^5094^VKzwP>BlZ6$?DoH$FeelK zmzYVw^}s0HZxdhI<5J*w+&{6~e=+X!aKB);|CP8;$NdLP!RH!aEbc!OU)ujj{r_3J z{p$&HD&c>JDfnIqjKTc@@umGQ15U#IbG!YQ;l2R(t9JX($9*R5M=*x~Yk>*4zxbN| zzlHRryfc9u!v80x7gzy|#QhfEr977a$Kn3*LH)nSZvT0F5AppzOewDkT!i~m;!ArT zssBG?xBnc%e2ehE#T0zC1Le4Ti7)Lx12_@)zuWD<6!-bKciHWKHSTZYeh70g5Cz8L z{+#&I{zvNn-FExWBFrg-|23wBj{u`_ze{{+|L+4Q;J(Rj{~zEUf%_%9{jb7(2JTMG zL4XB}!~GZHOMQ;i|DU(p{|dsKM)-R$CBIcb1@4cCFZgu&|E+fWJN^H4yZsjs<}AWL zhG_unfQh*KJQ-Y{)J1k|W=Y$k*#?TbBI8(g7qf=bX{sFXC%@hM*aF)1rNr4&6QC5iYeh<}{K&l;MND)9##oibD6*JY&mBz|&cN`b`B zKPqLg#7{parAx)1H-FZGrlvWw!U6qIZeW(Yn(Jwqf7Sd2t@8u3?AsN%sDdS7cFoQ{eKM;MvKA{R*cBO>-LO z%nb9zX&ALc*Ub|5w5zMV6HfbVX+f(^2?ugwd!}u*=JK{cIAB$$BLH%oei-z2ArdoqD_vO@0iv-DOYdNBQgN(N03CfvNBTI{1>t>ZWQ{)D@lr0>b%gux= z2&OSKaWh>B;p#ZspAAe$1*i45eZls-VEaM3{tq&^31}!6zykTlpfL%Q0+m2DFb#MK zIOUG?u$ZXO%Jp zIC~~k0Y>N9D1TzN(pa3L)( z1{Y>n53Ba$fz>7nc9(fTNs{%vX->{mVy3WkDrO5iAU`C|J@V%-Wx+ZYH3(v6#l=tS z3`=9v6~ecV8qW|n(m_O070rRb7ixM1Jm(vx(mf?+{nv3KK#X57E&ul5N zT5`?Gbd$$j%%w#w$48cWjx|;dCn38|-1E&@^Yn0t6sFq=vcUG4zTln`Xb)m(f1PY? zJX#eQA%a^sD6A4E*J|-w*ZM-AdoK|+g6ZCCGrhcgxG#KmdmsIAGFOd;7gJZibxnHc zOZpFwd}W#LBVSo|O6JIXq{Wu{tnw1#B}X=uQqn=;5eUQHNbX#STb@Tolo9E$VUdTG zh^&uSROpGZVi9Hw2d5!n@DbRWhAdlO@7s|*%X>HReL6D4k_NQrw-%>|x&`xAOO}bq zAKo7ImKVsSvi7s8F%qyNS)(#ygQShk*r>5#;}tyJWPB=3;6stDP8_H9MOu#PX9S=so`jOXX#TQMsa-7iof>R-o}(2UaX z0CO7eA?j>i1V8<jiHy#@>1zZ zV}(*DXLOgBQVQ59nrj$a8K)bd7QRq4`_f(a8hS64*ko&I)Rj^CO zM`0#9|6z9i@*tqjKldBt|2)Yj=3nLHuNHPtLAX}h`J994D@eGn8Ju|7G7H(3y2Rdf zt8|_x52)L`>&V)JK&l$4G8n0-pr`Azw8)!YvpNrgP|O-rsP3T06tkQ$e{?=A#1z`I zQU1hE49m!;lw74+!Vct`)4J6RDcq~tlECR?1e%-?`#^|LXZb$X?ou_V z$97{^F^`ZY-HY_XtEZFZQuPqE)Xz@yY!#UxsxVRzL98mG@*!3@3K$)*Anj8XY@vp7 z0W1mE1Q(KcYyYt!b~S|1znV@JWy`XEHTxAQwv)@PZ*%9(uz)(AZ?#9%uGzu5tQBu@=Z=TRXji-| z7Vl0O4=8*c(L7!6`n?Bu@sfdX0@Dcl9pIB8QK_DUz&tEr>S5QWO2$lkAWSjZ_9DE_ z_z4Th<};H>kNNRNF(PlIhMwzzL}D{|2#)KG6ZpB!Z|*1VSB@A-j2P5&!gi90yy2C) znB#qs-N|Uege&>ebe`O=oW~Od;S6crq{xR!%%)@S@d6sfkqKOUzILBX#CGD%>d@1> z4GVK+Pj7d3dDSMtL3s_!OpNMHnBC>mgkuxvC<*i*&YWjDa~_%Rz~C&vSux{hjgbJUyP-0}Lak(Fx%S5_q?8#mDm6 zQ}NR@XcUG6m$b2`nDEwIuIM`+@+idxkPZ?B) z*A;4zA;tT;GZzdI3z!WjZwSpOWwKYy1k&@T*}mWxFAvj_~g~Ww+wUq?8p}1iawF&F=tF~O^F;hiPvmxQXH8j z95QyXYUsIkorR%T<#VkW)8UhO#Vg5H zUepU?7k?^*?$n?49$IO2){NO;fz(RO=V?oXs*Cqaag9h!1*lO=5v#na=gqPB7m{~% zqO>3lQEl^=LY`*IUT1VXZ*&|e{>#E#YCKoovN}M%cAGovxT5&fsP_@`<*q#$^^yGs zuOLxvqvItWxG8?F`CK)=+k|s}JdytNPjEe@Rgs#={CWC*9uI5_Loqs@3O$G9ae1S; zWwbeCE)|p}E+I&fx4W3LH{<$Zil>&H+<74zXVac;^&SrX5d&SI>3iHWK;zUCn*oVBzH;kijN zZH&*CVHY5zFlW1JJ1!f4viReLveHr$_47Y*+s^3*!}Ua6Ey8;@wZRvDMB4kd>^0g= zDdX$r0gz8Es*H~96ur{?Osx@(j@RTt6_m=nJ9~CxRteoyavgfdb3J>o7kXc|vR4=# zTPcGgf*s!Nsx0S^D~ly_@v=OUur@OeJL(^m?^^?U)m-QJ(qLc z8uKOj6Z_yp8NIjM5ir_?!`@Mv*lQLDa!*hc!HsPUQ@ahboJ;j9nTJ;tzt()Z!_|(B zm&~E?3`OB;I4*vz>BZG*aD7Z#L6z>co_8nabbFVUQkqOWxx`;L(d6o$w?JAx&7`#p zV20o(Kj$SY`vEkTb^GKx?elX=_Z5As>oCnyrkkbo;ASbco2BfaX30NNv)JAH_;?YV zp82)Svc>J2{V{F{#(zVbfR>{{3xp&{pHX&ryx;oKA+pL zx;*nxMMwEO^i1)LGR6zN2xk#|yObkGmxIkOnMJ7)@JupPF^OiCml5yfg;%k1+G3UG z7jH2)FHEr}=Z3aeOAEPDf_2qr#ap=Be@lEA4Uv#qX*uf&Zu1{SAsSYDM~;JeG_-tZ zO_rB7+h;Q20Shvt*eHKuquwWP+2Wf~ijKw0y?5G609cu9smvB)B&9}kvw*0^+eN73F?lnG2rk#!!tXSOv?G;Hc* zOA&5Bap%S!q}RZ^S)ZK=abp{5v^`33b?=LGrxt(NEN?2P9leh}aNElv6=xDdc-fbL zHY1x;i(hQ|BOV2G&7HctL_SOvvXmh|HS)%F(MtwVxjfP>!Mn)&iucLl&8=sNa=y`) z&Ai%OZ}K^BT)nwueB($yn&V}t%WL7OY1Uxz_LggzK(^Y%`f_{X=V1ddeCS} zAOlfD>{`|yYQNTKdyi(7Iq4Y=+Y7{tdKk7Rn>a5}jM+9Ng{tUrY;}1@XL`%CnV+0% zEoBeGXv>0dpf1@tlb0K(hqjQjum3Ki-Bji%-e!?UJ7%*AWB-HDM!PKGp@ur*>t)V+ z{uOVkrA=>^w?{8->S>^IZ z>C}Epuwbv-Ow;Z8;UP;fX@e2tvlEAu4<)ZBWAVIHM(m->a%!3k53#2yiEJChrjY}6 znhv@fz=%KeI=wD&MIU=h7Uq-v>QW|&Ph0iH)<{hfH`ZTxmr%Mli;5i5NwE&R^ej$Z zu|+3??XLi-XOdSg+pzkgKT($Ejr*N~-^-M`&U0d&#O}S(_B7VWh=E4?gIHuHigEZg zp)W|v>JBkAi5W3E%V_67mYeo6Os+nY$<0D0L@2ji#=FJE&o3NdH5W#GXN8`mulgyk zQn8lgU~(rH}(EO)#NHcUjcs(Ilsvu`5?zNsn%qXiW;n9=_@{FY_VE6v1u6?SzMB8to&b! z7CG-ko@~R?oy4h#$GWtnfTtm4UH44S?<|BMc@AQC}`T&|IE4|28_N7p6xJc$vf)D@CyRe3pG4 z`ZHFgl?4{N3S^r0lTDR5U1MN1ERK>Fc7rs(X;5~qmRag4{?r;fxA}W~X&rAT|L|!f z1RwW}AbB=EQjLyH#>!9dv$J>uYeE*wmjqMgv37D9UHobD0Li86MvE36!b8r{!V#ev zZ1%Iw5LrCeXO8!?y-EV@JFFR*;Z{eu>_J)hbeGGN2t(6UxfU%emz@Gos{a0+qGgL4 z%*EB_;wp;4YgaQeyOZdbp4jR1Cq);r05&!M8W}qaf@t5Q*d^z0BV!Nn3AbF*79Bem z0*gH;(PTd`7K5nzYg6)S7riML`pKsaMVqdWH~r+gh9$vZIEO=s6II^|AEPAx!iE;_ z%W>uhiqhZ$hrB&5UGA`gf1=fmKA(PYd`EZ-0Tnu}(S@?T+et<3cgsKe^p_hY3G+3G zA!{EIeekMtHs*=ncf~K-?2B~!{%Ud*mh|Z_qn5OeHL0rj>84Yn4@t1%&svXz&1Es& zLC(>;-I`QwPN)jK;{C*&Qf-YBex9YeCtpK5y3y)*c;oTu?>xS<7-wo-CgdfKy~j4NsyagdKo) zpLJO-N%l<%>Q}t)lSaG$RLQ}4brbdibMOBOnL~|h6g8G=Y7}WS=udCcvYR3<#3276 z^fpD=4^sv7N;xy2yM|BJyXz-J4rE++jMY>UEh&if1r`oZ z;8&Vnh%GURBSO~Z;u5t2<25$(PwzC^)Yiv@TmqihJx1j~ zuT+b-?lF0iVb8nf0dtw`a0JaB6?ardXiM=kM&w4mT2u1P=R+?Qzs}tMbub#RMy5y8 zPnRZS?oRiyijEWfyi^OG@o#oKsjbH9xSb4(sj7CxSCZqv6( z*yV9=kD$H*N^LDt&0^*S^(;XpPm>DvD2+P1m2Ke@J-UE6=Vw%xAne_Y!h z*Y>_^+w0o?*R}0;ZGUxbvO}!P>~n1*T&4ZeU0a50%XDp7t}WZO1zg+zxVB^2snzLS z;M%UlCKJd^k6bDzOPEa0d#>$SdbRfZUWOB{3!6^mP1kk{9?~r{J;Pyl`s++=I_?J7 z_D9#2!~$J^Epcr(y0(~WJB0gOZ9S57)~7#{RduVZCE z`zmFLq%F0AjKD+z*ti`AL zjKo;C;j_G-&+qZM*Y-*F9I8R{KKK=`761JsHE1@u$%=N2{GRLQbC`FoW;M-n-o5g8 zB$m9ybo~> zEZbqfJY~D=$E<9Z{q&XXQm<0k_KG>-O8Xfs+edP!UNCPydXX)SNZHMC9=x)@*Xk#> z9G8C2OEiZ>bng(&q3`4${#~i>ez*ACfcnKXhkivzgt77S^`i^%5#DkGX1Xvjeh@2d z@sHOQ{Fmkm6Kq#<{a>0Z|I%C$DfFel`ABB}OLIkQE-e5bXMqp)*!xMY|4Vb_Uz#fn zO#X|3!)dPlOLIkQE;2v%tF9I zZB6x2kF4%gS=gGfjbg|d$Fm$qR`#xme38^zlz39Xu2Qu~rr$z1ju)%B0~&ew$P=h_ z95aT}PE)eqmBdq$e3j#oopDB>BE2l6-?X5w1*%e2^5&WM8UV zlzZi{z7Z{rO-v_ycXx}vu&4LsZqb_-Nxq7zQY_sST7a*jTDEn&E3^P#s;t|4?_y7F zQFMB6n(Tp@zF;5ntAb(KTOKXBaMDINX^0Zp^|#xX+B6bVq@kvnV|-Xk%ptLFu}@~k zT)afS7~Xoe#tPx9<<`d{7S%RB$W!6t91-T6*7J@x3{QR#h}M-E2*r z>&hHTfCQPt+D0XFSTUEbpkxkjRWgU`l!#kxL$snMI<>*9t%|ma%wZ9&PzYqw5%K}K zMOB(KE`x|38lCuHIm8k+?B#H|v3pEbP>>*(MB7NPYG+%mb>2_8GPA^p{FUNaQ){f& zDw55jy+o*5YZuXSm7HDVARe|-NoG7<99t;;41N+m@hfoE`;a0Kc#9ORKM}Q^D^k{O zhP@jT#1P+QAI#3^+2#W2IMQo=hp(L(DfVMrS~8;&>6PLanx3b1@X!*7_&pVR774`G z#xYiH9ZiEeTdT-c$jzbI)PARNz1&_6pWcrE;zWd3Z01D1MT8OQnS6*X&unclTdVL@ zw~N?~kZw(^v+)jP#^nzc-Zk-^FL>Vtr-IGN2A@UiPL;l02nzGe+G-G9c zM`u`5Imws9`)TF^5#gyUo|<^mxwA18T@9BU~4LpqJ(R%xQ9 zGaeyIkw~hsNU>FDbegrGgsKP)Rr8@T_64HyR)r!fjv^Dsqpzhe#qz(7zQQmdhe;`p z<_r~WFNlOut;(4byxxr>DfwFvqD1ok0}C`zrUet__W6BOs!SbAY05J?dN@vn$3Xc| z6JLWl+j{muP9l$|`+*2Z#ui@mO?txZ;D1r{@IB!SDQRm}?_*?#bf8G$YqBL@^R=!I zMUqx~!08d8oFh%d>E9_vM{TJRPLqaRecVWThw%3rO%kz)$oo&twJO|UfJW9siZqZT z+R=X)2;Uj|y(qElv&AxhLE#V*bePBjA-f^?As5JrR7GWYJQwXo(vqPxJw~_fWOwx- zrr->y*2GE~Q;VN%+Ck__b*`l+ELtvbYN<7Gn$=oOC9;l0A4nK)FMbdH^Ns1F#vY*h z)5jkKJ8o{h8x>vLb`V_zzLqKiN2H2xP`=ygfk&d>qosVU)h<;S9UluFg#HXw&^9hj zsKzOS!gk!9PX0#?nQ?4R4v1~Ti7dJDE1)A47{^NHv-E^U|Gg@CV%0pj!=+93@3qM-lQV(&d{rZTWca3zu^FvkWZY? zN{BisEGI?YNrnhZqn9Pe)@#a<)qsu;$yR3%Zua#3#6rI?cfBHz+IIv}nG#w(BlYM|p&wsNGp#3gnJ4D;+T-$TlL@_GU^M>m;mi-XzcL_Ef<2Kjt9@lR;fp8G_ zR1VN}xGfwiYFjz-5ZYFVoP)Mq0c~m9uh>tKQ}+R$-@3L<*t8tMVNd(jnP>d8-#N)A z5zf+`lYH4gD(&Y(wbZ>@@i1g#-+6p^838_fPL)^$^m?4L>mq#e+49john}Uk@+~A$ z-QPdzEd9_kaLJ<5&BrO>lzu+7-{72l4l(4C-Xk82kCH25oFi~?^grDepTraHBc4~w z1-Q-5fwgnf<&n;-&pxN%?11{k&#V8$ie2dWaOc$lzR7v@U9zg@Co~ZFC!ALY>~r`) z!I@{Dc}_qi0-EMsF*h72C@wzt+h^zJpBorIv+1h9$k`3tSbONLLCKUX1&U8a(>@Jd zPZ#&Yukd=4 zyvbglcYxRLP4{Mav%CRszPHp{2TI+%ojjeqB#&eGcP#(1_;(!tj_2PA{LALwiTo?& zAN#=t`zEb;|7OxcJbxobKmLwhXt+`Kbhzl|Q^w0G$&|g4s^-)6{uq;At{%A`-#!^a zJHz8WXaI*BM@b+wPs5E(yNFjNgo6IWCNa)tP%O3gA6e|xN0!tydRkJ)GE*&UkrzP9 zP(3K+3JLxaw^G;yEAF!P4_YQNxqTR?C{!@Re;x%gE33n6zOdqLQ8hNtV6RWUTSKDP z`pgT=c|K~j36IDCU$?r7yI|9b$ECJfl94G7?;fiB2g(C!6rpnAdoo9qA~dTas0Er@ z0oVt<1_4RH5d%^FqnJpDCIvc_~ z!v;FNypP=w{vPp%ER6NT=>=q5MQVahp1_+RkLxg{+5=h}s-shQfvu*Ynj#CzA14g% z7KL{~cGG66s>;C{e-}$pbl%13HQMgQMMeq{m;qtVnAuWF8SVwkvIETHfC_s!3vr16 zbS01A7NM95{w0)Ze@alqK%R@cM1qZVa>65D(gcfnM%&5cYJS3WsLDKWdJRfaH>*Og zet`#dMw`#`+!#+1%6olXZ)Ru(nY5RfG?kbi>m~8do;PudvTwQ>Q(ir9N@+!Ttg@%q zp}+Ld)1WOk>N}qMoJv--ydRy?r{*%NxA(l&E(xGO!aY`M{=s&BIweYPr-m(`kbJuA z#)c?_*hwdSTn*rg?t@i!c?obw64J>t5m;KmFH&tDTGFZn;xDXfi@|086kCS3~RDrFvqI*(M zyAX<5cx&t~_At$l-5zT2^Z=h+b` zCWOD`kdsY>=6=#BT{D{}8z+0rZjhBr%PInp#07CZAFkeRF8Kqx13mAw;|E_!4-Yx0 zjcIX|W-cU-YTpSt1eErb?2)r}-X1DK7fV%})k@c!NzD8=QDE;-b9n42*13cexZLhKa zs{P(^ZHJxR=^4T-qN^Y85b%J&nfax-r0EC9JY`WB@xA47pV=zR*_#r4B+NM~ijKu6 zH6JL&sb+5CebDdFx!f>j625++{!w!|NmP(2KPgI*nrS*StXeJM=Q`y<0yV|pGQN6| z1$3rRfv=lG6?~`QI|t99*3gewNboyU=5IIEl{r)cVdO^xdIJB1Ih1qVVE+pb1Ap`N zh5C%S6sA)H_o$)cO|!1bw#NFbOEXwWmsqEVUK?+Ifa!Ra`dGzUg31v;nl`)6Zg#YJR7Z;+mfGt2CC2+K$HLA+Gv@-nB;RJ~>xHY?+`%bp{jgHBla=2%Y>kkM*wR6U8}o7TYGrt>S<2G(}P_3MJw&|@l06z3p5wD(w1Y4j`W}^P1k!F z>If<7%jkW8ZvmtIHbRkLjhxSk72epbB-PEmU3-$v&0TLMhn@(%Xpf0(5KG{k9yn%E zbh6hR8lCDjFHUbBAHsvkMUhP@BbI=%1~&f6ea)wa#KEx4ZK9;U1UwSotSvG}W|*xd zk;hB*OKNcWjS?dCQfPng%Y-S~C{!1EHngYr9>JTfoL0}UMlB+2Pk{S$9t|xFHV=s- zP*5h-wTJ7mIj{8evTu}br3XXLeG_D7aKI*QmWW@YV{=dM9T}!C*pl}Z80{8nV{<8+ zg2zP3N;ZJs%P8JTN&Q4_&goyyuPVCbL$NEgmGYbWRSo=-Ba7+DDnRS&k{V;_(RLc*>s^SFhii{isJlmM(Y1=Ir+IFTqg2Gq%eaTei3a`W0-GNVilhD<`Hy^Qte+$o! S|Nc=Umh8y51Co+Q|Nj6dc3)xu literal 0 HcmV?d00001 diff --git a/libs/zlib/windows/lib/libz.dll.a b/libs/zlib/windows/lib/libz.dll.a new file mode 100644 index 0000000000000000000000000000000000000000..fd1899575e0a9379be6aea1d8d9bdc92fc6e28a2 GIT binary patch literal 43738 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 literal 0 HcmV?d00001 diff --git a/libs/zlib/windows/lib/zlib-bcc.lib b/libs/zlib/windows/lib/zlib-bcc.lib new file mode 100644 index 0000000000000000000000000000000000000000..f23e2b12a072e923743055357bc239801da35e44 GIT binary patch literal 6656 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