From f5f1bb7e843e4acedddda6931e3944156654db80 Mon Sep 17 00:00:00 2001 From: skyjake Date: Tue, 27 Sep 2011 18:20:53 +0300 Subject: [PATCH] Win32: Updated libpng and libcurl Both of these are dependent on zlib 1.2.5, which is now included in doomsday/external/zlib. libpng is version 1.5.5 and libcurl is version 7.22. They have been compiled with MSVC 2010. An external libcurl SDK is no longer being used by dep_curl.pri. --- distrib/platform_release.py | 11 +- distrib/win32/setup.iss.template | 7 +- doomsday/dep_curl.pri | 16 +- doomsday/dep_libpng.pri | 4 +- .../libcurl/portable/include/curl/curl.h | 2178 ++++++++++ .../libcurl/portable/include/curl/curlbuild.h | 583 +++ .../libcurl/portable/include/curl/curlrules.h | 261 ++ .../libcurl/portable/include/curl/curlver.h | 69 + .../libcurl/portable/include/curl/easy.h | 102 + .../libcurl/portable/include/curl/mprintf.h | 81 + .../libcurl/portable/include/curl/multi.h | 345 ++ .../portable/include/curl/stdcheaders.h | 33 + .../portable/include/curl/typecheck-gcc.h | 590 +++ doomsday/external/libcurl/win32/libcurl.dll | Bin 0 -> 227840 bytes doomsday/external/libcurl/win32/libcurl.exp | Bin 0 -> 7869 bytes doomsday/external/libcurl/win32/libcurl.lib | Bin 0 -> 13694 bytes .../external/libpng/portable/include/png.h | 3812 +++++++---------- .../libpng/portable/include/pngconf.h | 1689 ++------ .../libpng/portable/include/pnglibconf.h | 187 + doomsday/external/libpng/win32/libpng13.dll | Bin 135168 -> 0 bytes doomsday/external/libpng/win32/libpng13.lib | Bin 45914 -> 0 bytes doomsday/external/libpng/win32/libpng13d.dll | Bin 262144 -> 0 bytes doomsday/external/libpng/win32/libpng13d.lib | Bin 46088 -> 0 bytes doomsday/external/libpng/win32/libpng15.dll | Bin 0 -> 176128 bytes doomsday/external/libpng/win32/libpng15.lib | Bin 0 -> 53568 bytes 25 files changed, 6307 insertions(+), 3661 deletions(-) create mode 100644 doomsday/external/libcurl/portable/include/curl/curl.h create mode 100644 doomsday/external/libcurl/portable/include/curl/curlbuild.h create mode 100644 doomsday/external/libcurl/portable/include/curl/curlrules.h create mode 100644 doomsday/external/libcurl/portable/include/curl/curlver.h create mode 100644 doomsday/external/libcurl/portable/include/curl/easy.h create mode 100644 doomsday/external/libcurl/portable/include/curl/mprintf.h create mode 100644 doomsday/external/libcurl/portable/include/curl/multi.h create mode 100644 doomsday/external/libcurl/portable/include/curl/stdcheaders.h create mode 100644 doomsday/external/libcurl/portable/include/curl/typecheck-gcc.h create mode 100644 doomsday/external/libcurl/win32/libcurl.dll create mode 100644 doomsday/external/libcurl/win32/libcurl.exp create mode 100644 doomsday/external/libcurl/win32/libcurl.lib create mode 100644 doomsday/external/libpng/portable/include/pnglibconf.h delete mode 100644 doomsday/external/libpng/win32/libpng13.dll delete mode 100644 doomsday/external/libpng/win32/libpng13.lib delete mode 100644 doomsday/external/libpng/win32/libpng13d.dll delete mode 100644 doomsday/external/libpng/win32/libpng13d.lib create mode 100644 doomsday/external/libpng/win32/libpng15.dll create mode 100644 doomsday/external/libpng/win32/libpng15.lib diff --git a/distrib/platform_release.py b/distrib/platform_release.py index a4d27f8721..9f29323db3 100755 --- a/distrib/platform_release.py +++ b/distrib/platform_release.py @@ -7,7 +7,7 @@ import glob import build_version -LAUNCH_DIR = os.getcwd() +LAUNCH_DIR = os.path.abspath(os.getcwd()) DOOMSDAY_DIR = os.path.abspath(os.path.join(os.getcwd(), '..', 'doomsday')) SNOWBERRY_DIR = os.path.abspath(os.path.join(LAUNCH_DIR, '..', 'snowberry')) WORK_DIR = os.path.join(LAUNCH_DIR, 'work') @@ -80,9 +80,7 @@ def prepare_work_dir(): def mac_os_version(): return platform.mac_ver()[0][:4] - - - + """The Mac OS X release procedure.""" def mac_release(): @@ -198,6 +196,11 @@ def mac_release(): """The Mac OS X release procedure.""" def win_release(): + PROD_DIR = os.path.join(LAUNCH_DIR, 'products') + if not os.path.exists(PROD_DIR): + print "Creating the products directory." + os.mkdir(PROD_DIR) + # Generate the Inno Setup configuration file. script = file('win32\setup.iss.template', 'rt').read() file('win32\setup.iss', 'wt').write(script diff --git a/distrib/win32/setup.iss.template b/distrib/win32/setup.iss.template index b4b62d3bf3..ecb3fcf69f 100644 --- a/distrib/win32/setup.iss.template +++ b/distrib/win32/setup.iss.template @@ -68,12 +68,9 @@ Source: "mikmod.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: En Source: "SDL_mixer.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine Source: "smpeg.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine Source: "lzss.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine -Source: "curllib.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine -Source: "openldap.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine -Source: "ssleay32.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine -Source: "libeay32.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine Source: "zlib1.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine -Source: "libpng13.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine +Source: "libpng15.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine +Source: "libcurl.dll"; DestDir: "{app}\bin"; Flags: ignoreversion; Components: Engine ; Snowberry Source: "..\..\snowberry\dist\*"; DestDir: "{app}\snowberry"; Flags: ignoreversion; Components: Launcher diff --git a/doomsday/dep_curl.pri b/doomsday/dep_curl.pri index 4f8c09b859..9ae3a52ad9 100644 --- a/doomsday/dep_curl.pri +++ b/doomsday/dep_curl.pri @@ -1,19 +1,13 @@ # Build configuration for cURL. win32 { - isEmpty(CURL_DIR) { - error("dep_curl: cURL SDK path not defined, check your config_user.pri") - } - - INCLUDEPATH += $$CURL_DIR/include - LIBS += -l$$CURL_DIR/libcurl_imp + CURL_DIR = $$PWD/external/libcurl + + INCLUDEPATH += $$CURL_DIR/portable/include + LIBS += -l$$CURL_DIR/win32/libcurl # Install the libcurl shared library. INSTALLS += curllibs - curllibs.files = \ - $$CURL_DIR/curllib.dll \ - $$CURL_DIR/openldap.dll \ - $$CURL_DIR/ssleay32.dll \ - $$CURL_DIR/libeay32.dll + curllibs.files = $$CURL_DIR/win32/libcurl.dll curllibs.path = $$DENG_WIN_PRODUCTS_DIR } else:macx { diff --git a/doomsday/dep_libpng.pri b/doomsday/dep_libpng.pri index 7ee52c77ed..4950784448 100644 --- a/doomsday/dep_libpng.pri +++ b/doomsday/dep_libpng.pri @@ -1,11 +1,11 @@ # Build configuration for libpng. win32 { INCLUDEPATH += $$PWD/external/libpng/portable/include - LIBS += -L$$PWD/external/libpng/win32 -llibpng13 + LIBS += -L$$PWD/external/libpng/win32 -llibpng15 # Installed shared libraries. INSTALLS += pnglibs - pnglibs.files = $$PWD/external/libpng/win32/libpng13.dll + pnglibs.files = $$PWD/external/libpng/win32/libpng15.dll pnglibs.path = $$DENG_WIN_PRODUCTS_DIR } else:macx { diff --git a/doomsday/external/libcurl/portable/include/curl/curl.h b/doomsday/external/libcurl/portable/include/curl/curl.h new file mode 100644 index 0000000000..ef6bda8f3a --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/curl.h @@ -0,0 +1,2178 @@ +#ifndef __CURL_CURL_H +#define __CURL_CURL_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2011, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* + * If you have libcurl problems, all docs and details are found here: + * http://curl.haxx.se/libcurl/ + * + * curl-library mailing list subscription and unsubscription web interface: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + */ + +#include "curlver.h" /* libcurl version defines */ +#include "curlbuild.h" /* libcurl build definitions */ +#include "curlrules.h" /* libcurl rules enforcement */ + +/* + * Define WIN32 when build target is Win32 API + */ + +#if (defined(_WIN32) || defined(__WIN32__)) && \ + !defined(WIN32) && !defined(__SYMBIAN32__) +#define WIN32 +#endif + +#include +#include + +#if defined(__FreeBSD__) && (__FreeBSD__ >= 2) +/* Needed for __FreeBSD_version symbol definition */ +#include +#endif + +/* The include stuff here below is mainly for time_t! */ +#include +#include + +#if defined(WIN32) && !defined(_WIN32_WCE) && !defined(__CYGWIN__) +#if !(defined(_WINSOCKAPI_) || defined(_WINSOCK_H) || defined(__LWIP_OPT_H__)) +/* The check above prevents the winsock2 inclusion if winsock.h already was + included, since they can't co-exist without problems */ +#include +#include +#endif +#endif + +/* HP-UX systems version 9, 10 and 11 lack sys/select.h and so does oldish + libc5-based Linux systems. Only include it on systems that are known to + require it! */ +#if defined(_AIX) || defined(__NOVELL_LIBC__) || defined(__NetBSD__) || \ + defined(__minix) || defined(__SYMBIAN32__) || defined(__INTEGRITY) || \ + defined(ANDROID) || \ + (defined(__FreeBSD_version) && (__FreeBSD_version < 800000)) +#include +#endif + +#if !defined(WIN32) && !defined(_WIN32_WCE) +#include +#endif + +#if !defined(WIN32) && !defined(__WATCOMC__) && !defined(__VXWORKS__) +#include +#endif + +#ifdef __BEOS__ +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURL; + +/* + * Decorate exportable functions for Win32 and Symbian OS DLL linking. + * This avoids using a .def file for building libcurl.dll. + */ +#if (defined(WIN32) || defined(_WIN32) || defined(__SYMBIAN32__)) && \ + !defined(CURL_STATICLIB) +#if defined(BUILDING_LIBCURL) +#define CURL_EXTERN __declspec(dllexport) +#else +#define CURL_EXTERN __declspec(dllimport) +#endif +#else + +#ifdef CURL_HIDDEN_SYMBOLS +/* + * This definition is used to make external definitions visible in the + * shared library when symbols are hidden by default. It makes no + * difference when compiling applications whether this is set or not, + * only when compiling the library. + */ +#define CURL_EXTERN CURL_EXTERN_SYMBOL +#else +#define CURL_EXTERN +#endif +#endif + +#ifndef curl_socket_typedef +/* socket typedef */ +#if defined(WIN32) && !defined(__LWIP_OPT_H__) +typedef SOCKET curl_socket_t; +#define CURL_SOCKET_BAD INVALID_SOCKET +#else +typedef int curl_socket_t; +#define CURL_SOCKET_BAD -1 +#endif +#define curl_socket_typedef +#endif /* curl_socket_typedef */ + +struct curl_httppost { + struct curl_httppost *next; /* next entry in the list */ + char *name; /* pointer to allocated name */ + long namelength; /* length of name length */ + char *contents; /* pointer to allocated data contents */ + long contentslength; /* length of contents field */ + char *buffer; /* pointer to allocated buffer contents */ + long bufferlength; /* length of buffer field */ + char *contenttype; /* Content-Type */ + struct curl_slist* contentheader; /* list of extra headers for this form */ + struct curl_httppost *more; /* if one field name has more than one + file, this link should link to following + files */ + long flags; /* as defined below */ +#define HTTPPOST_FILENAME (1<<0) /* specified content is a file name */ +#define HTTPPOST_READFILE (1<<1) /* specified content is a file name */ +#define HTTPPOST_PTRNAME (1<<2) /* name is only stored pointer + do not free in formfree */ +#define HTTPPOST_PTRCONTENTS (1<<3) /* contents is only stored pointer + do not free in formfree */ +#define HTTPPOST_BUFFER (1<<4) /* upload file from buffer */ +#define HTTPPOST_PTRBUFFER (1<<5) /* upload file from pointer contents */ +#define HTTPPOST_CALLBACK (1<<6) /* upload file contents by using the + regular read callback to get the data + and pass the given pointer as custom + pointer */ + + char *showfilename; /* The file name to show. If not set, the + actual file name will be used (if this + is a file part) */ + void *userp; /* custom pointer used for + HTTPPOST_CALLBACK posts */ +}; + +typedef int (*curl_progress_callback)(void *clientp, + double dltotal, + double dlnow, + double ultotal, + double ulnow); + +#ifndef CURL_MAX_WRITE_SIZE + /* Tests have proven that 20K is a very bad buffer size for uploads on + Windows, while 16K for some odd reason performed a lot better. + We do the ifndef check to allow this value to easier be changed at build + time for those who feel adventurous. The practical minimum is about + 400 bytes since libcurl uses a buffer of this size as a scratch area + (unrelated to network send operations). */ +#define CURL_MAX_WRITE_SIZE 16384 +#endif + +#ifndef CURL_MAX_HTTP_HEADER +/* The only reason to have a max limit for this is to avoid the risk of a bad + server feeding libcurl with a never-ending header that will cause reallocs + infinitely */ +#define CURL_MAX_HTTP_HEADER (100*1024) +#endif + + +/* This is a magic return code for the write callback that, when returned, + will signal libcurl to pause receiving on the current transfer. */ +#define CURL_WRITEFUNC_PAUSE 0x10000001 +typedef size_t (*curl_write_callback)(char *buffer, + size_t size, + size_t nitems, + void *outstream); + + + +/* enumeration of file types */ +typedef enum { + CURLFILETYPE_FILE = 0, + CURLFILETYPE_DIRECTORY, + CURLFILETYPE_SYMLINK, + CURLFILETYPE_DEVICE_BLOCK, + CURLFILETYPE_DEVICE_CHAR, + CURLFILETYPE_NAMEDPIPE, + CURLFILETYPE_SOCKET, + CURLFILETYPE_DOOR, /* is possible only on Sun Solaris now */ + + CURLFILETYPE_UNKNOWN /* should never occur */ +} curlfiletype; + +#define CURLFINFOFLAG_KNOWN_FILENAME (1<<0) +#define CURLFINFOFLAG_KNOWN_FILETYPE (1<<1) +#define CURLFINFOFLAG_KNOWN_TIME (1<<2) +#define CURLFINFOFLAG_KNOWN_PERM (1<<3) +#define CURLFINFOFLAG_KNOWN_UID (1<<4) +#define CURLFINFOFLAG_KNOWN_GID (1<<5) +#define CURLFINFOFLAG_KNOWN_SIZE (1<<6) +#define CURLFINFOFLAG_KNOWN_HLINKCOUNT (1<<7) + +/* Content of this structure depends on information which is known and is + achievable (e.g. by FTP LIST parsing). Please see the url_easy_setopt(3) man + page for callbacks returning this structure -- some fields are mandatory, + some others are optional. The FLAG field has special meaning. */ +struct curl_fileinfo { + char *filename; + curlfiletype filetype; + time_t time; + unsigned int perm; + int uid; + int gid; + curl_off_t size; + long int hardlinks; + + struct { + /* If some of these fields is not NULL, it is a pointer to b_data. */ + char *time; + char *perm; + char *user; + char *group; + char *target; /* pointer to the target filename of a symlink */ + } strings; + + unsigned int flags; + + /* used internally */ + char * b_data; + size_t b_size; + size_t b_used; +}; + +/* return codes for CURLOPT_CHUNK_BGN_FUNCTION */ +#define CURL_CHUNK_BGN_FUNC_OK 0 +#define CURL_CHUNK_BGN_FUNC_FAIL 1 /* tell the lib to end the task */ +#define CURL_CHUNK_BGN_FUNC_SKIP 2 /* skip this chunk over */ + +/* if splitting of data transfer is enabled, this callback is called before + download of an individual chunk started. Note that parameter "remains" works + only for FTP wildcard downloading (for now), otherwise is not used */ +typedef long (*curl_chunk_bgn_callback)(const void *transfer_info, + void *ptr, + int remains); + +/* return codes for CURLOPT_CHUNK_END_FUNCTION */ +#define CURL_CHUNK_END_FUNC_OK 0 +#define CURL_CHUNK_END_FUNC_FAIL 1 /* tell the lib to end the task */ + +/* If splitting of data transfer is enabled this callback is called after + download of an individual chunk finished. + Note! After this callback was set then it have to be called FOR ALL chunks. + Even if downloading of this chunk was skipped in CHUNK_BGN_FUNC. + This is the reason why we don't need "transfer_info" parameter in this + callback and we are not interested in "remains" parameter too. */ +typedef long (*curl_chunk_end_callback)(void *ptr); + +/* return codes for FNMATCHFUNCTION */ +#define CURL_FNMATCHFUNC_MATCH 0 /* string corresponds to the pattern */ +#define CURL_FNMATCHFUNC_NOMATCH 1 /* pattern doesn't match the string */ +#define CURL_FNMATCHFUNC_FAIL 2 /* an error occurred */ + +/* callback type for wildcard downloading pattern matching. If the + string matches the pattern, return CURL_FNMATCHFUNC_MATCH value, etc. */ +typedef int (*curl_fnmatch_callback)(void *ptr, + const char *pattern, + const char *string); + +/* These are the return codes for the seek callbacks */ +#define CURL_SEEKFUNC_OK 0 +#define CURL_SEEKFUNC_FAIL 1 /* fail the entire transfer */ +#define CURL_SEEKFUNC_CANTSEEK 2 /* tell libcurl seeking can't be done, so + libcurl might try other means instead */ +typedef int (*curl_seek_callback)(void *instream, + curl_off_t offset, + int origin); /* 'whence' */ + +/* This is a return code for the read callback that, when returned, will + signal libcurl to immediately abort the current transfer. */ +#define CURL_READFUNC_ABORT 0x10000000 +/* This is a return code for the read callback that, when returned, will + signal libcurl to pause sending data on the current transfer. */ +#define CURL_READFUNC_PAUSE 0x10000001 + +typedef size_t (*curl_read_callback)(char *buffer, + size_t size, + size_t nitems, + void *instream); + +typedef enum { + CURLSOCKTYPE_IPCXN, /* socket created for a specific IP connection */ + CURLSOCKTYPE_LAST /* never use */ +} curlsocktype; + +/* The return code from the sockopt_callback can signal information back + to libcurl: */ +#define CURL_SOCKOPT_OK 0 +#define CURL_SOCKOPT_ERROR 1 /* causes libcurl to abort and return + CURLE_ABORTED_BY_CALLBACK */ +#define CURL_SOCKOPT_ALREADY_CONNECTED 2 + +typedef int (*curl_sockopt_callback)(void *clientp, + curl_socket_t curlfd, + curlsocktype purpose); + +struct curl_sockaddr { + int family; + int socktype; + int protocol; + unsigned int addrlen; /* addrlen was a socklen_t type before 7.18.0 but it + turned really ugly and painful on the systems that + lack this type */ + struct sockaddr addr; +}; + +typedef curl_socket_t +(*curl_opensocket_callback)(void *clientp, + curlsocktype purpose, + struct curl_sockaddr *address); + +typedef int +(*curl_closesocket_callback)(void *clientp, curl_socket_t item); + +typedef enum { + CURLIOE_OK, /* I/O operation successful */ + CURLIOE_UNKNOWNCMD, /* command was unknown to callback */ + CURLIOE_FAILRESTART, /* failed to restart the read */ + CURLIOE_LAST /* never use */ +} curlioerr; + +typedef enum { + CURLIOCMD_NOP, /* no operation */ + CURLIOCMD_RESTARTREAD, /* restart the read stream from start */ + CURLIOCMD_LAST /* never use */ +} curliocmd; + +typedef curlioerr (*curl_ioctl_callback)(CURL *handle, + int cmd, + void *clientp); + +/* + * The following typedef's are signatures of malloc, free, realloc, strdup and + * calloc respectively. Function pointers of these types can be passed to the + * curl_global_init_mem() function to set user defined memory management + * callback routines. + */ +typedef void *(*curl_malloc_callback)(size_t size); +typedef void (*curl_free_callback)(void *ptr); +typedef void *(*curl_realloc_callback)(void *ptr, size_t size); +typedef char *(*curl_strdup_callback)(const char *str); +typedef void *(*curl_calloc_callback)(size_t nmemb, size_t size); + +/* the kind of data that is passed to information_callback*/ +typedef enum { + CURLINFO_TEXT = 0, + CURLINFO_HEADER_IN, /* 1 */ + CURLINFO_HEADER_OUT, /* 2 */ + CURLINFO_DATA_IN, /* 3 */ + CURLINFO_DATA_OUT, /* 4 */ + CURLINFO_SSL_DATA_IN, /* 5 */ + CURLINFO_SSL_DATA_OUT, /* 6 */ + CURLINFO_END +} curl_infotype; + +typedef int (*curl_debug_callback) + (CURL *handle, /* the handle/transfer this concerns */ + curl_infotype type, /* what kind of data */ + char *data, /* points to the data */ + size_t size, /* size of the data pointed to */ + void *userptr); /* whatever the user please */ + +/* All possible error codes from all sorts of curl functions. Future versions + may return other values, stay prepared. + + Always add new return codes last. Never *EVER* remove any. The return + codes must remain the same! + */ + +typedef enum { + CURLE_OK = 0, + CURLE_UNSUPPORTED_PROTOCOL, /* 1 */ + CURLE_FAILED_INIT, /* 2 */ + CURLE_URL_MALFORMAT, /* 3 */ + CURLE_NOT_BUILT_IN, /* 4 - [was obsoleted in August 2007 for + 7.17.0, reused in April 2011 for 7.21.5] */ + CURLE_COULDNT_RESOLVE_PROXY, /* 5 */ + CURLE_COULDNT_RESOLVE_HOST, /* 6 */ + CURLE_COULDNT_CONNECT, /* 7 */ + CURLE_FTP_WEIRD_SERVER_REPLY, /* 8 */ + CURLE_REMOTE_ACCESS_DENIED, /* 9 a service was denied by the server + due to lack of access - when login fails + this is not returned. */ + CURLE_OBSOLETE10, /* 10 - NOT USED */ + CURLE_FTP_WEIRD_PASS_REPLY, /* 11 */ + CURLE_OBSOLETE12, /* 12 - NOT USED */ + CURLE_FTP_WEIRD_PASV_REPLY, /* 13 */ + CURLE_FTP_WEIRD_227_FORMAT, /* 14 */ + CURLE_FTP_CANT_GET_HOST, /* 15 */ + CURLE_OBSOLETE16, /* 16 - NOT USED */ + CURLE_FTP_COULDNT_SET_TYPE, /* 17 */ + CURLE_PARTIAL_FILE, /* 18 */ + CURLE_FTP_COULDNT_RETR_FILE, /* 19 */ + CURLE_OBSOLETE20, /* 20 - NOT USED */ + CURLE_QUOTE_ERROR, /* 21 - quote command failure */ + CURLE_HTTP_RETURNED_ERROR, /* 22 */ + CURLE_WRITE_ERROR, /* 23 */ + CURLE_OBSOLETE24, /* 24 - NOT USED */ + CURLE_UPLOAD_FAILED, /* 25 - failed upload "command" */ + CURLE_READ_ERROR, /* 26 - couldn't open/read from file */ + CURLE_OUT_OF_MEMORY, /* 27 */ + /* Note: CURLE_OUT_OF_MEMORY may sometimes indicate a conversion error + instead of a memory allocation error if CURL_DOES_CONVERSIONS + is defined + */ + CURLE_OPERATION_TIMEDOUT, /* 28 - the timeout time was reached */ + CURLE_OBSOLETE29, /* 29 - NOT USED */ + CURLE_FTP_PORT_FAILED, /* 30 - FTP PORT operation failed */ + CURLE_FTP_COULDNT_USE_REST, /* 31 - the REST command failed */ + CURLE_OBSOLETE32, /* 32 - NOT USED */ + CURLE_RANGE_ERROR, /* 33 - RANGE "command" didn't work */ + CURLE_HTTP_POST_ERROR, /* 34 */ + CURLE_SSL_CONNECT_ERROR, /* 35 - wrong when connecting with SSL */ + CURLE_BAD_DOWNLOAD_RESUME, /* 36 - couldn't resume download */ + CURLE_FILE_COULDNT_READ_FILE, /* 37 */ + CURLE_LDAP_CANNOT_BIND, /* 38 */ + CURLE_LDAP_SEARCH_FAILED, /* 39 */ + CURLE_OBSOLETE40, /* 40 - NOT USED */ + CURLE_FUNCTION_NOT_FOUND, /* 41 */ + CURLE_ABORTED_BY_CALLBACK, /* 42 */ + CURLE_BAD_FUNCTION_ARGUMENT, /* 43 */ + CURLE_OBSOLETE44, /* 44 - NOT USED */ + CURLE_INTERFACE_FAILED, /* 45 - CURLOPT_INTERFACE failed */ + CURLE_OBSOLETE46, /* 46 - NOT USED */ + CURLE_TOO_MANY_REDIRECTS , /* 47 - catch endless re-direct loops */ + CURLE_UNKNOWN_OPTION, /* 48 - User specified an unknown option */ + CURLE_TELNET_OPTION_SYNTAX , /* 49 - Malformed telnet option */ + CURLE_OBSOLETE50, /* 50 - NOT USED */ + CURLE_PEER_FAILED_VERIFICATION, /* 51 - peer's certificate or fingerprint + wasn't verified fine */ + CURLE_GOT_NOTHING, /* 52 - when this is a specific error */ + CURLE_SSL_ENGINE_NOTFOUND, /* 53 - SSL crypto engine not found */ + CURLE_SSL_ENGINE_SETFAILED, /* 54 - can not set SSL crypto engine as + default */ + CURLE_SEND_ERROR, /* 55 - failed sending network data */ + CURLE_RECV_ERROR, /* 56 - failure in receiving network data */ + CURLE_OBSOLETE57, /* 57 - NOT IN USE */ + CURLE_SSL_CERTPROBLEM, /* 58 - problem with the local certificate */ + CURLE_SSL_CIPHER, /* 59 - couldn't use specified cipher */ + CURLE_SSL_CACERT, /* 60 - problem with the CA cert (path?) */ + CURLE_BAD_CONTENT_ENCODING, /* 61 - Unrecognized/bad encoding */ + CURLE_LDAP_INVALID_URL, /* 62 - Invalid LDAP URL */ + CURLE_FILESIZE_EXCEEDED, /* 63 - Maximum file size exceeded */ + CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */ + CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind + that failed */ + CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */ + CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not + accepted and we failed to login */ + CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */ + CURLE_TFTP_PERM, /* 69 - permission problem on server */ + CURLE_REMOTE_DISK_FULL, /* 70 - out of disk space on server */ + CURLE_TFTP_ILLEGAL, /* 71 - Illegal TFTP operation */ + CURLE_TFTP_UNKNOWNID, /* 72 - Unknown transfer ID */ + CURLE_REMOTE_FILE_EXISTS, /* 73 - File already exists */ + CURLE_TFTP_NOSUCHUSER, /* 74 - No such user */ + CURLE_CONV_FAILED, /* 75 - conversion failed */ + CURLE_CONV_REQD, /* 76 - caller must register conversion + callbacks using curl_easy_setopt options + CURLOPT_CONV_FROM_NETWORK_FUNCTION, + CURLOPT_CONV_TO_NETWORK_FUNCTION, and + CURLOPT_CONV_FROM_UTF8_FUNCTION */ + CURLE_SSL_CACERT_BADFILE, /* 77 - could not load CACERT file, missing + or wrong format */ + CURLE_REMOTE_FILE_NOT_FOUND, /* 78 - remote file not found */ + CURLE_SSH, /* 79 - error from the SSH layer, somewhat + generic so the error message will be of + interest when this has happened */ + + CURLE_SSL_SHUTDOWN_FAILED, /* 80 - Failed to shut down the SSL + connection */ + CURLE_AGAIN, /* 81 - socket is not ready for send/recv, + wait till it's ready and try again (Added + in 7.18.2) */ + CURLE_SSL_CRL_BADFILE, /* 82 - could not load CRL file, missing or + wrong format (Added in 7.19.0) */ + CURLE_SSL_ISSUER_ERROR, /* 83 - Issuer check failed. (Added in + 7.19.0) */ + CURLE_FTP_PRET_FAILED, /* 84 - a PRET command failed */ + CURLE_RTSP_CSEQ_ERROR, /* 85 - mismatch of RTSP CSeq numbers */ + CURLE_RTSP_SESSION_ERROR, /* 86 - mismatch of RTSP Session Ids */ + CURLE_FTP_BAD_FILE_LIST, /* 87 - unable to parse FTP file list */ + CURLE_CHUNK_FAILED, /* 88 - chunk callback reported error */ + + CURL_LAST /* never use! */ +} CURLcode; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* compatibility with older names */ +#define CURLOPT_ENCODING CURLOPT_ACCEPT_ENCODING + +/* The following were added in 7.21.5, April 2011 */ +#define CURLE_UNKNOWN_TELNET_OPTION CURLE_UNKNOWN_OPTION + +/* The following were added in 7.17.1 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_SSL_PEER_CERTIFICATE CURLE_PEER_FAILED_VERIFICATION + +/* The following were added in 7.17.0 */ +/* These are scheduled to disappear by 2009 */ +#define CURLE_OBSOLETE CURLE_OBSOLETE50 /* no one should be using this! */ +#define CURLE_BAD_PASSWORD_ENTERED CURLE_OBSOLETE46 +#define CURLE_BAD_CALLING_ORDER CURLE_OBSOLETE44 +#define CURLE_FTP_USER_PASSWORD_INCORRECT CURLE_OBSOLETE10 +#define CURLE_FTP_CANT_RECONNECT CURLE_OBSOLETE16 +#define CURLE_FTP_COULDNT_GET_SIZE CURLE_OBSOLETE32 +#define CURLE_FTP_COULDNT_SET_ASCII CURLE_OBSOLETE29 +#define CURLE_FTP_WEIRD_USER_REPLY CURLE_OBSOLETE12 +#define CURLE_FTP_WRITE_ERROR CURLE_OBSOLETE20 +#define CURLE_LIBRARY_NOT_FOUND CURLE_OBSOLETE40 +#define CURLE_MALFORMAT_USER CURLE_OBSOLETE24 +#define CURLE_SHARE_IN_USE CURLE_OBSOLETE57 +#define CURLE_URL_MALFORMAT_USER CURLE_NOT_BUILT_IN + +#define CURLE_FTP_ACCESS_DENIED CURLE_REMOTE_ACCESS_DENIED +#define CURLE_FTP_COULDNT_SET_BINARY CURLE_FTP_COULDNT_SET_TYPE +#define CURLE_FTP_QUOTE_ERROR CURLE_QUOTE_ERROR +#define CURLE_TFTP_DISKFULL CURLE_REMOTE_DISK_FULL +#define CURLE_TFTP_EXISTS CURLE_REMOTE_FILE_EXISTS +#define CURLE_HTTP_RANGE_ERROR CURLE_RANGE_ERROR +#define CURLE_FTP_SSL_FAILED CURLE_USE_SSL_FAILED + +/* The following were added earlier */ + +#define CURLE_OPERATION_TIMEOUTED CURLE_OPERATION_TIMEDOUT + +#define CURLE_HTTP_NOT_FOUND CURLE_HTTP_RETURNED_ERROR +#define CURLE_HTTP_PORT_FAILED CURLE_INTERFACE_FAILED +#define CURLE_FTP_COULDNT_STOR_FILE CURLE_UPLOAD_FAILED + +#define CURLE_FTP_PARTIAL_FILE CURLE_PARTIAL_FILE +#define CURLE_FTP_BAD_DOWNLOAD_RESUME CURLE_BAD_DOWNLOAD_RESUME + +/* This was the error code 50 in 7.7.3 and a few earlier versions, this + is no longer used by libcurl but is instead #defined here only to not + make programs break */ +#define CURLE_ALREADY_COMPLETE 99999 + +#endif /*!CURL_NO_OLDIES*/ + +/* This prototype applies to all conversion callbacks */ +typedef CURLcode (*curl_conv_callback)(char *buffer, size_t length); + +typedef CURLcode (*curl_ssl_ctx_callback)(CURL *curl, /* easy handle */ + void *ssl_ctx, /* actually an + OpenSSL SSL_CTX */ + void *userptr); + +typedef enum { + CURLPROXY_HTTP = 0, /* added in 7.10, new in 7.19.4 default is to use + CONNECT HTTP/1.1 */ + CURLPROXY_HTTP_1_0 = 1, /* added in 7.19.4, force to use CONNECT + HTTP/1.0 */ + CURLPROXY_SOCKS4 = 4, /* support added in 7.15.2, enum existed already + in 7.10 */ + CURLPROXY_SOCKS5 = 5, /* added in 7.10 */ + CURLPROXY_SOCKS4A = 6, /* added in 7.18.0 */ + CURLPROXY_SOCKS5_HOSTNAME = 7 /* Use the SOCKS5 protocol but pass along the + host name rather than the IP address. added + in 7.18.0 */ +} curl_proxytype; /* this enum was added in 7.10 */ + +#define CURLAUTH_NONE 0 /* nothing */ +#define CURLAUTH_BASIC (1<<0) /* Basic (default) */ +#define CURLAUTH_DIGEST (1<<1) /* Digest */ +#define CURLAUTH_GSSNEGOTIATE (1<<2) /* GSS-Negotiate */ +#define CURLAUTH_NTLM (1<<3) /* NTLM */ +#define CURLAUTH_DIGEST_IE (1<<4) /* Digest with IE flavour */ +#define CURLAUTH_NTLM_WB (1<<5) /* NTLM delegating to winbind helper */ +#define CURLAUTH_ONLY (1<<31) /* used together with a single other + type to force no auth or just that + single type */ +#define CURLAUTH_ANY (~CURLAUTH_DIGEST_IE) /* all fine types set */ +#define CURLAUTH_ANYSAFE (~(CURLAUTH_BASIC|CURLAUTH_DIGEST_IE)) + +#define CURLSSH_AUTH_ANY ~0 /* all types supported by the server */ +#define CURLSSH_AUTH_NONE 0 /* none allowed, silly but complete */ +#define CURLSSH_AUTH_PUBLICKEY (1<<0) /* public/private key files */ +#define CURLSSH_AUTH_PASSWORD (1<<1) /* password */ +#define CURLSSH_AUTH_HOST (1<<2) /* host key files */ +#define CURLSSH_AUTH_KEYBOARD (1<<3) /* keyboard interactive */ +#define CURLSSH_AUTH_DEFAULT CURLSSH_AUTH_ANY + +#define CURLGSSAPI_DELEGATION_NONE 0 /* no delegation (default) */ +#define CURLGSSAPI_DELEGATION_POLICY_FLAG (1<<0) /* if permitted by policy */ +#define CURLGSSAPI_DELEGATION_FLAG (1<<1) /* delegate always */ + +#define CURL_ERROR_SIZE 256 + +struct curl_khkey { + const char *key; /* points to a zero-terminated string encoded with base64 + if len is zero, otherwise to the "raw" data */ + size_t len; + enum type { + CURLKHTYPE_UNKNOWN, + CURLKHTYPE_RSA1, + CURLKHTYPE_RSA, + CURLKHTYPE_DSS + } keytype; +}; + +/* this is the set of return values expected from the curl_sshkeycallback + callback */ +enum curl_khstat { + CURLKHSTAT_FINE_ADD_TO_FILE, + CURLKHSTAT_FINE, + CURLKHSTAT_REJECT, /* reject the connection, return an error */ + CURLKHSTAT_DEFER, /* do not accept it, but we can't answer right now so + this causes a CURLE_DEFER error but otherwise the + connection will be left intact etc */ + CURLKHSTAT_LAST /* not for use, only a marker for last-in-list */ +}; + +/* this is the set of status codes pass in to the callback */ +enum curl_khmatch { + CURLKHMATCH_OK, /* match */ + CURLKHMATCH_MISMATCH, /* host found, key mismatch! */ + CURLKHMATCH_MISSING, /* no matching host/key found */ + CURLKHMATCH_LAST /* not for use, only a marker for last-in-list */ +}; + +typedef int + (*curl_sshkeycallback) (CURL *easy, /* easy handle */ + const struct curl_khkey *knownkey, /* known */ + const struct curl_khkey *foundkey, /* found */ + enum curl_khmatch, /* libcurl's view on the keys */ + void *clientp); /* custom pointer passed from app */ + +/* parameter for the CURLOPT_USE_SSL option */ +typedef enum { + CURLUSESSL_NONE, /* do not attempt to use SSL */ + CURLUSESSL_TRY, /* try using SSL, proceed anyway otherwise */ + CURLUSESSL_CONTROL, /* SSL for the control connection or fail */ + CURLUSESSL_ALL, /* SSL for all communication or fail */ + CURLUSESSL_LAST /* not an option, never use */ +} curl_usessl; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2009 */ + +#define CURLFTPSSL_NONE CURLUSESSL_NONE +#define CURLFTPSSL_TRY CURLUSESSL_TRY +#define CURLFTPSSL_CONTROL CURLUSESSL_CONTROL +#define CURLFTPSSL_ALL CURLUSESSL_ALL +#define CURLFTPSSL_LAST CURLUSESSL_LAST +#define curl_ftpssl curl_usessl +#endif /*!CURL_NO_OLDIES*/ + +/* parameter for the CURLOPT_FTP_SSL_CCC option */ +typedef enum { + CURLFTPSSL_CCC_NONE, /* do not send CCC */ + CURLFTPSSL_CCC_PASSIVE, /* Let the server initiate the shutdown */ + CURLFTPSSL_CCC_ACTIVE, /* Initiate the shutdown */ + CURLFTPSSL_CCC_LAST /* not an option, never use */ +} curl_ftpccc; + +/* parameter for the CURLOPT_FTPSSLAUTH option */ +typedef enum { + CURLFTPAUTH_DEFAULT, /* let libcurl decide */ + CURLFTPAUTH_SSL, /* use "AUTH SSL" */ + CURLFTPAUTH_TLS, /* use "AUTH TLS" */ + CURLFTPAUTH_LAST /* not an option, never use */ +} curl_ftpauth; + +/* parameter for the CURLOPT_FTP_CREATE_MISSING_DIRS option */ +typedef enum { + CURLFTP_CREATE_DIR_NONE, /* do NOT create missing dirs! */ + CURLFTP_CREATE_DIR, /* (FTP/SFTP) if CWD fails, try MKD and then CWD + again if MKD succeeded, for SFTP this does + similar magic */ + CURLFTP_CREATE_DIR_RETRY, /* (FTP only) if CWD fails, try MKD and then CWD + again even if MKD failed! */ + CURLFTP_CREATE_DIR_LAST /* not an option, never use */ +} curl_ftpcreatedir; + +/* parameter for the CURLOPT_FTP_FILEMETHOD option */ +typedef enum { + CURLFTPMETHOD_DEFAULT, /* let libcurl pick */ + CURLFTPMETHOD_MULTICWD, /* single CWD operation for each path part */ + CURLFTPMETHOD_NOCWD, /* no CWD at all */ + CURLFTPMETHOD_SINGLECWD, /* one CWD to full dir, then work on file */ + CURLFTPMETHOD_LAST /* not an option, never use */ +} curl_ftpmethod; + +/* CURLPROTO_ defines are for the CURLOPT_*PROTOCOLS options */ +#define CURLPROTO_HTTP (1<<0) +#define CURLPROTO_HTTPS (1<<1) +#define CURLPROTO_FTP (1<<2) +#define CURLPROTO_FTPS (1<<3) +#define CURLPROTO_SCP (1<<4) +#define CURLPROTO_SFTP (1<<5) +#define CURLPROTO_TELNET (1<<6) +#define CURLPROTO_LDAP (1<<7) +#define CURLPROTO_LDAPS (1<<8) +#define CURLPROTO_DICT (1<<9) +#define CURLPROTO_FILE (1<<10) +#define CURLPROTO_TFTP (1<<11) +#define CURLPROTO_IMAP (1<<12) +#define CURLPROTO_IMAPS (1<<13) +#define CURLPROTO_POP3 (1<<14) +#define CURLPROTO_POP3S (1<<15) +#define CURLPROTO_SMTP (1<<16) +#define CURLPROTO_SMTPS (1<<17) +#define CURLPROTO_RTSP (1<<18) +#define CURLPROTO_RTMP (1<<19) +#define CURLPROTO_RTMPT (1<<20) +#define CURLPROTO_RTMPE (1<<21) +#define CURLPROTO_RTMPTE (1<<22) +#define CURLPROTO_RTMPS (1<<23) +#define CURLPROTO_RTMPTS (1<<24) +#define CURLPROTO_GOPHER (1<<25) +#define CURLPROTO_ALL (~0) /* enable everything */ + +/* long may be 32 or 64 bits, but we should never depend on anything else + but 32 */ +#define CURLOPTTYPE_LONG 0 +#define CURLOPTTYPE_OBJECTPOINT 10000 +#define CURLOPTTYPE_FUNCTIONPOINT 20000 +#define CURLOPTTYPE_OFF_T 30000 + +/* name is uppercase CURLOPT_, + type is one of the defined CURLOPTTYPE_ + number is unique identifier */ +#ifdef CINIT +#undef CINIT +#endif + +#ifdef CURL_ISOCPP +#define CINIT(na,t,nu) CURLOPT_ ## na = CURLOPTTYPE_ ## t + nu +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLOPT_/**/name = type + number +#endif + +/* + * This macro-mania below setups the CURLOPT_[what] enum, to be used with + * curl_easy_setopt(). The first argument in the CINIT() macro is the [what] + * word. + */ + +typedef enum { + /* This is the FILE * or void * the regular output should be written to. */ + CINIT(FILE, OBJECTPOINT, 1), + + /* The full URL to get/put */ + CINIT(URL, OBJECTPOINT, 2), + + /* Port number to connect to, if other than default. */ + CINIT(PORT, LONG, 3), + + /* Name of proxy to use. */ + CINIT(PROXY, OBJECTPOINT, 4), + + /* "name:password" to use when fetching. */ + CINIT(USERPWD, OBJECTPOINT, 5), + + /* "name:password" to use with proxy. */ + CINIT(PROXYUSERPWD, OBJECTPOINT, 6), + + /* Range to get, specified as an ASCII string. */ + CINIT(RANGE, OBJECTPOINT, 7), + + /* not used */ + + /* Specified file stream to upload from (use as input): */ + CINIT(INFILE, OBJECTPOINT, 9), + + /* Buffer to receive error messages in, must be at least CURL_ERROR_SIZE + * bytes big. If this is not used, error messages go to stderr instead: */ + CINIT(ERRORBUFFER, OBJECTPOINT, 10), + + /* Function that will be called to store the output (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(WRITEFUNCTION, FUNCTIONPOINT, 11), + + /* Function that will be called to read the input (instead of fread). The + * parameters will use fread() syntax, make sure to follow them. */ + CINIT(READFUNCTION, FUNCTIONPOINT, 12), + + /* Time-out the read operation after this amount of seconds */ + CINIT(TIMEOUT, LONG, 13), + + /* If the CURLOPT_INFILE is used, this can be used to inform libcurl about + * how large the file being sent really is. That allows better error + * checking and better verifies that the upload was successful. -1 means + * unknown size. + * + * For large file support, there is also a _LARGE version of the key + * which takes an off_t type, allowing platforms with larger off_t + * sizes to handle larger files. See below for INFILESIZE_LARGE. + */ + CINIT(INFILESIZE, LONG, 14), + + /* POST static input fields. */ + CINIT(POSTFIELDS, OBJECTPOINT, 15), + + /* Set the referrer page (needed by some CGIs) */ + CINIT(REFERER, OBJECTPOINT, 16), + + /* Set the FTP PORT string (interface name, named or numerical IP address) + Use i.e '-' to use default address. */ + CINIT(FTPPORT, OBJECTPOINT, 17), + + /* Set the User-Agent string (examined by some CGIs) */ + CINIT(USERAGENT, OBJECTPOINT, 18), + + /* If the download receives less than "low speed limit" bytes/second + * during "low speed time" seconds, the operations is aborted. + * You could i.e if you have a pretty high speed connection, abort if + * it is less than 2000 bytes/sec during 20 seconds. + */ + + /* Set the "low speed limit" */ + CINIT(LOW_SPEED_LIMIT, LONG, 19), + + /* Set the "low speed time" */ + CINIT(LOW_SPEED_TIME, LONG, 20), + + /* Set the continuation offset. + * + * Note there is also a _LARGE version of this key which uses + * off_t types, allowing for large file offsets on platforms which + * use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. + */ + CINIT(RESUME_FROM, LONG, 21), + + /* Set cookie in request: */ + CINIT(COOKIE, OBJECTPOINT, 22), + + /* This points to a linked list of headers, struct curl_slist kind */ + CINIT(HTTPHEADER, OBJECTPOINT, 23), + + /* This points to a linked list of post entries, struct curl_httppost */ + CINIT(HTTPPOST, OBJECTPOINT, 24), + + /* name of the file keeping your private SSL-certificate */ + CINIT(SSLCERT, OBJECTPOINT, 25), + + /* password for the SSL or SSH private key */ + CINIT(KEYPASSWD, OBJECTPOINT, 26), + + /* send TYPE parameter? */ + CINIT(CRLF, LONG, 27), + + /* send linked-list of QUOTE commands */ + CINIT(QUOTE, OBJECTPOINT, 28), + + /* send FILE * or void * to store headers to, if you use a callback it + is simply passed to the callback unmodified */ + CINIT(WRITEHEADER, OBJECTPOINT, 29), + + /* point to a file to read the initial cookies from, also enables + "cookie awareness" */ + CINIT(COOKIEFILE, OBJECTPOINT, 31), + + /* What version to specifically try to use. + See CURL_SSLVERSION defines below. */ + CINIT(SSLVERSION, LONG, 32), + + /* What kind of HTTP time condition to use, see defines */ + CINIT(TIMECONDITION, LONG, 33), + + /* Time to use with the above condition. Specified in number of seconds + since 1 Jan 1970 */ + CINIT(TIMEVALUE, LONG, 34), + + /* 35 = OBSOLETE */ + + /* Custom request, for customizing the get command like + HTTP: DELETE, TRACE and others + FTP: to use a different list command + */ + CINIT(CUSTOMREQUEST, OBJECTPOINT, 36), + + /* HTTP request, for odd commands like DELETE, TRACE and others */ + CINIT(STDERR, OBJECTPOINT, 37), + + /* 38 is not used */ + + /* send linked-list of post-transfer QUOTE commands */ + CINIT(POSTQUOTE, OBJECTPOINT, 39), + + CINIT(WRITEINFO, OBJECTPOINT, 40), /* DEPRECATED, do not use! */ + + CINIT(VERBOSE, LONG, 41), /* talk a lot */ + CINIT(HEADER, LONG, 42), /* throw the header out too */ + CINIT(NOPROGRESS, LONG, 43), /* shut off the progress meter */ + CINIT(NOBODY, LONG, 44), /* use HEAD to get http document */ + CINIT(FAILONERROR, LONG, 45), /* no output on http error codes >= 300 */ + CINIT(UPLOAD, LONG, 46), /* this is an upload */ + CINIT(POST, LONG, 47), /* HTTP POST method */ + CINIT(DIRLISTONLY, LONG, 48), /* bare names when listing directories */ + + CINIT(APPEND, LONG, 50), /* Append instead of overwrite on upload! */ + + /* Specify whether to read the user+password from the .netrc or the URL. + * This must be one of the CURL_NETRC_* enums below. */ + CINIT(NETRC, LONG, 51), + + CINIT(FOLLOWLOCATION, LONG, 52), /* use Location: Luke! */ + + CINIT(TRANSFERTEXT, LONG, 53), /* transfer data in text/ASCII format */ + CINIT(PUT, LONG, 54), /* HTTP PUT */ + + /* 55 = OBSOLETE */ + + /* Function that will be called instead of the internal progress display + * function. This function should be defined as the curl_progress_callback + * prototype defines. */ + CINIT(PROGRESSFUNCTION, FUNCTIONPOINT, 56), + + /* Data passed to the progress callback */ + CINIT(PROGRESSDATA, OBJECTPOINT, 57), + + /* We want the referrer field set automatically when following locations */ + CINIT(AUTOREFERER, LONG, 58), + + /* Port of the proxy, can be set in the proxy string as well with: + "[host]:[port]" */ + CINIT(PROXYPORT, LONG, 59), + + /* size of the POST input data, if strlen() is not good to use */ + CINIT(POSTFIELDSIZE, LONG, 60), + + /* tunnel non-http operations through a HTTP proxy */ + CINIT(HTTPPROXYTUNNEL, LONG, 61), + + /* Set the interface string to use as outgoing network interface */ + CINIT(INTERFACE, OBJECTPOINT, 62), + + /* Set the krb4/5 security level, this also enables krb4/5 awareness. This + * is a string, 'clear', 'safe', 'confidential' or 'private'. If the string + * is set but doesn't match one of these, 'private' will be used. */ + CINIT(KRBLEVEL, OBJECTPOINT, 63), + + /* Set if we should verify the peer in ssl handshake, set 1 to verify. */ + CINIT(SSL_VERIFYPEER, LONG, 64), + + /* The CApath or CAfile used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAINFO, OBJECTPOINT, 65), + + /* 66 = OBSOLETE */ + /* 67 = OBSOLETE */ + + /* Maximum number of http redirects to follow */ + CINIT(MAXREDIRS, LONG, 68), + + /* Pass a long set to 1 to get the date of the requested document (if + possible)! Pass a zero to shut it off. */ + CINIT(FILETIME, LONG, 69), + + /* This points to a linked list of telnet options */ + CINIT(TELNETOPTIONS, OBJECTPOINT, 70), + + /* Max amount of cached alive connections */ + CINIT(MAXCONNECTS, LONG, 71), + + CINIT(CLOSEPOLICY, LONG, 72), /* DEPRECATED, do not use! */ + + /* 73 = OBSOLETE */ + + /* Set to explicitly use a new connection for the upcoming transfer. + Do not use this unless you're absolutely sure of this, as it makes the + operation slower and is less friendly for the network. */ + CINIT(FRESH_CONNECT, LONG, 74), + + /* Set to explicitly forbid the upcoming transfer's connection to be re-used + when done. Do not use this unless you're absolutely sure of this, as it + makes the operation slower and is less friendly for the network. */ + CINIT(FORBID_REUSE, LONG, 75), + + /* Set to a file name that contains random data for libcurl to use to + seed the random engine when doing SSL connects. */ + CINIT(RANDOM_FILE, OBJECTPOINT, 76), + + /* Set to the Entropy Gathering Daemon socket pathname */ + CINIT(EGDSOCKET, OBJECTPOINT, 77), + + /* Time-out connect operations after this amount of seconds, if connects + are OK within this time, then fine... This only aborts the connect + phase. [Only works on unix-style/SIGALRM operating systems] */ + CINIT(CONNECTTIMEOUT, LONG, 78), + + /* Function that will be called to store headers (instead of fwrite). The + * parameters will use fwrite() syntax, make sure to follow them. */ + CINIT(HEADERFUNCTION, FUNCTIONPOINT, 79), + + /* Set this to force the HTTP request to get back to GET. Only really usable + if POST, PUT or a custom request have been used first. + */ + CINIT(HTTPGET, LONG, 80), + + /* Set if we should verify the Common name from the peer certificate in ssl + * handshake, set 1 to check existence, 2 to ensure that it matches the + * provided hostname. */ + CINIT(SSL_VERIFYHOST, LONG, 81), + + /* Specify which file name to write all known cookies in after completed + operation. Set file name to "-" (dash) to make it go to stdout. */ + CINIT(COOKIEJAR, OBJECTPOINT, 82), + + /* Specify which SSL ciphers to use */ + CINIT(SSL_CIPHER_LIST, OBJECTPOINT, 83), + + /* Specify which HTTP version to use! This must be set to one of the + CURL_HTTP_VERSION* enums set below. */ + CINIT(HTTP_VERSION, LONG, 84), + + /* Specifically switch on or off the FTP engine's use of the EPSV command. By + default, that one will always be attempted before the more traditional + PASV command. */ + CINIT(FTP_USE_EPSV, LONG, 85), + + /* type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") */ + CINIT(SSLCERTTYPE, OBJECTPOINT, 86), + + /* name of the file keeping your private SSL-key */ + CINIT(SSLKEY, OBJECTPOINT, 87), + + /* type of the file keeping your private SSL-key ("DER", "PEM", "ENG") */ + CINIT(SSLKEYTYPE, OBJECTPOINT, 88), + + /* crypto engine for the SSL-sub system */ + CINIT(SSLENGINE, OBJECTPOINT, 89), + + /* set the crypto engine for the SSL-sub system as default + the param has no meaning... + */ + CINIT(SSLENGINE_DEFAULT, LONG, 90), + + /* Non-zero value means to use the global dns cache */ + CINIT(DNS_USE_GLOBAL_CACHE, LONG, 91), /* DEPRECATED, do not use! */ + + /* DNS cache timeout */ + CINIT(DNS_CACHE_TIMEOUT, LONG, 92), + + /* send linked-list of pre-transfer QUOTE commands */ + CINIT(PREQUOTE, OBJECTPOINT, 93), + + /* set the debug function */ + CINIT(DEBUGFUNCTION, FUNCTIONPOINT, 94), + + /* set the data for the debug function */ + CINIT(DEBUGDATA, OBJECTPOINT, 95), + + /* mark this as start of a cookie session */ + CINIT(COOKIESESSION, LONG, 96), + + /* The CApath directory used to validate the peer certificate + this option is used only if SSL_VERIFYPEER is true */ + CINIT(CAPATH, OBJECTPOINT, 97), + + /* Instruct libcurl to use a smaller receive buffer */ + CINIT(BUFFERSIZE, LONG, 98), + + /* Instruct libcurl to not use any signal/alarm handlers, even when using + timeouts. This option is useful for multi-threaded applications. + See libcurl-the-guide for more background information. */ + CINIT(NOSIGNAL, LONG, 99), + + /* Provide a CURLShare for mutexing non-ts data */ + CINIT(SHARE, OBJECTPOINT, 100), + + /* indicates type of proxy. accepted values are CURLPROXY_HTTP (default), + CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and CURLPROXY_SOCKS5. */ + CINIT(PROXYTYPE, LONG, 101), + + /* Set the Accept-Encoding string. Use this to tell a server you would like + the response to be compressed. Before 7.21.6, this was known as + CURLOPT_ENCODING */ + CINIT(ACCEPT_ENCODING, OBJECTPOINT, 102), + + /* Set pointer to private data */ + CINIT(PRIVATE, OBJECTPOINT, 103), + + /* Set aliases for HTTP 200 in the HTTP Response header */ + CINIT(HTTP200ALIASES, OBJECTPOINT, 104), + + /* Continue to send authentication (user+password) when following locations, + even when hostname changed. This can potentially send off the name + and password to whatever host the server decides. */ + CINIT(UNRESTRICTED_AUTH, LONG, 105), + + /* Specifically switch on or off the FTP engine's use of the EPRT command ( + it also disables the LPRT attempt). By default, those ones will always be + attempted before the good old traditional PORT command. */ + CINIT(FTP_USE_EPRT, LONG, 106), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_USERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(HTTPAUTH, LONG, 107), + + /* Set the ssl context callback function, currently only for OpenSSL ssl_ctx + in second argument. The function must be matching the + curl_ssl_ctx_callback proto. */ + CINIT(SSL_CTX_FUNCTION, FUNCTIONPOINT, 108), + + /* Set the userdata for the ssl context callback function's third + argument */ + CINIT(SSL_CTX_DATA, OBJECTPOINT, 109), + + /* FTP Option that causes missing dirs to be created on the remote server. + In 7.19.4 we introduced the convenience enums for this option using the + CURLFTP_CREATE_DIR prefix. + */ + CINIT(FTP_CREATE_MISSING_DIRS, LONG, 110), + + /* Set this to a bitmask value to enable the particular authentications + methods you like. Use this in combination with CURLOPT_PROXYUSERPWD. + Note that setting multiple bits may cause extra network round-trips. */ + CINIT(PROXYAUTH, LONG, 111), + + /* FTP option that changes the timeout, in seconds, associated with + getting a response. This is different from transfer timeout time and + essentially places a demand on the FTP server to acknowledge commands + in a timely manner. */ + CINIT(FTP_RESPONSE_TIMEOUT, LONG, 112), +#define CURLOPT_SERVER_RESPONSE_TIMEOUT CURLOPT_FTP_RESPONSE_TIMEOUT + + /* Set this option to one of the CURL_IPRESOLVE_* defines (see below) to + tell libcurl to resolve names to those IP versions only. This only has + affect on systems with support for more than one, i.e IPv4 _and_ IPv6. */ + CINIT(IPRESOLVE, LONG, 113), + + /* Set this option to limit the size of a file that will be downloaded from + an HTTP or FTP server. + + Note there is also _LARGE version which adds large file support for + platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. */ + CINIT(MAXFILESIZE, LONG, 114), + + /* See the comment for INFILESIZE above, but in short, specifies + * the size of the file being uploaded. -1 means unknown. + */ + CINIT(INFILESIZE_LARGE, OFF_T, 115), + + /* Sets the continuation offset. There is also a LONG version of this; + * look above for RESUME_FROM. + */ + CINIT(RESUME_FROM_LARGE, OFF_T, 116), + + /* Sets the maximum size of data that will be downloaded from + * an HTTP or FTP server. See MAXFILESIZE above for the LONG version. + */ + CINIT(MAXFILESIZE_LARGE, OFF_T, 117), + + /* Set this option to the file name of your .netrc file you want libcurl + to parse (using the CURLOPT_NETRC option). If not set, libcurl will do + a poor attempt to find the user's home directory and check for a .netrc + file in there. */ + CINIT(NETRC_FILE, OBJECTPOINT, 118), + + /* Enable SSL/TLS for FTP, pick one of: + CURLFTPSSL_TRY - try using SSL, proceed anyway otherwise + CURLFTPSSL_CONTROL - SSL for the control connection or fail + CURLFTPSSL_ALL - SSL for all communication or fail + */ + CINIT(USE_SSL, LONG, 119), + + /* The _LARGE version of the standard POSTFIELDSIZE option */ + CINIT(POSTFIELDSIZE_LARGE, OFF_T, 120), + + /* Enable/disable the TCP Nagle algorithm */ + CINIT(TCP_NODELAY, LONG, 121), + + /* 122 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 123 OBSOLETE. Gone in 7.16.0 */ + /* 124 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 125 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 126 OBSOLETE, used in 7.12.3. Gone in 7.13.0 */ + /* 127 OBSOLETE. Gone in 7.16.0 */ + /* 128 OBSOLETE. Gone in 7.16.0 */ + + /* When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option + can be used to change libcurl's default action which is to first try + "AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK + response has been received. + + Available parameters are: + CURLFTPAUTH_DEFAULT - let libcurl decide + CURLFTPAUTH_SSL - try "AUTH SSL" first, then TLS + CURLFTPAUTH_TLS - try "AUTH TLS" first, then SSL + */ + CINIT(FTPSSLAUTH, LONG, 129), + + CINIT(IOCTLFUNCTION, FUNCTIONPOINT, 130), + CINIT(IOCTLDATA, OBJECTPOINT, 131), + + /* 132 OBSOLETE. Gone in 7.16.0 */ + /* 133 OBSOLETE. Gone in 7.16.0 */ + + /* zero terminated string for pass on to the FTP server when asked for + "account" info */ + CINIT(FTP_ACCOUNT, OBJECTPOINT, 134), + + /* feed cookies into cookie engine */ + CINIT(COOKIELIST, OBJECTPOINT, 135), + + /* ignore Content-Length */ + CINIT(IGNORE_CONTENT_LENGTH, LONG, 136), + + /* Set to non-zero to skip the IP address received in a 227 PASV FTP server + response. Typically used for FTP-SSL purposes but is not restricted to + that. libcurl will then instead use the same IP address it used for the + control connection. */ + CINIT(FTP_SKIP_PASV_IP, LONG, 137), + + /* Select "file method" to use when doing FTP, see the curl_ftpmethod + above. */ + CINIT(FTP_FILEMETHOD, LONG, 138), + + /* Local port number to bind the socket to */ + CINIT(LOCALPORT, LONG, 139), + + /* Number of ports to try, including the first one set with LOCALPORT. + Thus, setting it to 1 will make no additional attempts but the first. + */ + CINIT(LOCALPORTRANGE, LONG, 140), + + /* no transfer, set up connection and let application use the socket by + extracting it with CURLINFO_LASTSOCKET */ + CINIT(CONNECT_ONLY, LONG, 141), + + /* Function that will be called to convert from the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_FROM_NETWORK_FUNCTION, FUNCTIONPOINT, 142), + + /* Function that will be called to convert to the + network encoding (instead of using the iconv calls in libcurl) */ + CINIT(CONV_TO_NETWORK_FUNCTION, FUNCTIONPOINT, 143), + + /* Function that will be called to convert from UTF8 + (instead of using the iconv calls in libcurl) + Note that this is used only for SSL certificate processing */ + CINIT(CONV_FROM_UTF8_FUNCTION, FUNCTIONPOINT, 144), + + /* if the connection proceeds too quickly then need to slow it down */ + /* limit-rate: maximum number of bytes per second to send or receive */ + CINIT(MAX_SEND_SPEED_LARGE, OFF_T, 145), + CINIT(MAX_RECV_SPEED_LARGE, OFF_T, 146), + + /* Pointer to command string to send if USER/PASS fails. */ + CINIT(FTP_ALTERNATIVE_TO_USER, OBJECTPOINT, 147), + + /* callback function for setting socket options */ + CINIT(SOCKOPTFUNCTION, FUNCTIONPOINT, 148), + CINIT(SOCKOPTDATA, OBJECTPOINT, 149), + + /* set to 0 to disable session ID re-use for this transfer, default is + enabled (== 1) */ + CINIT(SSL_SESSIONID_CACHE, LONG, 150), + + /* allowed SSH authentication methods */ + CINIT(SSH_AUTH_TYPES, LONG, 151), + + /* Used by scp/sftp to do public/private key authentication */ + CINIT(SSH_PUBLIC_KEYFILE, OBJECTPOINT, 152), + CINIT(SSH_PRIVATE_KEYFILE, OBJECTPOINT, 153), + + /* Send CCC (Clear Command Channel) after authentication */ + CINIT(FTP_SSL_CCC, LONG, 154), + + /* Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution */ + CINIT(TIMEOUT_MS, LONG, 155), + CINIT(CONNECTTIMEOUT_MS, LONG, 156), + + /* set to zero to disable the libcurl's decoding and thus pass the raw body + data to the application even when it is encoded/compressed */ + CINIT(HTTP_TRANSFER_DECODING, LONG, 157), + CINIT(HTTP_CONTENT_DECODING, LONG, 158), + + /* Permission used when creating new files and directories on the remote + server for protocols that support it, SFTP/SCP/FILE */ + CINIT(NEW_FILE_PERMS, LONG, 159), + CINIT(NEW_DIRECTORY_PERMS, LONG, 160), + + /* Set the behaviour of POST when redirecting. Values must be set to one + of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 */ + CINIT(POSTREDIR, LONG, 161), + + /* used by scp/sftp to verify the host's public key */ + CINIT(SSH_HOST_PUBLIC_KEY_MD5, OBJECTPOINT, 162), + + /* Callback function for opening socket (instead of socket(2)). Optionally, + callback is able change the address or refuse to connect returning + CURL_SOCKET_BAD. The callback should have type + curl_opensocket_callback */ + CINIT(OPENSOCKETFUNCTION, FUNCTIONPOINT, 163), + CINIT(OPENSOCKETDATA, OBJECTPOINT, 164), + + /* POST volatile input fields. */ + CINIT(COPYPOSTFIELDS, OBJECTPOINT, 165), + + /* set transfer mode (;type=) when doing FTP via an HTTP proxy */ + CINIT(PROXY_TRANSFER_MODE, LONG, 166), + + /* Callback function for seeking in the input stream */ + CINIT(SEEKFUNCTION, FUNCTIONPOINT, 167), + CINIT(SEEKDATA, OBJECTPOINT, 168), + + /* CRL file */ + CINIT(CRLFILE, OBJECTPOINT, 169), + + /* Issuer certificate */ + CINIT(ISSUERCERT, OBJECTPOINT, 170), + + /* (IPv6) Address scope */ + CINIT(ADDRESS_SCOPE, LONG, 171), + + /* Collect certificate chain info and allow it to get retrievable with + CURLINFO_CERTINFO after the transfer is complete. (Unfortunately) only + working with OpenSSL-powered builds. */ + CINIT(CERTINFO, LONG, 172), + + /* "name" and "pwd" to use when fetching. */ + CINIT(USERNAME, OBJECTPOINT, 173), + CINIT(PASSWORD, OBJECTPOINT, 174), + + /* "name" and "pwd" to use with Proxy when fetching. */ + CINIT(PROXYUSERNAME, OBJECTPOINT, 175), + CINIT(PROXYPASSWORD, OBJECTPOINT, 176), + + /* Comma separated list of hostnames defining no-proxy zones. These should + match both hostnames directly, and hostnames within a domain. For + example, local.com will match local.com and www.local.com, but NOT + notlocal.com or www.notlocal.com. For compatibility with other + implementations of this, .local.com will be considered to be the same as + local.com. A single * is the only valid wildcard, and effectively + disables the use of proxy. */ + CINIT(NOPROXY, OBJECTPOINT, 177), + + /* block size for TFTP transfers */ + CINIT(TFTP_BLKSIZE, LONG, 178), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_SERVICE, OBJECTPOINT, 179), + + /* Socks Service */ + CINIT(SOCKS5_GSSAPI_NEC, LONG, 180), + + /* set the bitmask for the protocols that are allowed to be used for the + transfer, which thus helps the app which takes URLs from users or other + external inputs and want to restrict what protocol(s) to deal + with. Defaults to CURLPROTO_ALL. */ + CINIT(PROTOCOLS, LONG, 181), + + /* set the bitmask for the protocols that libcurl is allowed to follow to, + as a subset of the CURLOPT_PROTOCOLS ones. That means the protocol needs + to be set in both bitmasks to be allowed to get redirected to. Defaults + to all protocols except FILE and SCP. */ + CINIT(REDIR_PROTOCOLS, LONG, 182), + + /* set the SSH knownhost file name to use */ + CINIT(SSH_KNOWNHOSTS, OBJECTPOINT, 183), + + /* set the SSH host key callback, must point to a curl_sshkeycallback + function */ + CINIT(SSH_KEYFUNCTION, FUNCTIONPOINT, 184), + + /* set the SSH host key callback custom pointer */ + CINIT(SSH_KEYDATA, OBJECTPOINT, 185), + + /* set the SMTP mail originator */ + CINIT(MAIL_FROM, OBJECTPOINT, 186), + + /* set the SMTP mail receiver(s) */ + CINIT(MAIL_RCPT, OBJECTPOINT, 187), + + /* FTP: send PRET before PASV */ + CINIT(FTP_USE_PRET, LONG, 188), + + /* RTSP request method (OPTIONS, SETUP, PLAY, etc...) */ + CINIT(RTSP_REQUEST, LONG, 189), + + /* The RTSP session identifier */ + CINIT(RTSP_SESSION_ID, OBJECTPOINT, 190), + + /* The RTSP stream URI */ + CINIT(RTSP_STREAM_URI, OBJECTPOINT, 191), + + /* The Transport: header to use in RTSP requests */ + CINIT(RTSP_TRANSPORT, OBJECTPOINT, 192), + + /* Manually initialize the client RTSP CSeq for this handle */ + CINIT(RTSP_CLIENT_CSEQ, LONG, 193), + + /* Manually initialize the server RTSP CSeq for this handle */ + CINIT(RTSP_SERVER_CSEQ, LONG, 194), + + /* The stream to pass to INTERLEAVEFUNCTION. */ + CINIT(INTERLEAVEDATA, OBJECTPOINT, 195), + + /* Let the application define a custom write method for RTP data */ + CINIT(INTERLEAVEFUNCTION, FUNCTIONPOINT, 196), + + /* Turn on wildcard matching */ + CINIT(WILDCARDMATCH, LONG, 197), + + /* Directory matching callback called before downloading of an + individual file (chunk) started */ + CINIT(CHUNK_BGN_FUNCTION, FUNCTIONPOINT, 198), + + /* Directory matching callback called after the file (chunk) + was downloaded, or skipped */ + CINIT(CHUNK_END_FUNCTION, FUNCTIONPOINT, 199), + + /* Change match (fnmatch-like) callback for wildcard matching */ + CINIT(FNMATCH_FUNCTION, FUNCTIONPOINT, 200), + + /* Let the application define custom chunk data pointer */ + CINIT(CHUNK_DATA, OBJECTPOINT, 201), + + /* FNMATCH_FUNCTION user pointer */ + CINIT(FNMATCH_DATA, OBJECTPOINT, 202), + + /* send linked-list of name:port:address sets */ + CINIT(RESOLVE, OBJECTPOINT, 203), + + /* Set a username for authenticated TLS */ + CINIT(TLSAUTH_USERNAME, OBJECTPOINT, 204), + + /* Set a password for authenticated TLS */ + CINIT(TLSAUTH_PASSWORD, OBJECTPOINT, 205), + + /* Set authentication type for authenticated TLS */ + CINIT(TLSAUTH_TYPE, OBJECTPOINT, 206), + + /* Set to 1 to enable the "TE:" header in HTTP requests to ask for + compressed transfer-encoded responses. Set to 0 to disable the use of TE: + in outgoing requests. The current default is 0, but it might change in a + future libcurl release. + + libcurl will ask for the compressed methods it knows of, and if that + isn't any, it will not ask for transfer-encoding at all even if this + option is set to 1. + + */ + CINIT(TRANSFER_ENCODING, LONG, 207), + + /* Callback function for closing socket (instead of close(2)). The callback + should have type curl_closesocket_callback */ + CINIT(CLOSESOCKETFUNCTION, FUNCTIONPOINT, 208), + CINIT(CLOSESOCKETDATA, OBJECTPOINT, 209), + + /* allow GSSAPI credential delegation */ + CINIT(GSSAPI_DELEGATION, LONG, 210), + + CURLOPT_LASTENTRY /* the last unused */ +} CURLoption; + +#ifndef CURL_NO_OLDIES /* define this to test if your app builds with all + the obsolete stuff removed! */ + +/* Backwards compatibility with older names */ +/* These are scheduled to disappear by 2011 */ + +/* This was added in version 7.19.1 */ +#define CURLOPT_POST301 CURLOPT_POSTREDIR + +/* These are scheduled to disappear by 2009 */ + +/* The following were added in 7.17.0 */ +#define CURLOPT_SSLKEYPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_FTPAPPEND CURLOPT_APPEND +#define CURLOPT_FTPLISTONLY CURLOPT_DIRLISTONLY +#define CURLOPT_FTP_SSL CURLOPT_USE_SSL + +/* The following were added earlier */ + +#define CURLOPT_SSLCERTPASSWD CURLOPT_KEYPASSWD +#define CURLOPT_KRB4LEVEL CURLOPT_KRBLEVEL + +#else +/* This is set if CURL_NO_OLDIES is defined at compile-time */ +#undef CURLOPT_DNS_USE_GLOBAL_CACHE /* soon obsolete */ +#endif + + + /* Below here follows defines for the CURLOPT_IPRESOLVE option. If a host + name resolves addresses using more than one IP protocol version, this + option might be handy to force libcurl to use a specific IP version. */ +#define CURL_IPRESOLVE_WHATEVER 0 /* default, resolves addresses to all IP + versions that your system allows */ +#define CURL_IPRESOLVE_V4 1 /* resolve to ipv4 addresses */ +#define CURL_IPRESOLVE_V6 2 /* resolve to ipv6 addresses */ + + /* three convenient "aliases" that follow the name scheme better */ +#define CURLOPT_WRITEDATA CURLOPT_FILE +#define CURLOPT_READDATA CURLOPT_INFILE +#define CURLOPT_HEADERDATA CURLOPT_WRITEHEADER +#define CURLOPT_RTSPHEADER CURLOPT_HTTPHEADER + + /* These enums are for use with the CURLOPT_HTTP_VERSION option. */ +enum { + CURL_HTTP_VERSION_NONE, /* setting this means we don't care, and that we'd + like the library to choose the best possible + for us! */ + CURL_HTTP_VERSION_1_0, /* please use HTTP 1.0 in the request */ + CURL_HTTP_VERSION_1_1, /* please use HTTP 1.1 in the request */ + + CURL_HTTP_VERSION_LAST /* *ILLEGAL* http version */ +}; + +/* + * Public API enums for RTSP requests + */ +enum { + CURL_RTSPREQ_NONE, /* first in list */ + CURL_RTSPREQ_OPTIONS, + CURL_RTSPREQ_DESCRIBE, + CURL_RTSPREQ_ANNOUNCE, + CURL_RTSPREQ_SETUP, + CURL_RTSPREQ_PLAY, + CURL_RTSPREQ_PAUSE, + CURL_RTSPREQ_TEARDOWN, + CURL_RTSPREQ_GET_PARAMETER, + CURL_RTSPREQ_SET_PARAMETER, + CURL_RTSPREQ_RECORD, + CURL_RTSPREQ_RECEIVE, + CURL_RTSPREQ_LAST /* last in list */ +}; + + /* These enums are for use with the CURLOPT_NETRC option. */ +enum CURL_NETRC_OPTION { + CURL_NETRC_IGNORED, /* The .netrc will never be read. + * This is the default. */ + CURL_NETRC_OPTIONAL, /* A user:password in the URL will be preferred + * to one in the .netrc. */ + CURL_NETRC_REQUIRED, /* A user:password in the URL will be ignored. + * Unless one is set programmatically, the .netrc + * will be queried. */ + CURL_NETRC_LAST +}; + +enum { + CURL_SSLVERSION_DEFAULT, + CURL_SSLVERSION_TLSv1, + CURL_SSLVERSION_SSLv2, + CURL_SSLVERSION_SSLv3, + + CURL_SSLVERSION_LAST /* never use, keep last */ +}; + +enum CURL_TLSAUTH { + CURL_TLSAUTH_NONE, + CURL_TLSAUTH_SRP, + CURL_TLSAUTH_LAST /* never use, keep last */ +}; + +/* symbols to use with CURLOPT_POSTREDIR. + CURL_REDIR_POST_301 and CURL_REDIR_POST_302 can be bitwise ORed so that + CURL_REDIR_POST_301 | CURL_REDIR_POST_302 == CURL_REDIR_POST_ALL */ + +#define CURL_REDIR_GET_ALL 0 +#define CURL_REDIR_POST_301 1 +#define CURL_REDIR_POST_302 2 +#define CURL_REDIR_POST_ALL (CURL_REDIR_POST_301|CURL_REDIR_POST_302) + +typedef enum { + CURL_TIMECOND_NONE, + + CURL_TIMECOND_IFMODSINCE, + CURL_TIMECOND_IFUNMODSINCE, + CURL_TIMECOND_LASTMOD, + + CURL_TIMECOND_LAST +} curl_TimeCond; + + +/* curl_strequal() and curl_strnequal() are subject for removal in a future + libcurl, see lib/README.curlx for details */ +CURL_EXTERN int (curl_strequal)(const char *s1, const char *s2); +CURL_EXTERN int (curl_strnequal)(const char *s1, const char *s2, size_t n); + +/* name is uppercase CURLFORM_ */ +#ifdef CFINIT +#undef CFINIT +#endif + +#ifdef CURL_ISOCPP +#define CFINIT(name) CURLFORM_ ## name +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define CFINIT(name) CURLFORM_/**/name +#endif + +typedef enum { + CFINIT(NOTHING), /********* the first one is unused ************/ + + /* */ + CFINIT(COPYNAME), + CFINIT(PTRNAME), + CFINIT(NAMELENGTH), + CFINIT(COPYCONTENTS), + CFINIT(PTRCONTENTS), + CFINIT(CONTENTSLENGTH), + CFINIT(FILECONTENT), + CFINIT(ARRAY), + CFINIT(OBSOLETE), + CFINIT(FILE), + + CFINIT(BUFFER), + CFINIT(BUFFERPTR), + CFINIT(BUFFERLENGTH), + + CFINIT(CONTENTTYPE), + CFINIT(CONTENTHEADER), + CFINIT(FILENAME), + CFINIT(END), + CFINIT(OBSOLETE2), + + CFINIT(STREAM), + + CURLFORM_LASTENTRY /* the last unused */ +} CURLformoption; + +#undef CFINIT /* done */ + +/* structure to be used as parameter for CURLFORM_ARRAY */ +struct curl_forms { + CURLformoption option; + const char *value; +}; + +/* use this for multipart formpost building */ +/* Returns code for curl_formadd() + * + * Returns: + * CURL_FORMADD_OK on success + * CURL_FORMADD_MEMORY if the FormInfo allocation fails + * CURL_FORMADD_OPTION_TWICE if one option is given twice for one Form + * CURL_FORMADD_NULL if a null pointer was given for a char + * CURL_FORMADD_MEMORY if the allocation of a FormInfo struct failed + * CURL_FORMADD_UNKNOWN_OPTION if an unknown option was used + * CURL_FORMADD_INCOMPLETE if the some FormInfo is not complete (or error) + * CURL_FORMADD_MEMORY if a curl_httppost struct cannot be allocated + * CURL_FORMADD_MEMORY if some allocation for string copying failed. + * CURL_FORMADD_ILLEGAL_ARRAY if an illegal option is used in an array + * + ***************************************************************************/ +typedef enum { + CURL_FORMADD_OK, /* first, no error */ + + CURL_FORMADD_MEMORY, + CURL_FORMADD_OPTION_TWICE, + CURL_FORMADD_NULL, + CURL_FORMADD_UNKNOWN_OPTION, + CURL_FORMADD_INCOMPLETE, + CURL_FORMADD_ILLEGAL_ARRAY, + CURL_FORMADD_DISABLED, /* libcurl was built with this disabled */ + + CURL_FORMADD_LAST /* last */ +} CURLFORMcode; + +/* + * NAME curl_formadd() + * + * DESCRIPTION + * + * Pretty advanced function for building multi-part formposts. Each invoke + * adds one part that together construct a full post. Then use + * CURLOPT_HTTPPOST to send it off to libcurl. + */ +CURL_EXTERN CURLFORMcode curl_formadd(struct curl_httppost **httppost, + struct curl_httppost **last_post, + ...); + +/* + * callback function for curl_formget() + * The void *arg pointer will be the one passed as second argument to + * curl_formget(). + * The character buffer passed to it must not be freed. + * Should return the buffer length passed to it as the argument "len" on + * success. + */ +typedef size_t (*curl_formget_callback)(void *arg, const char *buf, + size_t len); + +/* + * NAME curl_formget() + * + * DESCRIPTION + * + * Serialize a curl_httppost struct built with curl_formadd(). + * Accepts a void pointer as second argument which will be passed to + * the curl_formget_callback function. + * Returns 0 on success. + */ +CURL_EXTERN int curl_formget(struct curl_httppost *form, void *arg, + curl_formget_callback append); +/* + * NAME curl_formfree() + * + * DESCRIPTION + * + * Free a multipart formpost previously built with curl_formadd(). + */ +CURL_EXTERN void curl_formfree(struct curl_httppost *form); + +/* + * NAME curl_getenv() + * + * DESCRIPTION + * + * Returns a malloc()'ed string that MUST be curl_free()ed after usage is + * complete. DEPRECATED - see lib/README.curlx + */ +CURL_EXTERN char *curl_getenv(const char *variable); + +/* + * NAME curl_version() + * + * DESCRIPTION + * + * Returns a static ascii string of the libcurl version. + */ +CURL_EXTERN char *curl_version(void); + +/* + * NAME curl_easy_escape() + * + * DESCRIPTION + * + * Escapes URL strings (converts all letters consider illegal in URLs to their + * %XX versions). This function returns a new allocated string or NULL if an + * error occurred. + */ +CURL_EXTERN char *curl_easy_escape(CURL *handle, + const char *string, + int length); + +/* the previous version: */ +CURL_EXTERN char *curl_escape(const char *string, + int length); + + +/* + * NAME curl_easy_unescape() + * + * DESCRIPTION + * + * Unescapes URL encoding in strings (converts all %XX codes to their 8bit + * versions). This function returns a new allocated string or NULL if an error + * occurred. + * Conversion Note: On non-ASCII platforms the ASCII %XX codes are + * converted into the host encoding. + */ +CURL_EXTERN char *curl_easy_unescape(CURL *handle, + const char *string, + int length, + int *outlength); + +/* the previous version */ +CURL_EXTERN char *curl_unescape(const char *string, + int length); + +/* + * NAME curl_free() + * + * DESCRIPTION + * + * Provided for de-allocation in the same translation unit that did the + * allocation. Added in libcurl 7.10 + */ +CURL_EXTERN void curl_free(void *p); + +/* + * NAME curl_global_init() + * + * DESCRIPTION + * + * curl_global_init() should be invoked exactly once for each application that + * uses libcurl and before any call of other libcurl functions. + * + * This function is not thread-safe! + */ +CURL_EXTERN CURLcode curl_global_init(long flags); + +/* + * NAME curl_global_init_mem() + * + * DESCRIPTION + * + * curl_global_init() or curl_global_init_mem() should be invoked exactly once + * for each application that uses libcurl. This function can be used to + * initialize libcurl and set user defined memory management callback + * functions. Users can implement memory management routines to check for + * memory leaks, check for mis-use of the curl library etc. User registered + * callback routines with be invoked by this library instead of the system + * memory management routines like malloc, free etc. + */ +CURL_EXTERN CURLcode curl_global_init_mem(long flags, + curl_malloc_callback m, + curl_free_callback f, + curl_realloc_callback r, + curl_strdup_callback s, + curl_calloc_callback c); + +/* + * NAME curl_global_cleanup() + * + * DESCRIPTION + * + * curl_global_cleanup() should be invoked exactly once for each application + * that uses libcurl + */ +CURL_EXTERN void curl_global_cleanup(void); + +/* linked-list structure for the CURLOPT_QUOTE option (and other) */ +struct curl_slist { + char *data; + struct curl_slist *next; +}; + +/* + * NAME curl_slist_append() + * + * DESCRIPTION + * + * Appends a string to a linked list. If no list exists, it will be created + * first. Returns the new list, after appending. + */ +CURL_EXTERN struct curl_slist *curl_slist_append(struct curl_slist *, + const char *); + +/* + * NAME curl_slist_free_all() + * + * DESCRIPTION + * + * free a previously built curl_slist. + */ +CURL_EXTERN void curl_slist_free_all(struct curl_slist *); + +/* + * NAME curl_getdate() + * + * DESCRIPTION + * + * Returns the time, in seconds since 1 Jan 1970 of the time string given in + * the first argument. The time argument in the second parameter is unused + * and should be set to NULL. + */ +CURL_EXTERN time_t curl_getdate(const char *p, const time_t *unused); + +/* info about the certificate chain, only for OpenSSL builds. Asked + for with CURLOPT_CERTINFO / CURLINFO_CERTINFO */ +struct curl_certinfo { + int num_of_certs; /* number of certificates with information */ + struct curl_slist **certinfo; /* for each index in this array, there's a + linked list with textual information in the + format "name: value" */ +}; + +#define CURLINFO_STRING 0x100000 +#define CURLINFO_LONG 0x200000 +#define CURLINFO_DOUBLE 0x300000 +#define CURLINFO_SLIST 0x400000 +#define CURLINFO_MASK 0x0fffff +#define CURLINFO_TYPEMASK 0xf00000 + +typedef enum { + CURLINFO_NONE, /* first, never use this */ + CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1, + CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2, + CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3, + CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4, + CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5, + CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6, + CURLINFO_SIZE_UPLOAD = CURLINFO_DOUBLE + 7, + CURLINFO_SIZE_DOWNLOAD = CURLINFO_DOUBLE + 8, + CURLINFO_SPEED_DOWNLOAD = CURLINFO_DOUBLE + 9, + CURLINFO_SPEED_UPLOAD = CURLINFO_DOUBLE + 10, + CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11, + CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12, + CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13, + CURLINFO_FILETIME = CURLINFO_LONG + 14, + CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO_DOUBLE + 15, + CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO_DOUBLE + 16, + CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17, + CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18, + CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19, + CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20, + CURLINFO_PRIVATE = CURLINFO_STRING + 21, + CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22, + CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23, + CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24, + CURLINFO_OS_ERRNO = CURLINFO_LONG + 25, + CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26, + CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27, + CURLINFO_COOKIELIST = CURLINFO_SLIST + 28, + CURLINFO_LASTSOCKET = CURLINFO_LONG + 29, + CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30, + CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31, + CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32, + CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33, + CURLINFO_CERTINFO = CURLINFO_SLIST + 34, + CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35, + CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36, + CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37, + CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38, + CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39, + CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40, + CURLINFO_LOCAL_IP = CURLINFO_STRING + 41, + CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42, + /* Fill in new entries below here! */ + + CURLINFO_LASTONE = 42 +} CURLINFO; + +/* CURLINFO_RESPONSE_CODE is the new name for the option previously known as + CURLINFO_HTTP_CODE */ +#define CURLINFO_HTTP_CODE CURLINFO_RESPONSE_CODE + +typedef enum { + CURLCLOSEPOLICY_NONE, /* first, never use this */ + + CURLCLOSEPOLICY_OLDEST, + CURLCLOSEPOLICY_LEAST_RECENTLY_USED, + CURLCLOSEPOLICY_LEAST_TRAFFIC, + CURLCLOSEPOLICY_SLOWEST, + CURLCLOSEPOLICY_CALLBACK, + + CURLCLOSEPOLICY_LAST /* last, never use this */ +} curl_closepolicy; + +#define CURL_GLOBAL_SSL (1<<0) +#define CURL_GLOBAL_WIN32 (1<<1) +#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) +#define CURL_GLOBAL_NOTHING 0 +#define CURL_GLOBAL_DEFAULT CURL_GLOBAL_ALL + + +/***************************************************************************** + * Setup defines, protos etc for the sharing stuff. + */ + +/* Different data locks for a single share */ +typedef enum { + CURL_LOCK_DATA_NONE = 0, + /* CURL_LOCK_DATA_SHARE is used internally to say that + * the locking is just made to change the internal state of the share + * itself. + */ + CURL_LOCK_DATA_SHARE, + CURL_LOCK_DATA_COOKIE, + CURL_LOCK_DATA_DNS, + CURL_LOCK_DATA_SSL_SESSION, + CURL_LOCK_DATA_CONNECT, + CURL_LOCK_DATA_LAST +} curl_lock_data; + +/* Different lock access types */ +typedef enum { + CURL_LOCK_ACCESS_NONE = 0, /* unspecified action */ + CURL_LOCK_ACCESS_SHARED = 1, /* for read perhaps */ + CURL_LOCK_ACCESS_SINGLE = 2, /* for write perhaps */ + CURL_LOCK_ACCESS_LAST /* never use */ +} curl_lock_access; + +typedef void (*curl_lock_function)(CURL *handle, + curl_lock_data data, + curl_lock_access locktype, + void *userptr); +typedef void (*curl_unlock_function)(CURL *handle, + curl_lock_data data, + void *userptr); + +typedef void CURLSH; + +typedef enum { + CURLSHE_OK, /* all is fine */ + CURLSHE_BAD_OPTION, /* 1 */ + CURLSHE_IN_USE, /* 2 */ + CURLSHE_INVALID, /* 3 */ + CURLSHE_NOMEM, /* out of memory */ + CURLSHE_LAST /* never use */ +} CURLSHcode; + +typedef enum { + CURLSHOPT_NONE, /* don't use */ + CURLSHOPT_SHARE, /* specify a data type to share */ + CURLSHOPT_UNSHARE, /* specify which data type to stop sharing */ + CURLSHOPT_LOCKFUNC, /* pass in a 'curl_lock_function' pointer */ + CURLSHOPT_UNLOCKFUNC, /* pass in a 'curl_unlock_function' pointer */ + CURLSHOPT_USERDATA, /* pass in a user data pointer used in the lock/unlock + callback functions */ + CURLSHOPT_LAST /* never use */ +} CURLSHoption; + +CURL_EXTERN CURLSH *curl_share_init(void); +CURL_EXTERN CURLSHcode curl_share_setopt(CURLSH *, CURLSHoption option, ...); +CURL_EXTERN CURLSHcode curl_share_cleanup(CURLSH *); + +/**************************************************************************** + * Structures for querying information about the curl library at runtime. + */ + +typedef enum { + CURLVERSION_FIRST, + CURLVERSION_SECOND, + CURLVERSION_THIRD, + CURLVERSION_FOURTH, + CURLVERSION_LAST /* never actually use this */ +} CURLversion; + +/* The 'CURLVERSION_NOW' is the symbolic name meant to be used by + basically all programs ever that want to get version information. It is + meant to be a built-in version number for what kind of struct the caller + expects. If the struct ever changes, we redefine the NOW to another enum + from above. */ +#define CURLVERSION_NOW CURLVERSION_FOURTH + +typedef struct { + CURLversion age; /* age of the returned struct */ + const char *version; /* LIBCURL_VERSION */ + unsigned int version_num; /* LIBCURL_VERSION_NUM */ + const char *host; /* OS/host/cpu/machine when configured */ + int features; /* bitmask, see defines below */ + const char *ssl_version; /* human readable string */ + long ssl_version_num; /* not used anymore, always 0 */ + const char *libz_version; /* human readable string */ + /* protocols is terminated by an entry with a NULL protoname */ + const char * const *protocols; + + /* The fields below this were added in CURLVERSION_SECOND */ + const char *ares; + int ares_num; + + /* This field was added in CURLVERSION_THIRD */ + const char *libidn; + + /* These field were added in CURLVERSION_FOURTH */ + + /* Same as '_libiconv_version' if built with HAVE_ICONV */ + int iconv_ver_num; + + const char *libssh_version; /* human readable string */ + +} curl_version_info_data; + +#define CURL_VERSION_IPV6 (1<<0) /* IPv6-enabled */ +#define CURL_VERSION_KERBEROS4 (1<<1) /* kerberos auth is supported */ +#define CURL_VERSION_SSL (1<<2) /* SSL options are present */ +#define CURL_VERSION_LIBZ (1<<3) /* libz features are present */ +#define CURL_VERSION_NTLM (1<<4) /* NTLM auth is supported */ +#define CURL_VERSION_GSSNEGOTIATE (1<<5) /* Negotiate auth support */ +#define CURL_VERSION_DEBUG (1<<6) /* built with debug capabilities */ +#define CURL_VERSION_ASYNCHDNS (1<<7) /* asynchronous dns resolves */ +#define CURL_VERSION_SPNEGO (1<<8) /* SPNEGO auth */ +#define CURL_VERSION_LARGEFILE (1<<9) /* supports files bigger than 2GB */ +#define CURL_VERSION_IDN (1<<10) /* International Domain Names support */ +#define CURL_VERSION_SSPI (1<<11) /* SSPI is supported */ +#define CURL_VERSION_CONV (1<<12) /* character conversions supported */ +#define CURL_VERSION_CURLDEBUG (1<<13) /* debug memory tracking supported */ +#define CURL_VERSION_TLSAUTH_SRP (1<<14) /* TLS-SRP auth is supported */ +#define CURL_VERSION_NTLM_WB (1<<15) /* NTLM delegating to winbind helper */ + + /* + * NAME curl_version_info() + * + * DESCRIPTION + * + * This function returns a pointer to a static copy of the version info + * struct. See above. + */ +CURL_EXTERN curl_version_info_data *curl_version_info(CURLversion); + +/* + * NAME curl_easy_strerror() + * + * DESCRIPTION + * + * The curl_easy_strerror function may be used to turn a CURLcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_easy_strerror(CURLcode); + +/* + * NAME curl_share_strerror() + * + * DESCRIPTION + * + * The curl_share_strerror function may be used to turn a CURLSHcode value + * into the equivalent human readable error string. This is useful + * for printing meaningful error messages. + */ +CURL_EXTERN const char *curl_share_strerror(CURLSHcode); + +/* + * NAME curl_easy_pause() + * + * DESCRIPTION + * + * The curl_easy_pause function pauses or unpauses transfers. Select the new + * state by setting the bitmask, use the convenience defines below. + * + */ +CURL_EXTERN CURLcode curl_easy_pause(CURL *handle, int bitmask); + +#define CURLPAUSE_RECV (1<<0) +#define CURLPAUSE_RECV_CONT (0) + +#define CURLPAUSE_SEND (1<<2) +#define CURLPAUSE_SEND_CONT (0) + +#define CURLPAUSE_ALL (CURLPAUSE_RECV|CURLPAUSE_SEND) +#define CURLPAUSE_CONT (CURLPAUSE_RECV_CONT|CURLPAUSE_SEND_CONT) + +#ifdef __cplusplus +} +#endif + +/* unfortunately, the easy.h and multi.h include files need options and info + stuff before they can be included! */ +#include "easy.h" /* nothing in curl is fun without the easy stuff */ +#include "multi.h" + +/* the typechecker doesn't work in C++ (yet) */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && \ + ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) && \ + !defined(__cplusplus) && !defined(CURL_DISABLE_TYPECHECK) +#include "typecheck-gcc.h" +#else +#if defined(__STDC__) && (__STDC__ >= 1) +/* This preprocessor magic that replaces a call with the exact same call is + only done to make sure application authors pass exactly three arguments + to these functions. */ +#define curl_easy_setopt(handle,opt,param) curl_easy_setopt(handle,opt,param) +#define curl_easy_getinfo(handle,info,arg) curl_easy_getinfo(handle,info,arg) +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) +#endif /* __STDC__ >= 1 */ +#endif /* gcc >= 4.3 && !__cplusplus */ + +#endif /* __CURL_CURL_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/curlbuild.h b/doomsday/external/libcurl/portable/include/curl/curlbuild.h new file mode 100644 index 0000000000..d0b32acbec --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/curlbuild.h @@ -0,0 +1,583 @@ +#ifndef __CURL_CURLBUILD_H +#define __CURL_CURLBUILD_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* NOTES FOR CONFIGURE CAPABLE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * See file include/curl/curlbuild.h.in, run configure, and forget + * that this file exists it is only used for non-configure systems. + * But you can keep reading if you want ;-) + * + */ + +/* ================================================================ */ +/* NOTES FOR NON-CONFIGURE SYSTEMS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * If you think that something actually needs to be changed, adjusted + * or fixed in this file, then, report it on the libcurl development + * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * Try to keep one section per platform, compiler and architecture, + * otherwise, if an existing section is reused for a different one and + * later on the original is adjusted, probably the piggybacking one can + * be adversely changed. + * + * In order to differentiate between platforms/compilers/architectures + * use only compiler built in predefined preprocessor symbols. + * + * This header file shall only export symbols which are 'curl' or 'CURL' + * prefixed, otherwise public name space would be polluted. + * + * NOTE 2: + * ------- + * + * For any given platform/compiler curl_off_t must be typedef'ed to a + * 64-bit wide signed integral data type. The width of this data type + * must remain constant and independent of any possible large file + * support settings. + * + * As an exception to the above, curl_off_t shall be typedef'ed to a + * 32-bit wide signed integral data type if there is no 64-bit type. + * + * As a general rule, curl_off_t shall not be mapped to off_t. This + * rule shall only be violated if off_t is the only 64-bit data type + * available and the size of off_t is independent of large file support + * settings. Keep your build on the safe side avoiding an off_t gating. + * If you have a 64-bit off_t then take for sure that another 64-bit + * data type exists, dig deeper and you will find it. + * + * NOTE 3: + * ------- + * + * Right now you might be staring at file include/curl/curlbuild.h.dist or + * at file include/curl/curlbuild.h, this is due to the following reason: + * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h + * when the libcurl source code distribution archive file is created. + * + * File include/curl/curlbuild.h.dist is not included in the distribution + * archive. File include/curl/curlbuild.h is not present in the git tree. + * + * The distributed include/curl/curlbuild.h file is only intended to be used + * on systems which can not run the also distributed configure script. + * + * On systems capable of running the configure script, the configure process + * will overwrite the distributed include/curl/curlbuild.h file with one that + * is suitable and specific to the library being configured and built, which + * is generated from the include/curl/curlbuild.h.in template file. + * + * If you check out from git on a non-configure platform, you must run the + * appropriate buildconf* script to set up curlbuild.h and other local files. + * + */ + +/* ================================================================ */ +/* DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE */ +/* ================================================================ */ + +#ifdef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined +#endif + +#ifdef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined +#endif + +#ifdef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined +#endif + +#ifdef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined +#endif + +#ifdef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined +#endif + +/* ================================================================ */ +/* EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY */ +/* ================================================================ */ + +#if defined(__DJGPP__) || defined(__GO32__) +# if defined(__DJGPP__) && (__DJGPP__ > 1) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SALFORDC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__BORLANDC__) +# if (__BORLANDC__ < 0x520) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__TURBOC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__WATCOMC__) +# if defined(__386__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__POCC__) +# if (__POCC__ < 280) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# elif defined(_MSC_VER) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__LCC__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__SYMBIAN32__) +# if defined(__EABI__) /* Treat all ARM compilers equally */ +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__CW32__) +# pragma longlong on +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__VC32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MWERKS__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(_WIN32_WCE) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__MINGW32__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__VMS) +# if defined(__VAX) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +#elif defined(__OS400__) +# if defined(__ILEC400__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__MVS__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(__370__) +# if defined(__IBMC__) || defined(__IBMCPP__) +# if defined(_ILP32) +# define CURL_SIZEOF_LONG 4 +# elif defined(_LP64) +# define CURL_SIZEOF_LONG 8 +# endif +# if defined(_LONG_LONG) +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(_LP64) +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# else +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 +# endif + +#elif defined(TPF) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP MSVC THE PENULTIMATE ENTRY */ +/* ===================================== */ + +#elif defined(_MSC_VER) +# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T __int64 +# define CURL_FORMAT_CURL_OFF_T "I64d" +# define CURL_FORMAT_CURL_OFF_TU "I64u" +# define CURL_FORMAT_OFF_T "%I64d" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T i64 +# define CURL_SUFFIX_CURL_OFF_TU ui64 +# else +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 4 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T int +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 + +/* ===================================== */ +/* KEEP GENERIC GCC THE LAST ENTRY */ +/* ===================================== */ + +#elif defined(__GNUC__) +# if defined(__i386__) || defined(__ppc__) +# define CURL_SIZEOF_LONG 4 +# define CURL_TYPEOF_CURL_OFF_T long long +# define CURL_FORMAT_CURL_OFF_T "lld" +# define CURL_FORMAT_CURL_OFF_TU "llu" +# define CURL_FORMAT_OFF_T "%lld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T LL +# define CURL_SUFFIX_CURL_OFF_TU ULL +# elif defined(__x86_64__) || defined(__ppc64__) +# define CURL_SIZEOF_LONG 8 +# define CURL_TYPEOF_CURL_OFF_T long +# define CURL_FORMAT_CURL_OFF_T "ld" +# define CURL_FORMAT_CURL_OFF_TU "lu" +# define CURL_FORMAT_OFF_T "%ld" +# define CURL_SIZEOF_CURL_OFF_T 8 +# define CURL_SUFFIX_CURL_OFF_T L +# define CURL_SUFFIX_CURL_OFF_TU UL +# endif +# define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t +# define CURL_SIZEOF_CURL_SOCKLEN_T 4 +# define CURL_PULL_SYS_TYPES_H 1 +# define CURL_PULL_SYS_SOCKET_H 1 + +#else +# error "Unknown non-configure build target!" + Error Compilation_aborted_Unknown_non_configure_build_target +#endif + +/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file */ +/* sys/types.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_TYPES_H +# include +#endif + +/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file */ +/* sys/socket.h is required here to properly make type definitions below. */ +#ifdef CURL_PULL_SYS_SOCKET_H +# include +#endif + +/* Data type definition of curl_socklen_t. */ + +#ifdef CURL_TYPEOF_CURL_SOCKLEN_T + typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t; +#endif + +/* Data type definition of curl_off_t. */ + +#ifdef CURL_TYPEOF_CURL_OFF_T + typedef CURL_TYPEOF_CURL_OFF_T curl_off_t; +#endif + +#endif /* __CURL_CURLBUILD_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/curlrules.h b/doomsday/external/libcurl/portable/include/curl/curlrules.h new file mode 100644 index 0000000000..cbc12fdd29 --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/curlrules.h @@ -0,0 +1,261 @@ +#ifndef __CURL_CURLRULES_H +#define __CURL_CURLRULES_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2011, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* ================================================================ */ +/* COMPILE TIME SANITY CHECKS */ +/* ================================================================ */ + +/* + * NOTE 1: + * ------- + * + * All checks done in this file are intentionally placed in a public + * header file which is pulled by curl/curl.h when an application is + * being built using an already built libcurl library. Additionally + * this file is also included and used when building the library. + * + * If compilation fails on this file it is certainly sure that the + * problem is elsewhere. It could be a problem in the curlbuild.h + * header file, or simply that you are using different compilation + * settings than those used to build the library. + * + * Nothing in this file is intended to be modified or adjusted by the + * curl library user nor by the curl library builder. + * + * Do not deactivate any check, these are done to make sure that the + * library is properly built and used. + * + * You can find further help on the libcurl development mailing list: + * http://cool.haxx.se/mailman/listinfo/curl-library/ + * + * NOTE 2 + * ------ + * + * Some of the following compile time checks are based on the fact + * that the dimension of a constant array can not be a negative one. + * In this way if the compile time verification fails, the compilation + * will fail issuing an error. The error description wording is compiler + * dependent but it will be quite similar to one of the following: + * + * "negative subscript or subscript is too large" + * "array must have at least one element" + * "-1 is an illegal array size" + * "size of array is negative" + * + * If you are building an application which tries to use an already + * built libcurl library and you are getting this kind of errors on + * this file, it is a clear indication that there is a mismatch between + * how the library was built and how you are trying to use it for your + * application. Your already compiled or binary library provider is the + * only one who can give you the details you need to properly use it. + */ + +/* + * Verify that some macros are actually defined. + */ + +#ifndef CURL_SIZEOF_LONG +# error "CURL_SIZEOF_LONG definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_SOCKLEN_T +# error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_SOCKLEN_T +# error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing +#endif + +#ifndef CURL_TYPEOF_CURL_OFF_T +# error "CURL_TYPEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_T +# error "CURL_FORMAT_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_FORMAT_CURL_OFF_TU +# error "CURL_FORMAT_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing +#endif + +#ifndef CURL_FORMAT_OFF_T +# error "CURL_FORMAT_OFF_T definition is missing!" + Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing +#endif + +#ifndef CURL_SIZEOF_CURL_OFF_T +# error "CURL_SIZEOF_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_T +# error "CURL_SUFFIX_CURL_OFF_T definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing +#endif + +#ifndef CURL_SUFFIX_CURL_OFF_TU +# error "CURL_SUFFIX_CURL_OFF_TU definition is missing!" + Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing +#endif + +/* + * Macros private to this header file. + */ + +#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1 + +#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1 + +/* + * Verify that the size previously defined and expected for long + * is the same as the one reported by sizeof() at compile time. + */ + +typedef char + __curl_rule_01__ + [CurlchkszEQ(long, CURL_SIZEOF_LONG)]; + +/* + * Verify that the size previously defined and expected for + * curl_off_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_02__ + [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)]; + +/* + * Verify at compile time that the size of curl_off_t as reported + * by sizeof() is greater or equal than the one reported for long + * for the current compilation. + */ + +typedef char + __curl_rule_03__ + [CurlchkszGE(curl_off_t, long)]; + +/* + * Verify that the size previously defined and expected for + * curl_socklen_t is actually the the same as the one reported + * by sizeof() at compile time. + */ + +typedef char + __curl_rule_04__ + [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)]; + +/* + * Verify at compile time that the size of curl_socklen_t as reported + * by sizeof() is greater or equal than the one reported for int for + * the current compilation. + */ + +typedef char + __curl_rule_05__ + [CurlchkszGE(curl_socklen_t, int)]; + +/* ================================================================ */ +/* EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS */ +/* ================================================================ */ + +/* + * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow + * these to be visible and exported by the external libcurl interface API, + * while also making them visible to the library internals, simply including + * setup.h, without actually needing to include curl.h internally. + * If some day this section would grow big enough, all this should be moved + * to its own header file. + */ + +/* + * Figure out if we can use the ## preprocessor operator, which is supported + * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__ + * or __cplusplus so we need to carefully check for them too. + */ + +#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \ + defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \ + defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \ + defined(__ILEC400__) + /* This compiler is believed to have an ISO compatible preprocessor */ +#define CURL_ISOCPP +#else + /* This compiler is believed NOT to have an ISO compatible preprocessor */ +#undef CURL_ISOCPP +#endif + +/* + * Macros for minimum-width signed and unsigned curl_off_t integer constants. + */ + +#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551) +# define __CURL_OFF_T_C_HLPR2(x) x +# define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \ + __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU) +#else +# ifdef CURL_ISOCPP +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix +# else +# define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix +# endif +# define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix) +# define CURL_OFF_T_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T) +# define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU) +#endif + +/* + * Get rid of macros private to this header file. + */ + +#undef CurlchkszEQ +#undef CurlchkszGE + +/* + * Get rid of macros not intended to exist beyond this point. + */ + +#undef CURL_PULL_WS2TCPIP_H +#undef CURL_PULL_SYS_TYPES_H +#undef CURL_PULL_SYS_SOCKET_H +#undef CURL_PULL_STDINT_H +#undef CURL_PULL_INTTYPES_H + +#undef CURL_TYPEOF_CURL_SOCKLEN_T +#undef CURL_TYPEOF_CURL_OFF_T + +#ifdef CURL_NO_OLDIES +#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */ +#endif + +#endif /* __CURL_CURLRULES_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/curlver.h b/doomsday/external/libcurl/portable/include/curl/curlver.h new file mode 100644 index 0000000000..c2357b43df --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/curlver.h @@ -0,0 +1,69 @@ +#ifndef __CURL_CURLVER_H +#define __CURL_CURLVER_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2011, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* This header file contains nothing but libcurl version info, generated by + a script at release-time. This was made its own header file in 7.11.2 */ + +/* This is the global package copyright */ +#define LIBCURL_COPYRIGHT "1996 - 2011 Daniel Stenberg, ." + +/* This is the version number of the libcurl package from which this header + file origins: */ +#define LIBCURL_VERSION "7.22.0" + +/* The numeric version number is also available "in parts" by using these + defines: */ +#define LIBCURL_VERSION_MAJOR 7 +#define LIBCURL_VERSION_MINOR 22 +#define LIBCURL_VERSION_PATCH 0 + +/* This is the numeric version of the libcurl version number, meant for easier + parsing and comparions by programs. The LIBCURL_VERSION_NUM define will + always follow this syntax: + + 0xXXYYZZ + + Where XX, YY and ZZ are the main version, release and patch numbers in + hexadecimal (using 8 bits each). All three numbers are always represented + using two digits. 1.2 would appear as "0x010200" while version 9.11.7 + appears as "0x090b07". + + This 6-digit (24 bits) hexadecimal number does not show pre-release number, + and it is always a greater number in a more recent release. It makes + comparisons with greater than and less than work. +*/ +#define LIBCURL_VERSION_NUM 0x071600 + +/* + * This is the date and time when the full source package was created. The + * timestamp is not stored in git, as the timestamp is properly set in the + * tarballs by the maketgz script. + * + * The format of the date should follow this template: + * + * "Mon Feb 12 11:35:33 UTC 2007" + */ +#define LIBCURL_TIMESTAMP "Tue Sep 13 16:53:51 UTC 2011" + +#endif /* __CURL_CURLVER_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/easy.h b/doomsday/external/libcurl/portable/include/curl/easy.h new file mode 100644 index 0000000000..c1e3e76096 --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/easy.h @@ -0,0 +1,102 @@ +#ifndef __CURL_EASY_H +#define __CURL_EASY_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2008, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN CURL *curl_easy_init(void); +CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...); +CURL_EXTERN CURLcode curl_easy_perform(CURL *curl); +CURL_EXTERN void curl_easy_cleanup(CURL *curl); + +/* + * NAME curl_easy_getinfo() + * + * DESCRIPTION + * + * Request internal information from the curl session with this function. The + * third argument MUST be a pointer to a long, a pointer to a char * or a + * pointer to a double (as the documentation describes elsewhere). The data + * pointed to will be filled in accordingly and can be relied upon only if the + * function returns CURLE_OK. This function is intended to get used *AFTER* a + * performed transfer, all results from this function are undefined until the + * transfer is completed. + */ +CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...); + + +/* + * NAME curl_easy_duphandle() + * + * DESCRIPTION + * + * Creates a new curl session handle with the same options set for the handle + * passed in. Duplicating a handle could only be a matter of cloning data and + * options, internal state info and things like persistent connections cannot + * be transferred. It is useful in multithreaded applications when you can run + * curl_easy_duphandle() for each new thread to avoid a series of identical + * curl_easy_setopt() invokes in every thread. + */ +CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl); + +/* + * NAME curl_easy_reset() + * + * DESCRIPTION + * + * Re-initializes a CURL handle to the default values. This puts back the + * handle to the same state as it was in when it was just created. + * + * It does keep: live connections, the Session ID cache, the DNS cache and the + * cookies. + */ +CURL_EXTERN void curl_easy_reset(CURL *curl); + +/* + * NAME curl_easy_recv() + * + * DESCRIPTION + * + * Receives data from the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen, + size_t *n); + +/* + * NAME curl_easy_send() + * + * DESCRIPTION + * + * Sends data over the connected socket. Use after successful + * curl_easy_perform() with CURLOPT_CONNECT_ONLY option. + */ +CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer, + size_t buflen, size_t *n); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/doomsday/external/libcurl/portable/include/curl/mprintf.h b/doomsday/external/libcurl/portable/include/curl/mprintf.h new file mode 100644 index 0000000000..de7dd2f3c3 --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/mprintf.h @@ -0,0 +1,81 @@ +#ifndef __CURL_MPRINTF_H +#define __CURL_MPRINTF_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2006, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include +#include /* needed for FILE */ + +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +CURL_EXTERN int curl_mprintf(const char *format, ...); +CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...); +CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...); +CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength, + const char *format, ...); +CURL_EXTERN int curl_mvprintf(const char *format, va_list args); +CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args); +CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args); +CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength, + const char *format, va_list args); +CURL_EXTERN char *curl_maprintf(const char *format, ...); +CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args); + +#ifdef _MPRINTF_REPLACE +# undef printf +# undef fprintf +# undef sprintf +# undef vsprintf +# undef snprintf +# undef vprintf +# undef vfprintf +# undef vsnprintf +# undef aprintf +# undef vaprintf +# define printf curl_mprintf +# define fprintf curl_mfprintf +#ifdef CURLDEBUG +/* When built with CURLDEBUG we define away the sprintf() functions since we + don't want internal code to be using them */ +# define sprintf sprintf_was_used +# define vsprintf vsprintf_was_used +#else +# define sprintf curl_msprintf +# define vsprintf curl_mvsprintf +#endif +# define snprintf curl_msnprintf +# define vprintf curl_mvprintf +# define vfprintf curl_mvfprintf +# define vsnprintf curl_mvsnprintf +# define aprintf curl_maprintf +# define vaprintf curl_mvaprintf +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __CURL_MPRINTF_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/multi.h b/doomsday/external/libcurl/portable/include/curl/multi.h new file mode 100644 index 0000000000..f96566669c --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/multi.h @@ -0,0 +1,345 @@ +#ifndef __CURL_MULTI_H +#define __CURL_MULTI_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2007, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ +/* + This is an "external" header file. Don't give away any internals here! + + GOALS + + o Enable a "pull" interface. The application that uses libcurl decides where + and when to ask libcurl to get/send data. + + o Enable multiple simultaneous transfers in the same thread without making it + complicated for the application. + + o Enable the application to select() on its own file descriptors and curl's + file descriptors simultaneous easily. + +*/ + +/* + * This header file should not really need to include "curl.h" since curl.h + * itself includes this file and we expect user applications to do #include + * without the need for especially including multi.h. + * + * For some reason we added this include here at one point, and rather than to + * break existing (wrongly written) libcurl applications, we leave it as-is + * but with this warning attached. + */ +#include "curl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void CURLM; + +typedef enum { + CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or + curl_multi_socket*() soon */ + CURLM_OK, + CURLM_BAD_HANDLE, /* the passed-in handle is not a valid CURLM handle */ + CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */ + CURLM_OUT_OF_MEMORY, /* if you ever get this, you're in deep sh*t */ + CURLM_INTERNAL_ERROR, /* this is a libcurl bug */ + CURLM_BAD_SOCKET, /* the passed in socket argument did not match */ + CURLM_UNKNOWN_OPTION, /* curl_multi_setopt() with unsupported option */ + CURLM_LAST +} CURLMcode; + +/* just to make code nicer when using curl_multi_socket() you can now check + for CURLM_CALL_MULTI_SOCKET too in the same style it works for + curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */ +#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM + +typedef enum { + CURLMSG_NONE, /* first, not used */ + CURLMSG_DONE, /* This easy handle has completed. 'result' contains + the CURLcode of the transfer */ + CURLMSG_LAST /* last, not used */ +} CURLMSG; + +struct CURLMsg { + CURLMSG msg; /* what this message means */ + CURL *easy_handle; /* the handle it concerns */ + union { + void *whatever; /* message-specific data */ + CURLcode result; /* return code for transfer */ + } data; +}; +typedef struct CURLMsg CURLMsg; + +/* + * Name: curl_multi_init() + * + * Desc: inititalize multi-style curl usage + * + * Returns: a new CURLM handle to use in all 'curl_multi' functions. + */ +CURL_EXTERN CURLM *curl_multi_init(void); + +/* + * Name: curl_multi_add_handle() + * + * Desc: add a standard curl handle to the multi stack + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_remove_handle() + * + * Desc: removes a curl handle from the multi stack again + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle, + CURL *curl_handle); + + /* + * Name: curl_multi_fdset() + * + * Desc: Ask curl for its fd_set sets. The app can use these to select() or + * poll() on. We want curl_multi_perform() called as soon as one of + * them are ready. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle, + fd_set *read_fd_set, + fd_set *write_fd_set, + fd_set *exc_fd_set, + int *max_fd); + + /* + * Name: curl_multi_perform() + * + * Desc: When the app thinks there's data available for curl it calls this + * function to read/write whatever there is right now. This returns + * as soon as the reads and writes are done. This function does not + * require that there actually is data available for reading or that + * data can be written, it can be called just in case. It returns + * the number of handles that still transfer data in the second + * argument's integer-pointer. + * + * Returns: CURLMcode type, general multi error code. *NOTE* that this only + * returns errors etc regarding the whole multi stack. There might + * still have occurred problems on invidual transfers even when this + * returns OK. + */ +CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle, + int *running_handles); + + /* + * Name: curl_multi_cleanup() + * + * Desc: Cleans up and removes a whole multi stack. It does not free or + * touch any individual easy handles in any way. We need to define + * in what state those handles will be if this function is called + * in the middle of a transfer. + * + * Returns: CURLMcode type, general multi error code. + */ +CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle); + +/* + * Name: curl_multi_info_read() + * + * Desc: Ask the multi handle if there's any messages/informationals from + * the individual transfers. Messages include informationals such as + * error code from the transfer or just the fact that a transfer is + * completed. More details on these should be written down as well. + * + * Repeated calls to this function will return a new struct each + * time, until a special "end of msgs" struct is returned as a signal + * that there is no more to get at this point. + * + * The data the returned pointer points to will not survive calling + * curl_multi_cleanup(). + * + * The 'CURLMsg' struct is meant to be very simple and only contain + * very basic informations. If more involved information is wanted, + * we will provide the particular "transfer handle" in that struct + * and that should/could/would be used in subsequent + * curl_easy_getinfo() calls (or similar). The point being that we + * must never expose complex structs to applications, as then we'll + * undoubtably get backwards compatibility problems in the future. + * + * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out + * of structs. It also writes the number of messages left in the + * queue (after this read) in the integer the second argument points + * to. + */ +CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle, + int *msgs_in_queue); + +/* + * Name: curl_multi_strerror() + * + * Desc: The curl_multi_strerror function may be used to turn a CURLMcode + * value into the equivalent human readable error string. This is + * useful for printing meaningful error messages. + * + * Returns: A pointer to a zero-terminated error message. + */ +CURL_EXTERN const char *curl_multi_strerror(CURLMcode); + +/* + * Name: curl_multi_socket() and + * curl_multi_socket_all() + * + * Desc: An alternative version of curl_multi_perform() that allows the + * application to pass in one of the file descriptors that have been + * detected to have "action" on them and let libcurl perform. + * See man page for details. + */ +#define CURL_POLL_NONE 0 +#define CURL_POLL_IN 1 +#define CURL_POLL_OUT 2 +#define CURL_POLL_INOUT 3 +#define CURL_POLL_REMOVE 4 + +#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD + +#define CURL_CSELECT_IN 0x01 +#define CURL_CSELECT_OUT 0x02 +#define CURL_CSELECT_ERR 0x04 + +typedef int (*curl_socket_callback)(CURL *easy, /* easy handle */ + curl_socket_t s, /* socket */ + int what, /* see above */ + void *userp, /* private callback + pointer */ + void *socketp); /* private socket + pointer */ +/* + * Name: curl_multi_timer_callback + * + * Desc: Called by libcurl whenever the library detects a change in the + * maximum number of milliseconds the app is allowed to wait before + * curl_multi_socket() or curl_multi_perform() must be called + * (to allow libcurl's timed events to take place). + * + * Returns: The callback should return zero. + */ +typedef int (*curl_multi_timer_callback)(CURLM *multi, /* multi handle */ + long timeout_ms, /* see above */ + void *userp); /* private callback + pointer */ + +CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle, + curl_socket_t s, + int ev_bitmask, + int *running_handles); + +CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle, + int *running_handles); + +#ifndef CURL_ALLOW_OLD_MULTI_SOCKET +/* This macro below was added in 7.16.3 to push users who recompile to use + the new curl_multi_socket_action() instead of the old curl_multi_socket() +*/ +#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z) +#endif + +/* + * Name: curl_multi_timeout() + * + * Desc: Returns the maximum number of milliseconds the app is allowed to + * wait before curl_multi_socket() or curl_multi_perform() must be + * called (to allow libcurl's timed events to take place). + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle, + long *milliseconds); + +#undef CINIT /* re-using the same name as in curl.h */ + +#ifdef CURL_ISOCPP +#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num +#else +/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */ +#define LONG CURLOPTTYPE_LONG +#define OBJECTPOINT CURLOPTTYPE_OBJECTPOINT +#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT +#define OFF_T CURLOPTTYPE_OFF_T +#define CINIT(name,type,number) CURLMOPT_/**/name = type + number +#endif + +typedef enum { + /* This is the socket callback function pointer */ + CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1), + + /* This is the argument passed to the socket callback */ + CINIT(SOCKETDATA, OBJECTPOINT, 2), + + /* set to 1 to enable pipelining for this multi handle */ + CINIT(PIPELINING, LONG, 3), + + /* This is the timer callback function pointer */ + CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4), + + /* This is the argument passed to the timer callback */ + CINIT(TIMERDATA, OBJECTPOINT, 5), + + /* maximum number of entries in the connection cache */ + CINIT(MAXCONNECTS, LONG, 6), + + CURLMOPT_LASTENTRY /* the last unused */ +} CURLMoption; + + +/* + * Name: curl_multi_setopt() + * + * Desc: Sets options for the multi handle. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle, + CURLMoption option, ...); + + +/* + * Name: curl_multi_assign() + * + * Desc: This function sets an association in the multi handle between the + * given socket and a private pointer of the application. This is + * (only) useful for curl_multi_socket uses. + * + * Returns: CURLM error code. + */ +CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle, + curl_socket_t sockfd, void *sockp); + +#ifdef __cplusplus +} /* end of extern "C" */ +#endif + +#endif diff --git a/doomsday/external/libcurl/portable/include/curl/stdcheaders.h b/doomsday/external/libcurl/portable/include/curl/stdcheaders.h new file mode 100644 index 0000000000..ad82ef6335 --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/stdcheaders.h @@ -0,0 +1,33 @@ +#ifndef __STDC_HEADERS_H +#define __STDC_HEADERS_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2010, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +#include + +size_t fread (void *, size_t, size_t, FILE *); +size_t fwrite (const void *, size_t, size_t, FILE *); + +int strcasecmp(const char *, const char *); +int strncasecmp(const char *, const char *, size_t); + +#endif /* __STDC_HEADERS_H */ diff --git a/doomsday/external/libcurl/portable/include/curl/typecheck-gcc.h b/doomsday/external/libcurl/portable/include/curl/typecheck-gcc.h new file mode 100644 index 0000000000..f043a18e43 --- /dev/null +++ b/doomsday/external/libcurl/portable/include/curl/typecheck-gcc.h @@ -0,0 +1,590 @@ +#ifndef __CURL_TYPECHECK_GCC_H +#define __CURL_TYPECHECK_GCC_H +/*************************************************************************** + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ + * \___|\___/|_| \_\_____| + * + * Copyright (C) 1998 - 2011, Daniel Stenberg, , et al. + * + * This software is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at http://curl.haxx.se/docs/copyright.html. + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so, under the terms of the COPYING file. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ***************************************************************************/ + +/* wraps curl_easy_setopt() with typechecking */ + +/* To add a new kind of warning, add an + * if(_curl_is_sometype_option(_curl_opt)) + * if(!_curl_is_sometype(value)) + * _curl_easy_setopt_err_sometype(); + * block and define _curl_is_sometype_option, _curl_is_sometype and + * _curl_easy_setopt_err_sometype below + * + * NOTE: We use two nested 'if' statements here instead of the && operator, in + * order to work around gcc bug #32061. It affects only gcc 4.3.x/4.4.x + * when compiling with -Wlogical-op. + * + * To add an option that uses the same type as an existing option, you'll just + * need to extend the appropriate _curl_*_option macro + */ +#define curl_easy_setopt(handle, option, value) \ +__extension__ ({ \ + __typeof__ (option) _curl_opt = option; \ + if(__builtin_constant_p(_curl_opt)) { \ + if(_curl_is_long_option(_curl_opt)) \ + if(!_curl_is_long(value)) \ + _curl_easy_setopt_err_long(); \ + if(_curl_is_off_t_option(_curl_opt)) \ + if(!_curl_is_off_t(value)) \ + _curl_easy_setopt_err_curl_off_t(); \ + if(_curl_is_string_option(_curl_opt)) \ + if(!_curl_is_string(value)) \ + _curl_easy_setopt_err_string(); \ + if(_curl_is_write_cb_option(_curl_opt)) \ + if(!_curl_is_write_cb(value)) \ + _curl_easy_setopt_err_write_callback(); \ + if((_curl_opt) == CURLOPT_READFUNCTION) \ + if(!_curl_is_read_cb(value)) \ + _curl_easy_setopt_err_read_cb(); \ + if((_curl_opt) == CURLOPT_IOCTLFUNCTION) \ + if(!_curl_is_ioctl_cb(value)) \ + _curl_easy_setopt_err_ioctl_cb(); \ + if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION) \ + if(!_curl_is_sockopt_cb(value)) \ + _curl_easy_setopt_err_sockopt_cb(); \ + if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION) \ + if(!_curl_is_opensocket_cb(value)) \ + _curl_easy_setopt_err_opensocket_cb(); \ + if((_curl_opt) == CURLOPT_PROGRESSFUNCTION) \ + if(!_curl_is_progress_cb(value)) \ + _curl_easy_setopt_err_progress_cb(); \ + if((_curl_opt) == CURLOPT_DEBUGFUNCTION) \ + if(!_curl_is_debug_cb(value)) \ + _curl_easy_setopt_err_debug_cb(); \ + if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION) \ + if(!_curl_is_ssl_ctx_cb(value)) \ + _curl_easy_setopt_err_ssl_ctx_cb(); \ + if(_curl_is_conv_cb_option(_curl_opt)) \ + if(!_curl_is_conv_cb(value)) \ + _curl_easy_setopt_err_conv_cb(); \ + if((_curl_opt) == CURLOPT_SEEKFUNCTION) \ + if(!_curl_is_seek_cb(value)) \ + _curl_easy_setopt_err_seek_cb(); \ + if(_curl_is_cb_data_option(_curl_opt)) \ + if(!_curl_is_cb_data(value)) \ + _curl_easy_setopt_err_cb_data(); \ + if((_curl_opt) == CURLOPT_ERRORBUFFER) \ + if(!_curl_is_error_buffer(value)) \ + _curl_easy_setopt_err_error_buffer(); \ + if((_curl_opt) == CURLOPT_STDERR) \ + if(!_curl_is_FILE(value)) \ + _curl_easy_setopt_err_FILE(); \ + if(_curl_is_postfields_option(_curl_opt)) \ + if(!_curl_is_postfields(value)) \ + _curl_easy_setopt_err_postfields(); \ + if((_curl_opt) == CURLOPT_HTTPPOST) \ + if(!_curl_is_arr((value), struct curl_httppost)) \ + _curl_easy_setopt_err_curl_httpost(); \ + if(_curl_is_slist_option(_curl_opt)) \ + if(!_curl_is_arr((value), struct curl_slist)) \ + _curl_easy_setopt_err_curl_slist(); \ + if((_curl_opt) == CURLOPT_SHARE) \ + if(!_curl_is_ptr((value), CURLSH)) \ + _curl_easy_setopt_err_CURLSH(); \ + } \ + curl_easy_setopt(handle, _curl_opt, value); \ +}) + +/* wraps curl_easy_getinfo() with typechecking */ +/* FIXME: don't allow const pointers */ +#define curl_easy_getinfo(handle, info, arg) \ +__extension__ ({ \ + __typeof__ (info) _curl_info = info; \ + if(__builtin_constant_p(_curl_info)) { \ + if(_curl_is_string_info(_curl_info)) \ + if(!_curl_is_arr((arg), char *)) \ + _curl_easy_getinfo_err_string(); \ + if(_curl_is_long_info(_curl_info)) \ + if(!_curl_is_arr((arg), long)) \ + _curl_easy_getinfo_err_long(); \ + if(_curl_is_double_info(_curl_info)) \ + if(!_curl_is_arr((arg), double)) \ + _curl_easy_getinfo_err_double(); \ + if(_curl_is_slist_info(_curl_info)) \ + if(!_curl_is_arr((arg), struct curl_slist *)) \ + _curl_easy_getinfo_err_curl_slist(); \ + } \ + curl_easy_getinfo(handle, _curl_info, arg); \ +}) + +/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(), + * for now just make sure that the functions are called with three + * arguments + */ +#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param) +#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param) + + +/* the actual warnings, triggered by calling the _curl_easy_setopt_err* + * functions */ + +/* To define a new warning, use _CURL_WARNING(identifier, "message") */ +#define _CURL_WARNING(id, message) \ + static void __attribute__((warning(message))) __attribute__((unused)) \ + __attribute__((noinline)) id(void) { __asm__(""); } + +_CURL_WARNING(_curl_easy_setopt_err_long, + "curl_easy_setopt expects a long argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_off_t, + "curl_easy_setopt expects a curl_off_t argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_string, + "curl_easy_setopt expects a " + "string (char* or char[]) argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_write_callback, + "curl_easy_setopt expects a curl_write_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_read_cb, + "curl_easy_setopt expects a curl_read_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb, + "curl_easy_setopt expects a curl_ioctl_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb, + "curl_easy_setopt expects a curl_sockopt_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb, + "curl_easy_setopt expects a " + "curl_opensocket_callback argument for this option" + ) +_CURL_WARNING(_curl_easy_setopt_err_progress_cb, + "curl_easy_setopt expects a curl_progress_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_debug_cb, + "curl_easy_setopt expects a curl_debug_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb, + "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_conv_cb, + "curl_easy_setopt expects a curl_conv_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_seek_cb, + "curl_easy_setopt expects a curl_seek_callback argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_cb_data, + "curl_easy_setopt expects a " + "private data pointer as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_error_buffer, + "curl_easy_setopt expects a " + "char buffer of CURL_ERROR_SIZE as argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_FILE, + "curl_easy_setopt expects a FILE* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_postfields, + "curl_easy_setopt expects a void* or char* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_httpost, + "curl_easy_setopt expects a struct curl_httppost* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_curl_slist, + "curl_easy_setopt expects a struct curl_slist* argument for this option") +_CURL_WARNING(_curl_easy_setopt_err_CURLSH, + "curl_easy_setopt expects a CURLSH* argument for this option") + +_CURL_WARNING(_curl_easy_getinfo_err_string, + "curl_easy_getinfo expects a pointer to char * for this info") +_CURL_WARNING(_curl_easy_getinfo_err_long, + "curl_easy_getinfo expects a pointer to long for this info") +_CURL_WARNING(_curl_easy_getinfo_err_double, + "curl_easy_getinfo expects a pointer to double for this info") +_CURL_WARNING(_curl_easy_getinfo_err_curl_slist, + "curl_easy_getinfo expects a pointer to struct curl_slist * for this info") + +/* groups of curl_easy_setops options that take the same type of argument */ + +/* To add a new option to one of the groups, just add + * (option) == CURLOPT_SOMETHING + * to the or-expression. If the option takes a long or curl_off_t, you don't + * have to do anything + */ + +/* evaluates to true if option takes a long argument */ +#define _curl_is_long_option(option) \ + (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT) + +#define _curl_is_off_t_option(option) \ + ((option) > CURLOPTTYPE_OFF_T) + +/* evaluates to true if option takes a char* argument */ +#define _curl_is_string_option(option) \ + ((option) == CURLOPT_URL || \ + (option) == CURLOPT_PROXY || \ + (option) == CURLOPT_INTERFACE || \ + (option) == CURLOPT_NETRC_FILE || \ + (option) == CURLOPT_USERPWD || \ + (option) == CURLOPT_USERNAME || \ + (option) == CURLOPT_PASSWORD || \ + (option) == CURLOPT_PROXYUSERPWD || \ + (option) == CURLOPT_PROXYUSERNAME || \ + (option) == CURLOPT_PROXYPASSWORD || \ + (option) == CURLOPT_NOPROXY || \ + (option) == CURLOPT_ACCEPT_ENCODING || \ + (option) == CURLOPT_REFERER || \ + (option) == CURLOPT_USERAGENT || \ + (option) == CURLOPT_COOKIE || \ + (option) == CURLOPT_COOKIEFILE || \ + (option) == CURLOPT_COOKIEJAR || \ + (option) == CURLOPT_COOKIELIST || \ + (option) == CURLOPT_FTPPORT || \ + (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER || \ + (option) == CURLOPT_FTP_ACCOUNT || \ + (option) == CURLOPT_RANGE || \ + (option) == CURLOPT_CUSTOMREQUEST || \ + (option) == CURLOPT_SSLCERT || \ + (option) == CURLOPT_SSLCERTTYPE || \ + (option) == CURLOPT_SSLKEY || \ + (option) == CURLOPT_SSLKEYTYPE || \ + (option) == CURLOPT_KEYPASSWD || \ + (option) == CURLOPT_SSLENGINE || \ + (option) == CURLOPT_CAINFO || \ + (option) == CURLOPT_CAPATH || \ + (option) == CURLOPT_RANDOM_FILE || \ + (option) == CURLOPT_EGDSOCKET || \ + (option) == CURLOPT_SSL_CIPHER_LIST || \ + (option) == CURLOPT_KRBLEVEL || \ + (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 || \ + (option) == CURLOPT_SSH_PUBLIC_KEYFILE || \ + (option) == CURLOPT_SSH_PRIVATE_KEYFILE || \ + (option) == CURLOPT_CRLFILE || \ + (option) == CURLOPT_ISSUERCERT || \ + (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE || \ + (option) == CURLOPT_SSH_KNOWNHOSTS || \ + (option) == CURLOPT_MAIL_FROM || \ + (option) == CURLOPT_RTSP_SESSION_ID || \ + (option) == CURLOPT_RTSP_STREAM_URI || \ + (option) == CURLOPT_RTSP_TRANSPORT || \ + 0) + +/* evaluates to true if option takes a curl_write_callback argument */ +#define _curl_is_write_cb_option(option) \ + ((option) == CURLOPT_HEADERFUNCTION || \ + (option) == CURLOPT_WRITEFUNCTION) + +/* evaluates to true if option takes a curl_conv_callback argument */ +#define _curl_is_conv_cb_option(option) \ + ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION || \ + (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION) + +/* evaluates to true if option takes a data argument to pass to a callback */ +#define _curl_is_cb_data_option(option) \ + ((option) == CURLOPT_WRITEDATA || \ + (option) == CURLOPT_READDATA || \ + (option) == CURLOPT_IOCTLDATA || \ + (option) == CURLOPT_SOCKOPTDATA || \ + (option) == CURLOPT_OPENSOCKETDATA || \ + (option) == CURLOPT_PROGRESSDATA || \ + (option) == CURLOPT_WRITEHEADER || \ + (option) == CURLOPT_DEBUGDATA || \ + (option) == CURLOPT_SSL_CTX_DATA || \ + (option) == CURLOPT_SEEKDATA || \ + (option) == CURLOPT_PRIVATE || \ + (option) == CURLOPT_SSH_KEYDATA || \ + (option) == CURLOPT_INTERLEAVEDATA || \ + (option) == CURLOPT_CHUNK_DATA || \ + (option) == CURLOPT_FNMATCH_DATA || \ + 0) + +/* evaluates to true if option takes a POST data argument (void* or char*) */ +#define _curl_is_postfields_option(option) \ + ((option) == CURLOPT_POSTFIELDS || \ + (option) == CURLOPT_COPYPOSTFIELDS || \ + 0) + +/* evaluates to true if option takes a struct curl_slist * argument */ +#define _curl_is_slist_option(option) \ + ((option) == CURLOPT_HTTPHEADER || \ + (option) == CURLOPT_HTTP200ALIASES || \ + (option) == CURLOPT_QUOTE || \ + (option) == CURLOPT_POSTQUOTE || \ + (option) == CURLOPT_PREQUOTE || \ + (option) == CURLOPT_TELNETOPTIONS || \ + (option) == CURLOPT_MAIL_RCPT || \ + 0) + +/* groups of curl_easy_getinfo infos that take the same type of argument */ + +/* evaluates to true if info expects a pointer to char * argument */ +#define _curl_is_string_info(info) \ + (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG) + +/* evaluates to true if info expects a pointer to long argument */ +#define _curl_is_long_info(info) \ + (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE) + +/* evaluates to true if info expects a pointer to double argument */ +#define _curl_is_double_info(info) \ + (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST) + +/* true if info expects a pointer to struct curl_slist * argument */ +#define _curl_is_slist_info(info) \ + (CURLINFO_SLIST < (info)) + + +/* typecheck helpers -- check whether given expression has requested type*/ + +/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros, + * otherwise define a new macro. Search for __builtin_types_compatible_p + * in the GCC manual. + * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is + * the actual expression passed to the curl_easy_setopt macro. This + * means that you can only apply the sizeof and __typeof__ operators, no + * == or whatsoever. + */ + +/* XXX: should evaluate to true iff expr is a pointer */ +#define _curl_is_any_ptr(expr) \ + (sizeof(expr) == sizeof(void*)) + +/* evaluates to true if expr is NULL */ +/* XXX: must not evaluate expr, so this check is not accurate */ +#define _curl_is_NULL(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL))) + +/* evaluates to true if expr is type*, const type* or NULL */ +#define _curl_is_ptr(expr, type) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), type *) || \ + __builtin_types_compatible_p(__typeof__(expr), const type *)) + +/* evaluates to true if expr is one of type[], type*, NULL or const type* */ +#define _curl_is_arr(expr, type) \ + (_curl_is_ptr((expr), type) || \ + __builtin_types_compatible_p(__typeof__(expr), type [])) + +/* evaluates to true if expr is a string */ +#define _curl_is_string(expr) \ + (_curl_is_arr((expr), char) || \ + _curl_is_arr((expr), signed char) || \ + _curl_is_arr((expr), unsigned char)) + +/* evaluates to true if expr is a long (no matter the signedness) + * XXX: for now, int is also accepted (and therefore short and char, which + * are promoted to int when passed to a variadic function) */ +#define _curl_is_long(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), long) || \ + __builtin_types_compatible_p(__typeof__(expr), signed long) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned long) || \ + __builtin_types_compatible_p(__typeof__(expr), int) || \ + __builtin_types_compatible_p(__typeof__(expr), signed int) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned int) || \ + __builtin_types_compatible_p(__typeof__(expr), short) || \ + __builtin_types_compatible_p(__typeof__(expr), signed short) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned short) || \ + __builtin_types_compatible_p(__typeof__(expr), char) || \ + __builtin_types_compatible_p(__typeof__(expr), signed char) || \ + __builtin_types_compatible_p(__typeof__(expr), unsigned char)) + +/* evaluates to true if expr is of type curl_off_t */ +#define _curl_is_off_t(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), curl_off_t)) + +/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */ +/* XXX: also check size of an char[] array? */ +#define _curl_is_error_buffer(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), char *) || \ + __builtin_types_compatible_p(__typeof__(expr), char[])) + +/* evaluates to true if expr is of type (const) void* or (const) FILE* */ +#if 0 +#define _curl_is_cb_data(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_ptr((expr), FILE)) +#else /* be less strict */ +#define _curl_is_cb_data(expr) \ + _curl_is_any_ptr(expr) +#endif + +/* evaluates to true if expr is of type FILE* */ +#define _curl_is_FILE(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), FILE *)) + +/* evaluates to true if expr can be passed as POST data (void* or char*) */ +#define _curl_is_postfields(expr) \ + (_curl_is_ptr((expr), void) || \ + _curl_is_arr((expr), char)) + +/* FIXME: the whole callback checking is messy... + * The idea is to tolerate char vs. void and const vs. not const + * pointers in arguments at least + */ +/* helper: __builtin_types_compatible_p distinguishes between functions and + * function pointers, hide it */ +#define _curl_callback_compatible(func, type) \ + (__builtin_types_compatible_p(__typeof__(func), type) || \ + __builtin_types_compatible_p(__typeof__(func), type*)) + +/* evaluates to true if expr is of type curl_read_callback or "similar" */ +#define _curl_is_read_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) || \ + _curl_callback_compatible((expr), _curl_read_callback1) || \ + _curl_callback_compatible((expr), _curl_read_callback2) || \ + _curl_callback_compatible((expr), _curl_read_callback3) || \ + _curl_callback_compatible((expr), _curl_read_callback4) || \ + _curl_callback_compatible((expr), _curl_read_callback5) || \ + _curl_callback_compatible((expr), _curl_read_callback6)) +typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*); +typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*); +typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*); +typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*); +typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*); +typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*); + +/* evaluates to true if expr is of type curl_write_callback or "similar" */ +#define _curl_is_write_cb(expr) \ + (_curl_is_read_cb(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) || \ + _curl_callback_compatible((expr), _curl_write_callback1) || \ + _curl_callback_compatible((expr), _curl_write_callback2) || \ + _curl_callback_compatible((expr), _curl_write_callback3) || \ + _curl_callback_compatible((expr), _curl_write_callback4) || \ + _curl_callback_compatible((expr), _curl_write_callback5) || \ + _curl_callback_compatible((expr), _curl_write_callback6)) +typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*); +typedef size_t (_curl_write_callback2)(const char *, size_t, size_t, + const void*); +typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*); +typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*); +typedef size_t (_curl_write_callback5)(const void *, size_t, size_t, + const void*); +typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*); + +/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */ +#define _curl_is_ioctl_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback1) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback2) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback3) || \ + _curl_callback_compatible((expr), _curl_ioctl_callback4)) +typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*); +typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*); +typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*); +typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*); + +/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */ +#define _curl_is_sockopt_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback1) || \ + _curl_callback_compatible((expr), _curl_sockopt_callback2)) +typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype); +typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t, + curlsocktype); + +/* evaluates to true if expr is of type curl_opensocket_callback or + "similar" */ +#define _curl_is_opensocket_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\ + _curl_callback_compatible((expr), _curl_opensocket_callback1) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback2) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback3) || \ + _curl_callback_compatible((expr), _curl_opensocket_callback4)) +typedef curl_socket_t (_curl_opensocket_callback1) + (void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback2) + (void *, curlsocktype, const struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback3) + (const void *, curlsocktype, struct curl_sockaddr *); +typedef curl_socket_t (_curl_opensocket_callback4) + (const void *, curlsocktype, const struct curl_sockaddr *); + +/* evaluates to true if expr is of type curl_progress_callback or "similar" */ +#define _curl_is_progress_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) || \ + _curl_callback_compatible((expr), _curl_progress_callback1) || \ + _curl_callback_compatible((expr), _curl_progress_callback2)) +typedef int (_curl_progress_callback1)(void *, + double, double, double, double); +typedef int (_curl_progress_callback2)(const void *, + double, double, double, double); + +/* evaluates to true if expr is of type curl_debug_callback or "similar" */ +#define _curl_is_debug_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) || \ + _curl_callback_compatible((expr), _curl_debug_callback1) || \ + _curl_callback_compatible((expr), _curl_debug_callback2) || \ + _curl_callback_compatible((expr), _curl_debug_callback3) || \ + _curl_callback_compatible((expr), _curl_debug_callback4)) +typedef int (_curl_debug_callback1) (CURL *, + curl_infotype, char *, size_t, void *); +typedef int (_curl_debug_callback2) (CURL *, + curl_infotype, char *, size_t, const void *); +typedef int (_curl_debug_callback3) (CURL *, + curl_infotype, const char *, size_t, void *); +typedef int (_curl_debug_callback4) (CURL *, + curl_infotype, const char *, size_t, const void *); + +/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */ +/* this is getting even messier... */ +#define _curl_is_ssl_ctx_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) || \ + _curl_callback_compatible((expr), _curl_ssl_ctx_callback8)) +typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *); +typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *); +typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *); +typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *); +#ifdef HEADER_SSL_H +/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX + * this will of course break if we're included before OpenSSL headers... + */ +typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *); +typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *); +typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *); +typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX, + const void *); +#else +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7; +typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8; +#endif + +/* evaluates to true if expr is of type curl_conv_callback or "similar" */ +#define _curl_is_conv_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) || \ + _curl_callback_compatible((expr), _curl_conv_callback1) || \ + _curl_callback_compatible((expr), _curl_conv_callback2) || \ + _curl_callback_compatible((expr), _curl_conv_callback3) || \ + _curl_callback_compatible((expr), _curl_conv_callback4)) +typedef CURLcode (*_curl_conv_callback1)(char *, size_t length); +typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length); +typedef CURLcode (*_curl_conv_callback3)(void *, size_t length); +typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length); + +/* evaluates to true if expr is of type curl_seek_callback or "similar" */ +#define _curl_is_seek_cb(expr) \ + (_curl_is_NULL(expr) || \ + __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) || \ + _curl_callback_compatible((expr), _curl_seek_callback1) || \ + _curl_callback_compatible((expr), _curl_seek_callback2)) +typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int); +typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int); + + +#endif /* __CURL_TYPECHECK_GCC_H */ diff --git a/doomsday/external/libcurl/win32/libcurl.dll b/doomsday/external/libcurl/win32/libcurl.dll new file mode 100644 index 0000000000000000000000000000000000000000..5f71329e055fae51e6c4a8e7cd70d2be6e54be2e GIT binary patch literal 227840 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 literal 0 HcmV?d00001 diff --git a/doomsday/external/libcurl/win32/libcurl.exp b/doomsday/external/libcurl/win32/libcurl.exp new file mode 100644 index 0000000000000000000000000000000000000000..339d28d645fc31edfe527b54818fe7aaf7fbefe9 GIT binary patch literal 7869 zcmeI1{g0eg701u^g(qNv1RB-kiX68l3n7@J69qr_l>u|G7iiKu9ZArVu*=iGarxi9z+ z7@zE(`QFdD&z<|+`^>`v;wn>D|OVOszHWors8y=Y)T}P0YN=&4>-l!mKA|2pW@?R!)uRy==A33TvIl5J z)uQEwvsQQftwz*n)EZWwcGa1uHD`Y7d{K|bjhRNIXU8pEjT)wdf$&k+eb9)ida|?S z+H}6`uA63^C9puQ66ve154s?$s{UT6h)BXf-?ub0O_vz@B#?4Lr7s8XAYK4Kd7Ua79lTH%;kW1Hmig;uHN z%vg2J<;`8HyF0tBSgTZtYHhu9l{t5H=iKF;bCz(5_W;8e%OVg24HuJ>PE2Pu$915gXk_%yJaQ+Q9HnTL_G}4=VJz72<1>yu=_>r23s!b2rP%;1lJZo}QFYh{MLi6*T2u>`Qv%EYY>g<+74Wgcf{gkK{*o~r2!+u)SNwB1- z=U_i0>T$4*qRznbdL`%yu$x4^0Q*@{Pl0U`^&;#eqMioh`z=8)!RACg3wE=pmtl{H zIt{j2)GM%gQO|+hBI+#cw5T&+1EOAoEr@ynY>TMZVR@et^di_+QRiSIQ7?hrD(XD! zjHs8vwuyQJc2?9YV1uGAz#bKK7Hmk=o3JHOuYuhr>LTo;qFx6}iFyn6n5c7LX;E*( zmPMTh%ZPdhwj$~cuwhY`V5_1ofMrEphOLQu6Kq7(71+9{i(sRo-i19b>MgJ_QSZSv zM7<3*F6w>Qrl@zoCPaMz+Y)sNjC0QfeF)nYbs6k-Q3N$7>I&2jQ463>hP}HhpdJ(TKGerVEr9(y{?FnObSHK7K+@3A)O5R4E;grht}@t&ke)Q7LF6oh zrvL{BYtxSoLYN*y(aAb?ct;OEwdV66a`1DgHrGY_ONBG~R=&rCgY6t%GZx>*^$3tKsAevCh+3 z4UfpnW_e5+wi2#|u1kW|DsU{YeTquVcr0ErYb+Dtd8|dQOHwr+i=X+{DUFCz2|j@r z+;T|r##h1*e}_vJw-%lyp2tK^_Hih%&WeNJa`-qTXrD^(dI32mC}=Xh6`4S%3Mc|Q) zk>|fU_Qt6rV-6hZq&SD<*>ddASZ6c5F&sTKjguZ8q|f5I`+8swBD%YuXYwt>@x*bf zgp>D-!;0-PnI|tm((|bllow#5=jr64e7kYDvB#8k<2T#nIn2GAgs>96;eSCfO8!STJo<8VZa9r^@bT)YNtu0`I?DN_%9Oc6%gC4|!yS3LY7yx<|(7^Bx(eXFM`N&$}d(qHlX7 zO|N<+LqGS(F#XmeS-Rqp5&EY`Mri?Jx3xZ*G2&=$lW|IVWP*lVGMu8_9!b+-k7TIi zkzqRJkt}`HBO~-pkBrg}Ju*hW^2j*-!6Os&HB9GPf1hS#Vs!Bbi*y>9B8eH|7E}G7nf|hX%ckZ)M>VE z#p$?dyKcV})4lBP{B2}PFPo{7%O;&t%cc0<-v*|%vYA^_*&ba=IY^aIAu^@YM|n^( zIoQ1w-0%N&$G9{yZEwZRPXNa4uX+36uJT|ko-YIeHKK!M={5qwfUDDVnE@d<{ VB~0AZrHg8NcfToBl+*b=;6E^@B9Z_A literal 0 HcmV?d00001 diff --git a/doomsday/external/libcurl/win32/libcurl.lib b/doomsday/external/libcurl/win32/libcurl.lib new file mode 100644 index 0000000000000000000000000000000000000000..df22aece6c9fa7054ecad6b8849b320453fa777e GIT binary patch literal 13694 zcmc&)OK%*<5iXLEEmMrbNU~%}q_}*TPjUI$6-h-7sKf>=o0bJyzWCtfiaV4R*;i(l z8wW5H1TcI`ZiY`f=->c`|3NN-4n7(7A%JsN038h;4BegT=T!Ifv}d#ovOsaBYrgKU zyQjLkx`yM|%HiI<-wrP2%-_n|%KFM$vADcq>X&74b#wiSxZNEDfIk78`v&0rGk}Zp z027}`Im9c<1;AwTYatUCus%v*L&(xo046h^37Osj zV3L0*WEQ)^WCr`dWcrbiWyCO9`bf$UUQyO|rF@H5lvhJ3Pw>hF+hTI*nvfh~n2enj zGV(D1lTp+$8TmoT*pK)e<YcrVum+{l&G)yr;{f=JM2P3N-+ce( z+ojj9-@cADs`XZ>#A=uJn_<0Nseo0o5c^>e5Qr#Rn7cuTKzNBDxx7G~(DuN6>U0_>_=mW)qT|JdYaW z6CV``rrvEgT4A-(*_UIZ3W~E~QJJF3W?Q;QF<{*1S`$p{-Wc zIxsYDWT_t1l^I9%g*IMeuNIUW2Q9OLRuVk7cG444wo&b%(`>08bDYxH$W{X_sU^F zt&J*TIQ2sL6bYnK#jx782w3X~TC4(ewPDx{>2hTLR_F*?PJn(yUX~LtJ89x=C21eM zOQqaV%UzcUqFt-DJEd}~6)j{_6~nT~pj6iHP@uIkdu+d2mjFJS0oa)ac!-fG3(e=T{0PfC z7}3Tv(wn`XM$|*9#L*Vs1h1!tq7w*`8DHw6tS5YvLGZDjnxE z=lV~Xkl+qP51+>+Tt!@Kq*Oj7(r9-Ysq8~q{2&rPb;S=MXro3{6@@K^lZkvJ$rt5XA_qIOCIWVs{qL^&d=N;;uv=Mw{yAXU0C z?QjTIyBeX3oQy16Gp-$rd~DBo#I3xP3ultD7wRF<+@R9}6VrSx-4`6qTu zbQheKQi;aE?}(+~Nl*NkrTjw`x>rlw@CKQkuA>cKIXMB6@b6v zGzL){C82=Kc3)HuGH3FQBU_)z7lmNGF{*`TF=E04?Zz0PjPEENxlgsOee*eBvZ>gS zP-LIaf?5#P=rFB=F4-6z--#(1xlc8=!lqn&78hIM$4o8}^b&&XBlFGV3l^Jd$C z;XjIC230YsLnEak_o?1lVck6@OoU_pmNM~kCu#mUEZ;M#VS|gEb}1FPPdBQBeGSw6 zn8DVgVo5~O^wEy!l;%;#bV^0;(~Zbud#5QA%XpH;vyaIa6P$^d%=|)cjGma_Wt*|* zeY03_Tl@st##t8|PmIt3lKXV;&a=kOX-1uNA5<3-P_NJY{nX zE$b{6J=VCSxy%nlgd@9!c(PE-7GErM&pea9EYym{b|ii};T*~GqpLRG(RdTj&af6S z(*K{MuP^(IdPZ2V`1A+Ao)~>6lw!n)v&sMApf|3BeUIg1uTU=esgjbB`=0&Ry5@2w gqB6fVUw&vqbE$8vWF(o_w{OL5+Dzj6Eu|a$FP5cCGynhq literal 0 HcmV?d00001 diff --git a/doomsday/external/libpng/portable/include/png.h b/doomsday/external/libpng/portable/include/png.h index 1b9f371eb1..7c8a9c2431 100644 --- a/doomsday/external/libpng/portable/include/png.h +++ b/doomsday/external/libpng/portable/include/png.h @@ -1,24 +1,26 @@ /* png.h - header file for PNG reference library * - * libpng version 1.2.15 - January 5, 2007 - * Copyright (c) 1998-2007 Glenn Randers-Pehrson + * libpng version 1.5.5 - September 22, 2011 + * Copyright (c) 1998-2011 Glenn Randers-Pehrson * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * + * This code is released under the libpng license (See LICENSE, below) + * * Authors and maintainers: - * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat - * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger - * libpng versions 0.97, January 1998, through 1.2.15 - January 5, 2007: Glenn - * See also "Contributing Authors", below. + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.5.5 - September 22, 2011: Glenn + * See also "Contributing Authors", below. * * Note about libpng version numbers: * - * Due to various miscommunications, unforeseen code incompatibilities - * and occasional factors outside the authors' control, version numbering - * on the library has not always been consistent and straightforward. - * The following table summarizes matters since version 0.89c, which was - * the first widely used release: + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: * * source png.h png.h shared-lib * version string int version @@ -103,63 +105,82 @@ * 1.0.16 10 10016 10.so.0.1.0.16 * 1.2.6 13 10206 12.so.0.1.2.6 * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 - * 1.0.17rc1 10 10017 10.so.0.1.0.17rc1 + * 1.0.17rc1 10 10017 12.so.0.1.0.17rc1 * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 - * 1.0.17 10 10017 10.so.0.1.0.17 + * 1.0.17 10 10017 12.so.0.1.0.17 * 1.2.7 13 10207 12.so.0.1.2.7 * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 - * 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5 + * 1.0.18rc1-5 10 10018 12.so.0.1.0.18rc1-5 * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 - * 1.0.18 10 10018 10.so.0.1.0.18 + * 1.0.18 10 10018 12.so.0.1.0.18 * 1.2.8 13 10208 12.so.0.1.2.8 * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 * 1.2.9beta4-11 13 10209 12.so.0.9[.0] * 1.2.9rc1 13 10209 12.so.0.9[.0] * 1.2.9 13 10209 12.so.0.9[.0] - * 1.2.10beta1-8 13 10210 12.so.0.10[.0] - * 1.2.10rc1-3 13 10210 12.so.0.10[.0] + * 1.2.10beta1-7 13 10210 12.so.0.10[.0] + * 1.2.10rc1-2 13 10210 12.so.0.10[.0] * 1.2.10 13 10210 12.so.0.10[.0] + * 1.4.0beta1-5 14 10400 14.so.0.0[.0] * 1.2.11beta1-4 13 10211 12.so.0.11[.0] - * 1.0.19rc1-5 10 10019 10.so.0.19[.0] - * 1.2.11rc1-5 13 10211 12.so.0.11[.0] - * 1.0.19 10 10019 10.so.0.19[.0] + * 1.4.0beta7-8 14 10400 14.so.0.0[.0] * 1.2.11 13 10211 12.so.0.11[.0] - * 1.0.20 10 10020 10.so.0.20[.0] * 1.2.12 13 10212 12.so.0.12[.0] - * 1.2.13beta1 13 10213 12.so.0.13[.0] - * 1.0.21 10 10021 10.so.0.21[.0] + * 1.4.0beta9-14 14 10400 14.so.0.0[.0] * 1.2.13 13 10213 12.so.0.13[.0] - * 1.2.14beta1-2 13 10214 12.so.0.14[.0] - * 1.0.22rc1 10 10022 10.so.0.22[.0] - * 1.2.14rc1 13 10214 12.so.0.14[.0] - * 1.0.22 10 10022 10.so.0.22[.0] - * 1.2.14 13 10214 12.so.0.14[.0] - * 1.2.15beta1-6 13 10215 12.so.0.15[.0] - * 1.0.23rc1-5 10 10023 10.so.0.23[.0] - * 1.2.15rc1-5 13 10215 12.so.0.15[.0] - * 1.0.23 10 10023 10.so.0.23[.0] - * 1.2.15 13 10215 12.so.0.15[.0] - * - * Henceforth the source version will match the shared-library major - * and minor numbers; the shared-library major version number will be - * used for changes in backward compatibility, as it is intended. The - * PNG_LIBPNG_VER macro, which is not used within libpng but is available - * for applications, is an unsigned integer of the form xyyzz corresponding - * to the source version x.y.z (leading zeros in y and z). Beta versions - * were given the previous public release number plus a letter, until - * version 1.0.6j; from then on they were given the upcoming public - * release number plus "betaNN" or "rcN". - * - * Binary incompatibility exists only when applications make direct access - * to the info_ptr or png_ptr members through png.h, and the compiled - * application is loaded with a different version of the library. - * - * DLLNUM will change each time there are forward or backward changes - * in binary compatibility (e.g., when a new feature is added). - * - * See libpng.txt or libpng.3 for more information. The PNG specification - * is available as a W3C Recommendation and as an ISO Specification, - * +# endif + + /* Need the time information for converting tIME chunks, it + * defines struct tm: + */ +# ifdef PNG_CONVERT_tIME_SUPPORTED + /* "time.h" functions are not supported on all operating systems */ +# include +# endif +# endif + +/* Machine specific configuration. */ +# include "pngconf.h" +#endif /* - * Added at libpng-1.2.8 */ -/* Ref MSDN: Private as priority over Special + * Added at libpng-1.2.8 + * + * Ref MSDN: Private as priority over Special * VS_FF_PRIVATEBUILD File *was not* built using standard release * procedures. If this value is given, the StringFileInfo block must - * contain a PrivateBuild string. + * contain a PrivateBuild string. * * VS_FF_SPECIALBUILD File *was* built by the original company using * standard release procedures but is a variation of the standard * file of the same version number. If this value is given, the - * StringFileInfo block must contain a SpecialBuild string. + * StringFileInfo block must contain a SpecialBuild string. */ -#if defined(PNG_USER_PRIVATEBUILD) +#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ # define PNG_LIBPNG_BUILD_TYPE \ - (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) #else -# if defined(PNG_LIBPNG_SPECIALBUILD) +# ifdef PNG_LIBPNG_SPECIALBUILD # define PNG_LIBPNG_BUILD_TYPE \ - (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) + (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) # else # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) # endif @@ -422,76 +472,61 @@ extern "C" { #endif /* __cplusplus */ -/* This file is arranged in several sections. The first section contains - * structure and type definitions. The second section contains the external - * library functions, while the third has the internal library functions, - * which applications aren't expected to use directly. - */ - -#ifndef PNG_NO_TYPECAST_NULL -#define int_p_NULL (int *)NULL -#define png_bytep_NULL (png_bytep)NULL -#define png_bytepp_NULL (png_bytepp)NULL -#define png_doublep_NULL (png_doublep)NULL -#define png_error_ptr_NULL (png_error_ptr)NULL -#define png_flush_ptr_NULL (png_flush_ptr)NULL -#define png_free_ptr_NULL (png_free_ptr)NULL -#define png_infopp_NULL (png_infopp)NULL -#define png_malloc_ptr_NULL (png_malloc_ptr)NULL -#define png_read_status_ptr_NULL (png_read_status_ptr)NULL -#define png_rw_ptr_NULL (png_rw_ptr)NULL -#define png_structp_NULL (png_structp)NULL -#define png_uint_16p_NULL (png_uint_16p)NULL -#define png_voidp_NULL (png_voidp)NULL -#define png_write_status_ptr_NULL (png_write_status_ptr)NULL -#else -#define int_p_NULL NULL -#define png_bytep_NULL NULL -#define png_bytepp_NULL NULL -#define png_doublep_NULL NULL -#define png_error_ptr_NULL NULL -#define png_flush_ptr_NULL NULL -#define png_free_ptr_NULL NULL -#define png_infopp_NULL NULL -#define png_malloc_ptr_NULL NULL -#define png_read_status_ptr_NULL NULL -#define png_rw_ptr_NULL NULL -#define png_structp_NULL NULL -#define png_uint_16p_NULL NULL -#define png_voidp_NULL NULL -#define png_write_status_ptr_NULL NULL -#endif - -/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ -#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) /* Version information for C files, stored in png.c. This had better match * the version above. */ -#ifdef PNG_USE_GLOBAL_ARRAYS -PNG_EXPORT_VAR (const char) png_libpng_ver[18]; - /* need room for 99.99.99beta99z */ -#else #define png_libpng_ver png_get_header_ver(NULL) -#endif -#ifdef PNG_USE_GLOBAL_ARRAYS -/* This was removed in version 1.0.5c */ -/* Structures to facilitate easy interlacing. See png.c for more details */ -PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7]; -PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7]; -PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7]; -PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7]; -PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7]; -PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7]; -#ifdef PNG_USE_PNGGCCRD -PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7]; -#endif -/* This isn't currently used. If you need it, see png.c for more details. -PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7]; -*/ -#endif +/* This file is arranged in several sections: + * + * 1. Any configuration options that can be specified by for the application + * code when it is built. (Build time configuration is in pnglibconf.h) + * 2. Type definitions (base types are defined in pngconf.h), structure + * definitions. + * 3. Exported library functions. + * + * The library source code has additional files (principally pngpriv.h) that + * allow configuration of the library. + */ +/* Section 1: run time configuration + * See pnglibconf.h for build time configuration + * + * Run time configuration allows the application to choose between + * implementations of certain arithmetic APIs. The default is set + * at build time and recorded in pnglibconf.h, but it is safe to + * override these (and only these) settings. Note that this won't + * change what the library does, only application code, and the + * settings can (and probably should) be made on a per-file basis + * by setting the #defines before including png.h + * + * Use macros to read integers from PNG data or use the exported + * functions? + * PNG_USE_READ_MACROS: use the macros (see below) Note that + * the macros evaluate their argument multiple times. + * PNG_NO_USE_READ_MACROS: call the relevant library function. + * + * Use the alternative algorithm for compositing alpha samples that + * does not use division? + * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' + * algorithm. + * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. + * + * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is + * false? + * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error + * APIs to png_warning. + * Otherwise the calls are mapped to png_error. + */ -#endif /* PNG_NO_EXTERN */ +/* Section 2: type definitions, including structures and compile time + * constants. + * See pngconf.h for base types that vary by machine/system + */ + +/* This triggers a compiler error in png.c, if png.c and png.h + * do not agree upon the version number. + */ +typedef char* png_libpng_version_1_5_5; /* Three color definitions. The order of the red, green, and blue, (and the * exact size) is not important, although the size of the fields need to @@ -504,6 +539,7 @@ typedef struct png_color_struct png_byte blue; } png_color; typedef png_color FAR * png_colorp; +typedef PNG_CONST png_color FAR * png_const_colorp; typedef png_color FAR * FAR * png_colorpp; typedef struct png_color_16_struct @@ -515,6 +551,7 @@ typedef struct png_color_16_struct png_uint_16 gray; /* for use in grayscale files */ } png_color_16; typedef png_color_16 FAR * png_color_16p; +typedef PNG_CONST png_color_16 FAR * png_const_color_16p; typedef png_color_16 FAR * FAR * png_color_16pp; typedef struct png_color_8_struct @@ -526,6 +563,7 @@ typedef struct png_color_8_struct png_byte alpha; /* for alpha channel files */ } png_color_8; typedef png_color_8 FAR * png_color_8p; +typedef PNG_CONST png_color_8 FAR * png_const_color_8p; typedef png_color_8 FAR * FAR * png_color_8pp; /* @@ -541,6 +579,7 @@ typedef struct png_sPLT_entry_struct png_uint_16 frequency; } png_sPLT_entry; typedef png_sPLT_entry FAR * png_sPLT_entryp; +typedef PNG_CONST png_sPLT_entry FAR * png_const_sPLT_entryp; typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; /* When the depth of the sPLT palette is 8 bits, the color and alpha samples @@ -556,6 +595,7 @@ typedef struct png_sPLT_struct png_int_32 nentries; /* number of palette entries */ } png_sPLT_t; typedef png_sPLT_t FAR * png_sPLT_tp; +typedef PNG_CONST png_sPLT_t FAR * png_const_sPLT_tp; typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; #ifdef PNG_TEXT_SUPPORTED @@ -563,7 +603,7 @@ typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; * and whether that contents is compressed or not. The "key" field * points to a regular zero-terminated C string. The "text", "lang", and * "lang_key" fields can be regular C strings, empty strings, or NULL pointers. - * However, the * structure returned by png_get_text() will always contain + * However, the structure returned by png_get_text() will always contain * regular zero-terminated C strings (possibly empty), never NULL pointers, * so they can be safely used in printf() and other string-handling functions. */ @@ -578,15 +618,14 @@ typedef struct png_text_struct png_charp text; /* comment, may be an empty string (ie "") or a NULL pointer */ png_size_t text_length; /* length of the text string */ -#ifdef PNG_iTXt_SUPPORTED png_size_t itxt_length; /* length of the itxt string */ png_charp lang; /* language code, 0-79 characters or a NULL pointer */ png_charp lang_key; /* keyword translated UTF-8 string, 0 or more chars or a NULL pointer */ -#endif } png_text; typedef png_text FAR * png_textp; +typedef PNG_CONST png_text FAR * png_const_textp; typedef png_text FAR * FAR * png_textpp; #endif @@ -616,9 +655,11 @@ typedef struct png_time_struct png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ } png_time; typedef png_time FAR * png_timep; +typedef PNG_CONST png_time FAR * png_const_timep; typedef png_time FAR * FAR * png_timepp; -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ + defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) /* png_unknown_chunk is a structure to hold queued chunks for which there is * no specific support. The idea is that we can use this to queue * up private chunks for output even though the library doesn't actually @@ -633,299 +674,41 @@ typedef struct png_unknown_chunk_t /* libpng-using applications should NOT directly modify this byte. */ png_byte location; /* mode of operation at read time */ } + + png_unknown_chunk; typedef png_unknown_chunk FAR * png_unknown_chunkp; +typedef PNG_CONST png_unknown_chunk FAR * png_const_unknown_chunkp; typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp; #endif -/* png_info is a structure that holds the information in a PNG file so - * that the application can find out the characteristics of the image. - * If you are reading the file, this structure will tell you what is - * in the PNG file. If you are writing the file, fill in the information - * you want to put into the PNG file, then call png_write_info(). - * The names chosen should be very close to the PNG specification, so - * consult that document for information about the meaning of each field. - * - * With libpng < 0.95, it was only possible to directly set and read the - * the values in the png_info_struct, which meant that the contents and - * order of the values had to remain fixed. With libpng 0.95 and later, - * however, there are now functions that abstract the contents of - * png_info_struct from the application, so this makes it easier to use - * libpng with dynamic libraries, and even makes it possible to use - * libraries that don't have all of the libpng ancillary chunk-handing - * functionality. - * - * In any case, the order of the parameters in png_info_struct should NOT - * be changed for as long as possible to keep compatibility with applications - * that use the old direct-access method with png_info_struct. - * - * The following members may have allocated storage attached that should be - * cleaned up before the structure is discarded: palette, trans, text, - * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, - * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these - * are automatically freed when the info structure is deallocated, if they were - * allocated internally by libpng. This behavior can be changed by means - * of the png_data_freer() function. - * - * More allocation details: all the chunk-reading functions that - * change these members go through the corresponding png_set_* - * functions. A function to clear these members is available: see - * png_free_data(). The png_set_* functions do not depend on being - * able to point info structure members to any of the storage they are - * passed (they make their own copies), EXCEPT that the png_set_text - * functions use the same storage passed to them in the text_ptr or - * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns - * functions do not make their own copies. - */ -typedef struct png_info_struct -{ - /* the following are necessary for every PNG file */ - png_uint_32 width; /* width of image in pixels (from IHDR) */ - png_uint_32 height; /* height of image in pixels (from IHDR) */ - png_uint_32 valid; /* valid chunk data (see PNG_INFO_ below) */ - png_uint_32 rowbytes; /* bytes needed to hold an untransformed row */ - png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ - png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ - png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ - png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ - png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ - /* The following three should have been named *_method not *_type */ - png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ - png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ - png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ - - /* The following is informational only on read, and not used on writes. */ - png_byte channels; /* number of data channels per pixel (1, 2, 3, 4) */ - png_byte pixel_depth; /* number of bits per pixel */ - png_byte spare_byte; /* to align the data, and for future use */ - png_byte signature[8]; /* magic bytes read by libpng from start of file */ - - /* The rest of the data is optional. If you are reading, check the - * valid field to see if the information in these are valid. If you - * are writing, set the valid field to those chunks you want written, - * and initialize the appropriate fields below. - */ - -#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) - /* The gAMA chunk describes the gamma characteristics of the system - * on which the image was created, normally in the range [1.0, 2.5]. - * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. - */ - float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ -#endif - -#if defined(PNG_sRGB_SUPPORTED) - /* GR-P, 0.96a */ - /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ - png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */ -#endif - -#if defined(PNG_TEXT_SUPPORTED) - /* The tEXt, and zTXt chunks contain human-readable textual data in - * uncompressed, compressed, and optionally compressed forms, respectively. - * The data in "text" is an array of pointers to uncompressed, - * null-terminated C strings. Each chunk has a keyword that describes the - * textual data contained in that chunk. Keywords are not required to be - * unique, and the text string may be empty. Any number of text chunks may - * be in an image. - */ - int num_text; /* number of comments read/to write */ - int max_text; /* current size of text array */ - png_textp text; /* array of comments read/to write */ -#endif /* PNG_TEXT_SUPPORTED */ - -#if defined(PNG_tIME_SUPPORTED) - /* The tIME chunk holds the last time the displayed image data was - * modified. See the png_time struct for the contents of this struct. - */ - png_time mod_time; -#endif - -#if defined(PNG_sBIT_SUPPORTED) - /* The sBIT chunk specifies the number of significant high-order bits - * in the pixel data. Values are in the range [1, bit_depth], and are - * only specified for the channels in the pixel data. The contents of - * the low-order bits is not specified. Data is valid if - * (valid & PNG_INFO_sBIT) is non-zero. - */ - png_color_8 sig_bit; /* significant bits in color channels */ -#endif - -#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ -defined(PNG_READ_BACKGROUND_SUPPORTED) - /* The tRNS chunk supplies transparency data for paletted images and - * other image types that don't need a full alpha channel. There are - * "num_trans" transparency values for a paletted image, stored in the - * same order as the palette colors, starting from index 0. Values - * for the data are in the range [0, 255], ranging from fully transparent - * to fully opaque, respectively. For non-paletted images, there is a - * single color specified that should be treated as fully transparent. - * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. - */ - png_bytep trans; /* transparent values for paletted image */ - png_color_16 trans_values; /* transparent color for non-palette image */ -#endif - -#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - /* The bKGD chunk gives the suggested image background color if the - * display program does not have its own background color and the image - * is needs to composited onto a background before display. The colors - * in "background" are normally in the same color space/depth as the - * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. - */ - png_color_16 background; -#endif - -#if defined(PNG_oFFs_SUPPORTED) - /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards - * and downwards from the top-left corner of the display, page, or other - * application-specific co-ordinate space. See the PNG_OFFSET_ defines - * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. - */ - png_int_32 x_offset; /* x offset on page */ - png_int_32 y_offset; /* y offset on page */ - png_byte offset_unit_type; /* offset units type */ -#endif - -#if defined(PNG_pHYs_SUPPORTED) - /* The pHYs chunk gives the physical pixel density of the image for - * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ - * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. - */ - png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ - png_uint_32 y_pixels_per_unit; /* vertical pixel density */ - png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ -#endif - -#if defined(PNG_hIST_SUPPORTED) - /* The hIST chunk contains the relative frequency or importance of the - * various palette entries, so that a viewer can intelligently select a - * reduced-color palette, if required. Data is an array of "num_palette" - * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) - * is non-zero. - */ - png_uint_16p hist; -#endif - -#ifdef PNG_cHRM_SUPPORTED - /* The cHRM chunk describes the CIE color characteristics of the monitor - * on which the PNG was created. This data allows the viewer to do gamut - * mapping of the input image to ensure that the viewer sees the same - * colors in the image as the creator. Values are in the range - * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. - */ -#ifdef PNG_FLOATING_POINT_SUPPORTED - float x_white; - float y_white; - float x_red; - float y_red; - float x_green; - float y_green; - float x_blue; - float y_blue; -#endif -#endif - -#if defined(PNG_pCAL_SUPPORTED) - /* The pCAL chunk describes a transformation between the stored pixel - * values and original physical data values used to create the image. - * The integer range [0, 2^bit_depth - 1] maps to the floating-point - * range given by [pcal_X0, pcal_X1], and are further transformed by a - * (possibly non-linear) transformation function given by "pcal_type" - * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ - * defines below, and the PNG-Group's PNG extensions document for a - * complete description of the transformations and how they should be - * implemented, and for a description of the ASCII parameter strings. - * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. - */ - png_charp pcal_purpose; /* pCAL chunk description string */ - png_int_32 pcal_X0; /* minimum value */ - png_int_32 pcal_X1; /* maximum value */ - png_charp pcal_units; /* Latin-1 string giving physical units */ - png_charpp pcal_params; /* ASCII strings containing parameter values */ - png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ - png_byte pcal_nparams; /* number of parameters given in pcal_params */ -#endif - -/* New members added in libpng-1.0.6 */ -#ifdef PNG_FREE_ME_SUPPORTED - png_uint_32 free_me; /* flags items libpng is responsible for freeing */ -#endif - -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) - /* storage for unknown chunks that the library doesn't recognize. */ - png_unknown_chunkp unknown_chunks; - png_size_t unknown_chunks_num; -#endif - -#if defined(PNG_iCCP_SUPPORTED) - /* iCCP chunk data. */ - png_charp iccp_name; /* profile name */ - png_charp iccp_profile; /* International Color Consortium profile data */ - /* Note to maintainer: should be png_bytep */ - png_uint_32 iccp_proflen; /* ICC profile data length */ - png_byte iccp_compression; /* Always zero */ -#endif - -#if defined(PNG_sPLT_SUPPORTED) - /* data on sPLT chunks (there may be more than one). */ - png_sPLT_tp splt_palettes; - png_uint_32 splt_palettes_num; -#endif - -#if defined(PNG_sCAL_SUPPORTED) - /* The sCAL chunk describes the actual physical dimensions of the - * subject matter of the graphic. The chunk contains a unit specification - * a byte value, and two ASCII strings representing floating-point - * values. The values are width and height corresponsing to one pixel - * in the image. This external representation is converted to double - * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. - */ - png_byte scal_unit; /* unit of physical scale */ -#ifdef PNG_FLOATING_POINT_SUPPORTED - double scal_pixel_width; /* width of one pixel */ - double scal_pixel_height; /* height of one pixel */ -#endif -#ifdef PNG_FIXED_POINT_SUPPORTED - png_charp scal_s_width; /* string containing height */ - png_charp scal_s_height; /* string containing width */ -#endif -#endif - -#if defined(PNG_INFO_IMAGE_SUPPORTED) - /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ - /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ - png_bytepp row_pointers; /* the image bits */ -#endif - -#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) - png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */ -#endif - -#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) - png_fixed_point int_x_white; - png_fixed_point int_y_white; - png_fixed_point int_x_red; - png_fixed_point int_y_red; - png_fixed_point int_x_green; - png_fixed_point int_y_green; - png_fixed_point int_x_blue; - png_fixed_point int_y_blue; -#endif +/* Values for the unknown chunk location byte */ -} png_info; +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_AFTER_IDAT 0x08 +/* The complete definition of png_info has, as of libpng-1.5.0, + * been moved into a separate header file that is not accessible to + * applications. Read libpng-manual.txt or libpng.3 for more info. + */ +typedef struct png_info_def png_info; typedef png_info FAR * png_infop; +typedef PNG_CONST png_info FAR * png_const_infop; typedef png_info FAR * FAR * png_infopp; /* Maximum positive integer used in PNG is (2^31)-1 */ #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) #define PNG_UINT_32_MAX ((png_uint_32)(-1)) #define PNG_SIZE_MAX ((png_size_t)(-1)) -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */ -#define PNG_MAX_UINT PNG_UINT_31_MAX -#endif + +/* These are constants for fixed point values encoded in the + * PNG specification manner (x100000) + */ +#define PNG_FP_1 100000 +#define PNG_FP_HALF 50000 +#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) +#define PNG_FP_MIN (-PNG_FP_MAX) /* These describe the color_type field in png_info. */ /* color type masks */ @@ -1013,7 +796,7 @@ typedef png_info FAR * FAR * png_infopp; #define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ #define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ #define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ -#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */ /* This is used for the transformation routines, as some of them * change these values for the row. It also should enable using @@ -1021,53 +804,86 @@ typedef png_info FAR * FAR * png_infopp; */ typedef struct png_row_info_struct { - png_uint_32 width; /* width of row */ - png_uint_32 rowbytes; /* number of bytes in row */ - png_byte color_type; /* color type of row */ - png_byte bit_depth; /* bit depth of row */ - png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_uint_32 width; /* width of row */ + png_size_t rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ png_byte pixel_depth; /* bits per pixel (depth * channels) */ } png_row_info; typedef png_row_info FAR * png_row_infop; typedef png_row_info FAR * FAR * png_row_infopp; +/* The complete definition of png_struct has, as of libpng-1.5.0, + * been moved into a separate header file that is not accessible to + * applications. Read libpng-manual.txt or libpng.3 for more info. + */ +typedef struct png_struct_def png_struct; +typedef PNG_CONST png_struct FAR * png_const_structp; +typedef png_struct FAR * png_structp; + /* These are the function types for the I/O functions and for the functions * that allow the user to override the default I/O functions with his or her * own. The png_error_ptr type should match that of user-supplied warning * and error functions, while the png_rw_ptr type should match that of the - * user read/write data functions. + * user read/write data functions. Note that the 'write' function must not + * modify the buffer it is passed. The 'read' function, on the other hand, is + * expected to return the read data in the buffer. */ -typedef struct png_struct_def png_struct; -typedef png_struct FAR * png_structp; - -typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); -typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); -typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); -typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, - int)); -typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, - int)); +typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); +typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t)); +typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); +typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, + int)); +typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, + int)); #ifdef PNG_PROGRESSIVE_READ_SUPPORTED -typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); -typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); -typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, - png_uint_32, int)); +typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); +typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); + +/* The following callback receives png_uint_32 row_number, int pass for the + * png_bytep data of the row. When transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, + png_uint_32, int)); #endif #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_LEGACY_SUPPORTED) -typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, - png_row_infop, png_bytep)); + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, + png_bytep)); #endif -#if defined(PNG_USER_CHUNKS_SUPPORTED) -typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +#ifdef PNG_USER_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, + png_unknown_chunkp)); #endif -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) -typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This must match the function definition in , and the application + * must include this before png.h to obtain the definition of jmp_buf. The + * function is required to be PNG_NORETURN, but this is not checked. If the + * function does return the application will crash via an abort() or similar + * system level call. + * + * If you get a warning here while building the library you may need to make + * changes to ensure that pnglibconf.h records the calling convention used by + * your compiler. This may be very difficult - try using a different compiler + * to build the library! + */ +PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); #endif /* Transform masks for the high-level interface */ @@ -1083,662 +899,653 @@ typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ -#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +/* Added to libpng-1.4.0 */ +#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ +/* Added to libpng-1.5.4 */ +#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ +#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ /* Flags for MNG supported features */ #define PNG_FLAG_MNG_EMPTY_PLTE 0x01 #define PNG_FLAG_MNG_FILTER_64 0x04 #define PNG_ALL_MNG_FEATURES 0x05 -typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); -typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); - -/* The structure that holds the information to read and write PNG files. - * The only people who need to care about what is inside of this are the - * people who will be modifying the library for their own special needs. - * It should NOT be accessed directly by an application, except to store - * the jmp_buf. - */ - -struct png_struct_def -{ -#ifdef PNG_SETJMP_SUPPORTED - jmp_buf jmpbuf; /* used in png_error */ -#endif - png_error_ptr error_fn; /* function for printing errors and aborting */ - png_error_ptr warning_fn; /* function for printing warnings */ - png_voidp error_ptr; /* user supplied struct for error functions */ - png_rw_ptr write_data_fn; /* function for writing output data */ - png_rw_ptr read_data_fn; /* function for reading input data */ - png_voidp io_ptr; /* ptr to application struct for I/O functions */ - -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) - png_user_transform_ptr read_user_transform_fn; /* user read transform */ -#endif - -#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) - png_user_transform_ptr write_user_transform_fn; /* user write transform */ -#endif - -/* These were added in libpng-1.0.2 */ -#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) - png_voidp user_transform_ptr; /* user supplied struct for user transform */ - png_byte user_transform_depth; /* bit depth of user transformed pixels */ - png_byte user_transform_channels; /* channels in user transformed pixels */ -#endif -#endif - - png_uint_32 mode; /* tells us where we are in the PNG file */ - png_uint_32 flags; /* flags indicating various things to libpng */ - png_uint_32 transformations; /* which transformations to perform */ - - z_stream zstream; /* pointer to decompression structure (below) */ - png_bytep zbuf; /* buffer for zlib */ - png_size_t zbuf_size; /* size of zbuf */ - int zlib_level; /* holds zlib compression level */ - int zlib_method; /* holds zlib compression method */ - int zlib_window_bits; /* holds zlib compression window bits */ - int zlib_mem_level; /* holds zlib compression memory level */ - int zlib_strategy; /* holds zlib compression strategy */ - - png_uint_32 width; /* width of image in pixels */ - png_uint_32 height; /* height of image in pixels */ - png_uint_32 num_rows; /* number of rows in current pass */ - png_uint_32 usr_width; /* width of row at start of write */ - png_uint_32 rowbytes; /* size of row in bytes */ - png_uint_32 irowbytes; /* size of current interlaced row in bytes */ - png_uint_32 iwidth; /* width of current interlaced row in pixels */ - png_uint_32 row_number; /* current row in interlace pass */ - png_bytep prev_row; /* buffer to save previous (unfiltered) row */ - png_bytep row_buf; /* buffer to save current (unfiltered) row */ - png_bytep sub_row; /* buffer to save "sub" row when filtering */ - png_bytep up_row; /* buffer to save "up" row when filtering */ - png_bytep avg_row; /* buffer to save "avg" row when filtering */ - png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ - png_row_info row_info; /* used for transformation routines */ - - png_uint_32 idat_size; /* current IDAT size for read */ - png_uint_32 crc; /* current chunk CRC value */ - png_colorp palette; /* palette from the input file */ - png_uint_16 num_palette; /* number of color entries in palette */ - png_uint_16 num_trans; /* number of transparency values */ - png_byte chunk_name[5]; /* null-terminated name of current chunk */ - png_byte compression; /* file compression type (always 0) */ - png_byte filter; /* file filter type (always 0) */ - png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ - png_byte pass; /* current interlace pass (0 - 6) */ - png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ - png_byte color_type; /* color type of file */ - png_byte bit_depth; /* bit depth of file */ - png_byte usr_bit_depth; /* bit depth of users row */ - png_byte pixel_depth; /* number of bits per pixel */ - png_byte channels; /* number of channels in file */ - png_byte usr_channels; /* channels at start of write */ - png_byte sig_bytes; /* magic bytes read/written from start of file */ - -#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) -#ifdef PNG_LEGACY_SUPPORTED - png_byte filler; /* filler byte for pixel expansion */ -#else - png_uint_16 filler; /* filler bytes for pixel expansion */ -#endif -#endif - -#if defined(PNG_bKGD_SUPPORTED) - png_byte background_gamma_type; -# ifdef PNG_FLOATING_POINT_SUPPORTED - float background_gamma; -# endif - png_color_16 background; /* background color in screen gamma space */ -#if defined(PNG_READ_GAMMA_SUPPORTED) - png_color_16 background_1; /* background normalized to gamma 1.0 */ -#endif -#endif /* PNG_bKGD_SUPPORTED */ - -#if defined(PNG_WRITE_FLUSH_SUPPORTED) - png_flush_ptr output_flush_fn;/* Function for flushing output */ - png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ - png_uint_32 flush_rows; /* number of rows written since last flush */ -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ -#ifdef PNG_FLOATING_POINT_SUPPORTED - float gamma; /* file gamma value */ - float screen_gamma; /* screen gamma value (display_exponent) */ -#endif -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - png_bytep gamma_table; /* gamma table for 8-bit depth files */ - png_bytep gamma_from_1; /* converts from 1.0 to screen */ - png_bytep gamma_to_1; /* converts from file to 1.0 */ - png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ - png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ - png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) - png_color_8 sig_bit; /* significant bits in each available channel */ -#endif - -#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) - png_color_8 shift; /* shift for significant bit tranformation */ -#endif - -#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ - || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - png_bytep trans; /* transparency values for paletted files */ - png_color_16 trans_values; /* transparency values for non-paletted files */ -#endif - - png_read_status_ptr read_row_fn; /* called after each row is decoded */ - png_write_status_ptr write_row_fn; /* called after each row is encoded */ -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED - png_progressive_info_ptr info_fn; /* called after header data fully read */ - png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ - png_progressive_end_ptr end_fn; /* called after image is complete */ - png_bytep save_buffer_ptr; /* current location in save_buffer */ - png_bytep save_buffer; /* buffer for previously read data */ - png_bytep current_buffer_ptr; /* current location in current_buffer */ - png_bytep current_buffer; /* buffer for recently used data */ - png_uint_32 push_length; /* size of current input chunk */ - png_uint_32 skip_length; /* bytes to skip in input data */ - png_size_t save_buffer_size; /* amount of data now in save_buffer */ - png_size_t save_buffer_max; /* total size of save_buffer */ - png_size_t buffer_size; /* total amount of available input data */ - png_size_t current_buffer_size; /* amount of data now in current_buffer */ - int process_mode; /* what push library is currently doing */ - int cur_palette; /* current push library palette index */ - -# if defined(PNG_TEXT_SUPPORTED) - png_size_t current_text_size; /* current size of text input data */ - png_size_t current_text_left; /* how much text left to read in input */ - png_charp current_text; /* current text chunk buffer */ - png_charp current_text_ptr; /* current location in current_text */ -# endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */ - -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ - -#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) -/* for the Borland special 64K segment handler */ - png_bytepp offset_table_ptr; - png_bytep offset_table; - png_uint_16 offset_table_number; - png_uint_16 offset_table_count; - png_uint_16 offset_table_count_free; -#endif - -#if defined(PNG_READ_DITHER_SUPPORTED) - png_bytep palette_lookup; /* lookup table for dithering */ - png_bytep dither_index; /* index translation for palette files */ -#endif - -#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) - png_uint_16p hist; /* histogram */ -#endif - -#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) - png_byte heuristic_method; /* heuristic for row filter selection */ - png_byte num_prev_filters; /* number of weights for previous rows */ - png_bytep prev_filters; /* filter type(s) of previous row(s) */ - png_uint_16p filter_weights; /* weight(s) for previous line(s) */ - png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ - png_uint_16p filter_costs; /* relative filter calculation cost */ - png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ -#endif - -#if defined(PNG_TIME_RFC1123_SUPPORTED) - png_charp time_buffer; /* String to hold RFC 1123 time text */ -#endif - -/* New members added in libpng-1.0.6 */ - -#ifdef PNG_FREE_ME_SUPPORTED - png_uint_32 free_me; /* flags items libpng is responsible for freeing */ -#endif - -#if defined(PNG_USER_CHUNKS_SUPPORTED) - png_voidp user_chunk_ptr; - png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ -#endif - -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) - int num_chunk_list; - png_bytep chunk_list; -#endif - -/* New members added in libpng-1.0.3 */ -#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) - png_byte rgb_to_gray_status; - /* These were changed from png_byte in libpng-1.0.6 */ - png_uint_16 rgb_to_gray_red_coeff; - png_uint_16 rgb_to_gray_green_coeff; - png_uint_16 rgb_to_gray_blue_coeff; -#endif - -/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ -#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ - defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ - defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) -/* changed from png_byte to png_uint_32 at version 1.2.0 */ -#ifdef PNG_1_0_X - png_byte mng_features_permitted; -#else - png_uint_32 mng_features_permitted; -#endif /* PNG_1_0_X */ -#endif - -/* New member added in libpng-1.0.7 */ -#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) - png_fixed_point int_gamma; -#endif - -/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ -#if defined(PNG_MNG_FEATURES_SUPPORTED) - png_byte filter_type; -#endif - -#if defined(PNG_1_0_X) || (defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD)) -/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ - png_uint_32 row_buf_size; -#endif - -/* New members added in libpng-1.2.0 */ -#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -# if !defined(PNG_1_0_X) -# if defined(PNG_MMX_CODE_SUPPORTED) - png_byte mmx_bitdepth_threshold; - png_uint_32 mmx_rowbytes_threshold; -# endif - png_uint_32 asm_flags; -# endif -#endif - -/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ -#ifdef PNG_USER_MEM_SUPPORTED - png_voidp mem_ptr; /* user supplied struct for mem functions */ - png_malloc_ptr malloc_fn; /* function for allocating memory */ - png_free_ptr free_fn; /* function for freeing memory */ -#endif - -/* New member added in libpng-1.0.13 and 1.2.0 */ - png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ - -#if defined(PNG_READ_DITHER_SUPPORTED) -/* The following three members were added at version 1.0.14 and 1.2.4 */ - png_bytep dither_sort; /* working sort array */ - png_bytep index_to_palette; /* where the original index currently is */ - /* in the palette */ - png_bytep palette_to_index; /* which original index points to this */ - /* palette color */ -#endif - -/* New members added in libpng-1.0.16 and 1.2.6 */ - png_byte compression_type; - -#ifdef PNG_SET_USER_LIMITS_SUPPORTED - png_uint_32 user_width_max; - png_uint_32 user_height_max; -#endif - -}; - - -/* This triggers a compiler error in png.c, if png.c and png.h - * do not agree upon the version number. +/* NOTE: prior to 1.5 these functions had no 'API' style declaration, + * this allowed the zlib default functions to be used on Windows + * platforms. In 1.5 the zlib default malloc (which just calls malloc and + * ignores the first argument) should be completely compatible with the + * following. */ -typedef png_structp version_1_2_15; +typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, + png_alloc_size_t)); +typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); typedef png_struct FAR * FAR * png_structpp; -/* Here are the function definitions most commonly used. This is not - * the place to find out how to use libpng. See libpng.txt for the +/* Section 3: exported functions + * Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng-manual.txt for the * full explanation, see example.c for the summary. This just provides * a simple one line description of the use of each function. + * + * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in + * pngconf.h and in the *.dfn files in the scripts directory. + * + * PNG_EXPORT(ordinal, type, name, (args)); + * + * ordinal: ordinal that is used while building + * *.def files. The ordinal value is only + * relevant when preprocessing png.h with + * the *.dfn files for building symbol table + * entries, and are removed by pngconf.h. + * type: return type of the function + * name: function name + * args: function arguments, with types + * + * When we wish to append attributes to a function prototype we use + * the PNG_EXPORTA() macro instead. + * + * PNG_EXPORTA(ordinal, type, name, (args), attributes); + * + * ordinal, type, name, and args: same as in PNG_EXPORT(). + * attributes: function attributes */ /* Returns the version number of the library */ -extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); +PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); /* Tell lib we have already handled the first magic bytes. * Handling more than 8 bytes from the beginning of the file is an error. */ -extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, - int num_bytes)); +PNG_EXPORT(2, void, png_set_sig_bytes, (png_structp png_ptr, int num_bytes)); /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a * PNG file. Returns zero if the supplied bytes match the 8-byte PNG * signature, and non-zero otherwise. Having num_to_check == 0 or * start > 7 will always fail (ie return non-zero). */ -extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, - png_size_t num_to_check)); +PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start, + png_size_t num_to_check)); /* Simple signature checking function. This is the same as calling * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). */ -extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); +#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) /* Allocate and initialize png_ptr struct for reading, and any other memory. */ -extern PNG_EXPORT(png_structp,png_create_read_struct) - PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn)); +PNG_EXPORTA(4, png_structp, png_create_read_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn), + PNG_ALLOCATED); /* Allocate and initialize png_ptr struct for writing, and any other memory */ -extern PNG_EXPORT(png_structp,png_create_write_struct) - PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn)); +PNG_EXPORTA(5, png_structp, png_create_write_struct, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn), + PNG_ALLOCATED); -#ifdef PNG_WRITE_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) - PNGARG((png_structp png_ptr)); -#endif +PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size, + (png_const_structp png_ptr)); -#ifdef PNG_WRITE_SUPPORTED -extern PNG_EXPORT(void,png_set_compression_buffer_size) - PNGARG((png_structp png_ptr, png_uint_32 size)); +PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structp png_ptr, + png_size_t size)); + +/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp + * match up. + */ +#ifdef PNG_SETJMP_SUPPORTED +/* This function returns the jmp_buf built in to *png_ptr. It must be + * supplied with an appropriate 'longjmp' function to use on that jmp_buf + * unless the default error function is overridden in which case NULL is + * acceptable. The size of the jmp_buf is checked against the actual size + * allocated by the library - the call will return NULL on a mismatch + * indicating an ABI mismatch. + */ +PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structp png_ptr, + png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)); +# define png_jmpbuf(png_ptr) \ + (*png_set_longjmp_fn((png_ptr), longjmp, sizeof (jmp_buf))) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) #endif +/* This function should be used by libpng applications in place of + * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it + * will use it; otherwise it will call PNG_ABORT(). This function was + * added in libpng-1.5.0. + */ +PNG_EXPORTA(9, void, png_longjmp, (png_structp png_ptr, int val), + PNG_NORETURN); +#ifdef PNG_READ_SUPPORTED /* Reset the compression stream */ -extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); +PNG_EXPORT(10, int, png_reset_zstream, (png_structp png_ptr)); +#endif /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ #ifdef PNG_USER_MEM_SUPPORTED -extern PNG_EXPORT(png_structp,png_create_read_struct_2) - PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, - png_malloc_ptr malloc_fn, png_free_ptr free_fn)); -extern PNG_EXPORT(png_structp,png_create_write_struct_2) - PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, - png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, - png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +PNG_EXPORTA(11, png_structp, png_create_read_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); +PNG_EXPORTA(12, png_structp, png_create_write_struct_2, + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warn_fn, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), + PNG_ALLOCATED); #endif +/* Write the PNG file signature. */ +PNG_EXPORT(13, void, png_write_sig, (png_structp png_ptr)); + /* Write a PNG chunk - size, type, (optional) data, CRC. */ -extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, - png_bytep chunk_name, png_bytep data, png_size_t length)); +PNG_EXPORT(14, void, png_write_chunk, (png_structp png_ptr, png_const_bytep + chunk_name, png_const_bytep data, png_size_t length)); /* Write the start of a PNG chunk - length and chunk name. */ -extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, - png_bytep chunk_name, png_uint_32 length)); +PNG_EXPORT(15, void, png_write_chunk_start, (png_structp png_ptr, + png_const_bytep chunk_name, png_uint_32 length)); /* Write the data of a PNG chunk started with png_write_chunk_start(). */ -extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, - png_bytep data, png_size_t length)); +PNG_EXPORT(16, void, png_write_chunk_data, (png_structp png_ptr, + png_const_bytep data, png_size_t length)); /* Finish a chunk started with png_write_chunk_start() (includes CRC). */ -extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); +PNG_EXPORT(17, void, png_write_chunk_end, (png_structp png_ptr)); /* Allocate and initialize the info structure */ -extern PNG_EXPORT(png_infop,png_create_info_struct) - PNGARG((png_structp png_ptr)); - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Initialize the info structure (old interface - DEPRECATED) */ -extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); -#undef png_info_init -#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ - png_sizeof(png_info)); -#endif +PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_structp png_ptr), + PNG_ALLOCATED); -extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, +PNG_EXPORT(19, void, png_info_init_3, (png_infopp info_ptr, png_size_t png_info_struct_size)); /* Writes all the PNG information before the image. */ -extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, - png_infop info_ptr)); -extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, - png_infop info_ptr)); +PNG_EXPORT(20, void, png_write_info_before_PLTE, + (png_structp png_ptr, png_infop info_ptr)); +PNG_EXPORT(21, void, png_write_info, + (png_structp png_ptr, png_infop info_ptr)); -#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED -/* read the information before the actual image data. */ -extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, - png_infop info_ptr)); +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the information before the actual image data. */ +PNG_EXPORT(22, void, png_read_info, + (png_structp png_ptr, png_infop info_ptr)); #endif -#if defined(PNG_TIME_RFC1123_SUPPORTED) -extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) - PNGARG((png_structp png_ptr, png_timep ptime)); +#ifdef PNG_TIME_RFC1123_SUPPORTED +PNG_EXPORT(23, png_const_charp, png_convert_to_rfc1123, + (png_structp png_ptr, + png_const_timep ptime)); #endif -#if !defined(_WIN32_WCE) -/* "time.h" functions are not supported on WindowsCE */ -#if defined(PNG_WRITE_tIME_SUPPORTED) -/* convert from a struct tm to png_time */ -extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, - struct tm FAR * ttime)); +#ifdef PNG_CONVERT_tIME_SUPPORTED +/* Convert from a struct tm to png_time */ +PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, + PNG_CONST struct tm FAR * ttime)); -/* convert from time_t to png_time. Uses gmtime() */ -extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, - time_t ttime)); -#endif /* PNG_WRITE_tIME_SUPPORTED */ -#endif /* _WIN32_WCE */ +/* Convert from time_t to png_time. Uses gmtime() */ +PNG_EXPORT(25, void, png_convert_from_time_t, + (png_timep ptime, time_t ttime)); +#endif /* PNG_CONVERT_tIME_SUPPORTED */ -#if defined(PNG_READ_EXPAND_SUPPORTED) +#ifdef PNG_READ_EXPAND_SUPPORTED /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ -extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); -#if !defined(PNG_1_0_X) -extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp - png_ptr)); -#endif -extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); -extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Deprecated */ -extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +PNG_EXPORT(26, void, png_set_expand, (png_structp png_ptr)); +PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structp png_ptr)); +PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structp png_ptr)); +PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structp png_ptr)); #endif + +#ifdef PNG_READ_EXPAND_16_SUPPORTED +/* Expand to 16-bit channels, forces conversion of palette to RGB and expansion + * of a tRNS chunk if present. + */ +PNG_EXPORT(221, void, png_set_expand_16, (png_structp png_ptr)); #endif #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) /* Use blue, green, red order for pixels. */ -extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +PNG_EXPORT(30, void, png_set_bgr, (png_structp png_ptr)); #endif -#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED /* Expand the grayscale to 24-bit RGB if necessary. */ -extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structp png_ptr)); #endif -#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED /* Reduce RGB to grayscale. */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, - int error_action, double red, double green )); +PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structp png_ptr, + int error_action, double red, double green)); +PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green)); + +PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structp + png_ptr)); #endif -extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, - int error_action, png_fixed_point red, png_fixed_point green )); -extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp - png_ptr)); + +#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, + png_colorp palette)); +#endif + +#ifdef PNG_READ_ALPHA_MODE_SUPPORTED +/* How the alpha channel is interpreted - this affects how the color channels of + * a PNG file are returned when an alpha channel, or tRNS chunk in a palette + * file, is present. + * + * This has no effect on the way pixels are written into a PNG output + * datastream. The color samples in a PNG datastream are never premultiplied + * with the alpha samples. + * + * The default is to return data according to the PNG specification: the alpha + * channel is a linear measure of the contribution of the pixel to the + * corresponding composited pixel. The gamma encoded color channels must be + * scaled according to the contribution and to do this it is necessary to undo + * the encoding, scale the color values, perform the composition and reencode + * the values. This is the 'PNG' mode. + * + * The alternative is to 'associate' the alpha with the color information by + * storing color channel values that have been scaled by the alpha. The + * advantage is that the color channels can be resampled (the image can be + * scaled) in this form. The disadvantage is that normal practice is to store + * linear, not (gamma) encoded, values and this requires 16-bit channels for + * still images rather than the 8-bit channels that are just about sufficient if + * gamma encoding is used. In addition all non-transparent pixel values, + * including completely opaque ones, must be gamma encoded to produce the final + * image. This is the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' mode (the + * latter being the two common names for associated alpha color channels.) + * + * Since it is not necessary to perform arithmetic on opaque color values so + * long as they are not to be resampled and are in the final color space it is + * possible to optimize the handling of alpha by storing the opaque pixels in + * the PNG format (adjusted for the output color space) while storing partially + * opaque pixels in the standard, linear, format. The accuracy required for + * standard alpha composition is relatively low, because the pixels are + * isolated, therefore typically the accuracy loss in storing 8-bit linear + * values is acceptable. (This is not true if the alpha channel is used to + * simulate transparency over large areas - use 16 bits or the PNG mode in + * this case!) This is the 'OPTIMIZED' mode. For this mode a pixel is + * treated as opaque only if the alpha value is equal to the maximum value. + * + * The final choice is to gamma encode the alpha channel as well. This is + * broken because, in practice, no implementation that uses this choice + * correctly undoes the encoding before handling alpha composition. Use this + * choice only if other serious errors in the software or hardware you use + * mandate it; the typical serious error is for dark halos to appear around + * opaque areas of the composited PNG image because of arithmetic overflow. + * + * The API function png_set_alpha_mode specifies which of these choices to use + * with an enumerated 'mode' value and the gamma of the required output: + */ +#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ +#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ +#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ +#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ +#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ +#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ + +PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structp png_ptr, int mode, + double output_gamma)); +PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structp png_ptr, + int mode, png_fixed_point output_gamma)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED) +/* The output_gamma value is a screen gamma in libpng terminology: it expresses + * how to decode the output values, not how they are encoded. The values used + * correspond to the normal numbers used to describe the overall gamma of a + * computer display system; for example 2.2 for an sRGB conformant system. The + * values are scaled by 100000 in the _fixed version of the API (so 220000 for + * sRGB.) + * + * The inverse of the value is always used to provide a default for the PNG file + * encoding if it has no gAMA chunk and if png_set_gamma() has not been called + * to override the PNG gamma information. + * + * When the ALPHA_OPTIMIZED mode is selected the output gamma is used to encode + * opaque pixels however pixels with lower alpha values are not encoded, + * regardless of the output gamma setting. + * + * When the standard Porter Duff handling is requested with mode 1 the output + * encoding is set to be linear and the output_gamma value is only relevant + * as a default for input data that has no gamma information. The linear output + * encoding will be overridden if png_set_gamma() is called - the results may be + * highly unexpected! + * + * The following numbers are derived from the sRGB standard and the research + * behind it. sRGB is defined to be approximated by a PNG gAMA chunk value of + * 0.45455 (1/2.2) for PNG. The value implicitly includes any viewing + * correction required to take account of any differences in the color + * environment of the original scene and the intended display environment; the + * value expresses how to *decode* the image for display, not how the original + * data was *encoded*. + * + * sRGB provides a peg for the PNG standard by defining a viewing environment. + * sRGB itself, and earlier TV standards, actually use a more complex transform + * (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is + * limited to simple power laws.) By saying that an image for direct display on + * an sRGB conformant system should be stored with a gAMA chunk value of 45455 + * (11.3.3.2 and 11.3.3.5 of the ISO PNG specification) the PNG specification + * makes it possible to derive values for other display systems and + * environments. + * + * The Mac value is deduced from the sRGB based on an assumption that the actual + * extra viewing correction used in early Mac display systems was implemented as + * a power 1.45 lookup table. + * + * Any system where a programmable lookup table is used or where the behavior of + * the final display device characteristics can be changed requires system + * specific code to obtain the current characteristic. However this can be + * difficult and most PNG gamma correction only requires an approximate value. + * + * By default, if png_set_alpha_mode() is not called, libpng assumes that all + * values are unencoded, linear, values and that the output device also has a + * linear characteristic. This is only very rarely correct - it is invariably + * better to call png_set_alpha_mode() with PNG_DEFAULT_sRGB than rely on the + * default if you don't know what the right answer is! + * + * The special value PNG_GAMMA_MAC_18 indicates an older Mac system (pre Mac OS + * 10.6) which used a correction table to implement a somewhat lower gamma on an + * otherwise sRGB system. + * + * Both these values are reserved (not simple gamma values) in order to allow + * more precise correction internally in the future. + * + * NOTE: the following values can be passed to either the fixed or floating + * point APIs, but the floating point API will also accept floating point + * values. + */ +#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ +#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ +#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ +#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ #endif -extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, - png_colorp palette)); +/* The following are examples of calls to png_set_alpha_mode to achieve the + * required overall gamma correction and, where necessary, alpha + * premultiplication. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * This is the default libpng handling of the alpha channel - it is not + * pre-multiplied into the color components. In addition the call states + * that the output is for a sRGB system and causes all PNG files without gAMA + * chunks to be assumed to be encoded using sRGB. + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * In this case the output is assumed to be something like an sRGB conformant + * display preceeded by a power-law lookup table of power 1.45. This is how + * early Mac systems behaved. + * + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); + * This is the classic Jim Blinn approach and will work in academic + * environments where everything is done by the book. It has the shortcoming + * of assuming that input PNG data with no gamma information is linear - this + * is unlikely to be correct unless the PNG files where generated locally. + * Most of the time the output precision will be so low as to show + * significant banding in dark areas of the image. + * + * png_set_expand_16(pp); + * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); + * This is a somewhat more realistic Jim Blinn inspired approach. PNG files + * are assumed to have the sRGB encoding if not marked with a gamma value and + * the output is always 16 bits per component. This permits accurate scaling + * and processing of the data. If you know that your input PNG files were + * generated locally you might need to replace PNG_DEFAULT_sRGB with the + * correct value for your system. + * + * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); + * If you just need to composite the PNG image onto an existing background + * and if you control the code that does this you can use the optimization + * setting. In this case you just copy completely opaque pixels to the + * output. For pixels that are not completely transparent (you just skip + * those) you do the composition math using png_composite or png_composite_16 + * below then encode the resultant 8-bit or 16-bit values to match the output + * encoding. + * + * Other cases + * If neither the PNG nor the standard linear encoding work for you because + * of the software or hardware you use then you have a big problem. The PNG + * case will probably result in halos around the image. The linear encoding + * will probably result in a washed out, too bright, image (it's actually too + * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably + * substantially reduce the halos. Alternatively try: + * + * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); + * This option will also reduce the halos, but there will be slight dark + * halos round the opaque parts of the image where the background is light. + * In the OPTIMIZED mode the halos will be light halos where the background + * is dark. Take your pick - the halos are unavoidable unless you can get + * your hardware/software fixed! (The OPTIMIZED approach is slightly + * faster.) + * + * When the default gamma of PNG files doesn't match the output gamma. + * If you have PNG files with no gamma information png_set_alpha_mode allows + * you to provide a default gamma, but it also sets the ouput gamma to the + * matching value. If you know your PNG files have a gamma that doesn't + * match the output you can take advantage of the fact that + * png_set_alpha_mode always sets the output gamma but only sets the PNG + * default if it is not already set: + * + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); + * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); + * The first call sets both the default and the output gamma values, the + * second call overrides the output gamma without changing the default. This + * is easier than achieving the same effect with png_set_gamma. You must use + * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will + * fire if more than one call to png_set_alpha_mode and png_set_background is + * made in the same read operation, however multiple calls with PNG_ALPHA_PNG + * are ignored. + */ -#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +PNG_EXPORT(36, void, png_set_strip_alpha, (png_structp png_ptr)); #endif #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +PNG_EXPORT(37, void, png_set_swap_alpha, (png_structp png_ptr)); #endif #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +PNG_EXPORT(38, void, png_set_invert_alpha, (png_structp png_ptr)); #endif #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) /* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ -extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, - png_uint_32 filler, int flags)); +PNG_EXPORT(39, void, png_set_filler, (png_structp png_ptr, png_uint_32 filler, + int flags)); /* The values of the PNG_FILLER_ defines should NOT be changed */ -#define PNG_FILLER_BEFORE 0 -#define PNG_FILLER_AFTER 1 +# define PNG_FILLER_BEFORE 0 +# define PNG_FILLER_AFTER 1 /* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ -#if !defined(PNG_1_0_X) -extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, - png_uint_32 filler, int flags)); -#endif +PNG_EXPORT(40, void, png_set_add_alpha, + (png_structp png_ptr, png_uint_32 filler, + int flags)); #endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) /* Swap bytes in 16-bit depth files. */ -extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +PNG_EXPORT(41, void, png_set_swap, (png_structp png_ptr)); #endif #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ -extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +PNG_EXPORT(42, void, png_set_packing, (png_structp png_ptr)); #endif -#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ + defined(PNG_WRITE_PACKSWAP_SUPPORTED) /* Swap packing order of pixels in bytes. */ -extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +PNG_EXPORT(43, void, png_set_packswap, (png_structp png_ptr)); #endif #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) /* Converts files to legal bit depths. */ -extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, - png_color_8p true_bits)); +PNG_EXPORT(44, void, png_set_shift, (png_structp png_ptr, png_const_color_8p + true_bits)); #endif #if defined(PNG_READ_INTERLACING_SUPPORTED) || \ defined(PNG_WRITE_INTERLACING_SUPPORTED) -/* Have the code handle the interlacing. Returns the number of passes. */ -extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +/* Have the code handle the interlacing. Returns the number of passes. + * MUST be called before png_read_update_info or png_start_read_image, + * otherwise it will not have the desired effect. Note that it is still + * necessary to call png_read_row or png_read_rows png_get_image_height + * times for each pass. +*/ +PNG_EXPORT(45, int, png_set_interlace_handling, (png_structp png_ptr)); #endif #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) /* Invert monochrome files */ -extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +PNG_EXPORT(46, void, png_set_invert_mono, (png_structp png_ptr)); #endif -#if defined(PNG_READ_BACKGROUND_SUPPORTED) -/* Handle alpha and tRNS by replacing with a background color. */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, - png_color_16p background_color, int background_gamma_code, - int need_expand, double background_gamma)); +#ifdef PNG_READ_BACKGROUND_SUPPORTED +/* Handle alpha and tRNS by replacing with a background color. Prior to + * libpng-1.5.4 this API must not be called before the PNG file header has been + * read. Doing so will result in unexpected behavior and possible warnings or + * errors if the PNG file contains a bKGD chunk. + */ +PNG_FP_EXPORT(47, void, png_set_background, (png_structp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structp png_ptr, + png_const_color_16p background_color, int background_gamma_code, + int need_expand, png_fixed_point background_gamma)); #endif -#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 -#define PNG_BACKGROUND_GAMMA_SCREEN 1 -#define PNG_BACKGROUND_GAMMA_FILE 2 -#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#ifdef PNG_READ_BACKGROUND_SUPPORTED +# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +# define PNG_BACKGROUND_GAMMA_SCREEN 1 +# define PNG_BACKGROUND_GAMMA_FILE 2 +# define PNG_BACKGROUND_GAMMA_UNIQUE 3 #endif -#if defined(PNG_READ_16_TO_8_SUPPORTED) -/* strip the second byte of information from a 16-bit depth file. */ -extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED +/* Scale a 16-bit depth file down to 8-bit, accurately. */ +PNG_EXPORT(229, void, png_set_scale_16, (png_structp png_ptr)); #endif -#if defined(PNG_READ_DITHER_SUPPORTED) -/* Turn on dithering, and reduce the palette to the number of colors available. */ -extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, - png_colorp palette, int num_palette, int maximum_colors, - png_uint_16p histogram, int full_dither)); +#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ +/* Strip the second byte of information from a 16-bit depth file. */ +PNG_EXPORT(48, void, png_set_strip_16, (png_structp png_ptr)); #endif -#if defined(PNG_READ_GAMMA_SUPPORTED) -/* Handle gamma correction. Screen_gamma=(display_exponent) */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, - double screen_gamma, double default_file_gamma)); -#endif +#ifdef PNG_READ_QUANTIZE_SUPPORTED +/* Turn on quantizing, and reduce the palette to the number of colors + * available. + */ +PNG_EXPORT(49, void, png_set_quantize, + (png_structp png_ptr, png_colorp palette, + int num_palette, int maximum_colors, png_const_uint_16p histogram, + int full_quantize)); #endif -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ - defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) -/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ -/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ -extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, - int empty_plte_permitted)); -#endif +#ifdef PNG_READ_GAMMA_SUPPORTED +/* The threshold on gamma processing is configurable but hard-wired into the + * library. The following is the floating point variant. + */ +#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +/* Handle gamma correction. Screen_gamma=(display_exponent). + * NOTE: this API simply sets the screen and file gamma values. It will + * therefore override the value for gamma in a PNG file if it is called after + * the file header has been read - use with care - call before reading the PNG + * file for best results! + * + * These routines accept the same gamma values as png_set_alpha_mode (described + * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either + * API (floating point or fixed.) Notice, however, that the 'file_gamma' value + * is the inverse of a 'screen gamma' value. + */ +PNG_FP_EXPORT(50, void, png_set_gamma, + (png_structp png_ptr, double screen_gamma, + double override_file_gamma)); +PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structp png_ptr, + png_fixed_point screen_gamma, png_fixed_point override_file_gamma)); #endif -#if defined(PNG_WRITE_FLUSH_SUPPORTED) +#ifdef PNG_WRITE_FLUSH_SUPPORTED /* Set how many lines between output flushes - 0 for no flushing */ -extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +PNG_EXPORT(51, void, png_set_flush, (png_structp png_ptr, int nrows)); /* Flush the current PNG output buffer */ -extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +PNG_EXPORT(52, void, png_write_flush, (png_structp png_ptr)); #endif -/* optional update palette with requested transformations */ -extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); +/* Optional update palette with requested transformations */ +PNG_EXPORT(53, void, png_start_read_image, (png_structp png_ptr)); -/* optional call to update the users info structure */ -extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, - png_infop info_ptr)); +/* Optional call to update the users info structure */ +PNG_EXPORT(54, void, png_read_update_info, + (png_structp png_ptr, png_infop info_ptr)); -#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED -/* read one or more rows of image data. */ -extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, - png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read one or more rows of image data. */ +PNG_EXPORT(55, void, png_read_rows, (png_structp png_ptr, png_bytepp row, + png_bytepp display_row, png_uint_32 num_rows)); #endif -#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED -/* read a row of data. */ -extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, - png_bytep row, - png_bytep display_row)); +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read a row of data. */ +PNG_EXPORT(56, void, png_read_row, (png_structp png_ptr, png_bytep row, + png_bytep display_row)); #endif -#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED -/* read the whole image into memory at once. */ -extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, - png_bytepp image)); +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the whole image into memory at once. */ +PNG_EXPORT(57, void, png_read_image, (png_structp png_ptr, png_bytepp image)); #endif -/* write a row of image data */ -extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, - png_bytep row)); +/* Write a row of image data */ +PNG_EXPORT(58, void, png_write_row, + (png_structp png_ptr, png_const_bytep row)); -/* write a few rows of image data */ -extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, - png_bytepp row, png_uint_32 num_rows)); +/* Write a few rows of image data: (*row) is not written; however, the type + * is declared as writeable to maintain compatibility with previous versions + * of libpng and to allow the 'display_row' array from read_rows to be passed + * unchanged to write_rows. + */ +PNG_EXPORT(59, void, png_write_rows, (png_structp png_ptr, png_bytepp row, + png_uint_32 num_rows)); -/* write the image data */ -extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, - png_bytepp image)); +/* Write the image data */ +PNG_EXPORT(60, void, png_write_image, + (png_structp png_ptr, png_bytepp image)); -/* writes the end of the PNG file. */ -extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, - png_infop info_ptr)); +/* Write the end of the PNG file. */ +PNG_EXPORT(61, void, png_write_end, + (png_structp png_ptr, png_infop info_ptr)); -#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED -/* read the end of the PNG file. */ -extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, - png_infop info_ptr)); +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED +/* Read the end of the PNG file. */ +PNG_EXPORT(62, void, png_read_end, (png_structp png_ptr, png_infop info_ptr)); #endif -/* free any memory associated with the png_info_struct */ -extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, - png_infopp info_ptr_ptr)); - -/* free any memory associated with the png_struct and the png_info_structs */ -extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp - png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); +/* Free any memory associated with the png_info_struct */ +PNG_EXPORT(63, void, png_destroy_info_struct, (png_structp png_ptr, + png_infopp info_ptr_ptr)); -/* free all memory used by the read (old method - NOT DLL EXPORTED) */ -extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, - png_infop end_info_ptr)); +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); -/* free any memory associated with the png_struct and the png_info_structs */ -extern PNG_EXPORT(void,png_destroy_write_struct) - PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); +/* Free any memory associated with the png_struct and the png_info_structs */ +PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, + png_infopp info_ptr_ptr)); -/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ -extern void png_write_destroy PNGARG((png_structp png_ptr)); +/* Set the libpng method of handling chunk CRC errors */ +PNG_EXPORT(66, void, png_set_crc_action, + (png_structp png_ptr, int crit_action, int ancil_action)); -/* set the libpng method of handling chunk CRC errors */ -extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, - int crit_action, int ancil_action)); - -/* Values for png_set_crc_action() to say how to handle CRC errors in +/* Values for png_set_crc_action() say how to handle CRC errors in * ancillary and critical chunks, and whether to use the data contained * therein. Note that it is impossible to "discard" data in a critical * chunk. For versions prior to 0.90, the action was always error/quit, @@ -1762,11 +1569,11 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, * header file (zlib.h) for an explination of the compression functions. */ -/* set the filtering method(s) used by libpng. Currently, the only valid +/* Set the filtering method(s) used by libpng. Currently, the only valid * value for "method" is 0. */ -extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, - int filters)); +PNG_EXPORT(67, void, png_set_filter, + (png_structp png_ptr, int method, int filters)); /* Flags for png_set_filter() to say which filters to use. The flags * are chosen so that they don't conflict with real filter types @@ -1792,7 +1599,7 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, #define PNG_FILTER_VALUE_PAETH 4 #define PNG_FILTER_VALUE_LAST 5 -#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* EXPERIMENTAL */ /* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ * defines, either the default (minimum-sum-of-absolute-differences), or * the experimental method (weighted-minimum-sum-of-absolute-differences). @@ -1821,11 +1628,13 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, * the weights and costs are set to 1.0, this degenerates the WEIGHTED method * to the UNWEIGHTED method, but with added encoding time/computation. */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, - int heuristic_method, int num_weights, png_doublep filter_weights, - png_doublep filter_costs)); -#endif +PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structp png_ptr, + int heuristic_method, int num_weights, png_const_doublep filter_weights, + png_const_doublep filter_costs)); +PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed, + (png_structp png_ptr, + int heuristic_method, int num_weights, png_const_fixed_point_p + filter_weights, png_const_fixed_point_p filter_costs)); #endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ /* Heuristic used for row filter selection. These defines should NOT be @@ -1836,6 +1645,7 @@ extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ #define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ +#ifdef PNG_WRITE_SUPPORTED /* Set the library compression level. Currently, valid values range from * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 * (0 - no compression, 9 - "maximal" compression). Note that tests have @@ -1843,33 +1653,58 @@ extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, * for PNG images, and do considerably fewer caclulations. In the future, * these values may not correspond directly to the zlib compression levels. */ -extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, - int level)); +PNG_EXPORT(69, void, png_set_compression_level, + (png_structp png_ptr, int level)); + +PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structp png_ptr, + int mem_level)); -extern PNG_EXPORT(void,png_set_compression_mem_level) - PNGARG((png_structp png_ptr, int mem_level)); +PNG_EXPORT(71, void, png_set_compression_strategy, (png_structp png_ptr, + int strategy)); -extern PNG_EXPORT(void,png_set_compression_strategy) - PNGARG((png_structp png_ptr, int strategy)); +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structp png_ptr, + int window_bits)); + +PNG_EXPORT(73, void, png_set_compression_method, (png_structp png_ptr, + int method)); +#endif -extern PNG_EXPORT(void,png_set_compression_window_bits) - PNGARG((png_structp png_ptr, int window_bits)); +#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +/* Also set zlib parameters for compressing non-IDAT chunks */ +PNG_EXPORT(222, void, png_set_text_compression_level, + (png_structp png_ptr, int level)); + +PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structp png_ptr, + int mem_level)); + +PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structp png_ptr, + int strategy)); + +/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a + * smaller value of window_bits if it can do so safely. + */ +PNG_EXPORT(225, void, png_set_text_compression_window_bits, (png_structp + png_ptr, int window_bits)); -extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, - int method)); +PNG_EXPORT(226, void, png_set_text_compression_method, (png_structp png_ptr, + int method)); +#endif /* PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED */ /* These next functions are called for input/output, memory, and error * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, * and call standard C I/O routines such as fread(), fwrite(), and * fprintf(). These functions can be made to use other I/O routines * at run time for those applications that need to handle I/O in a - * different manner by calling png_set_???_fn(). See libpng.txt for + * different manner by calling png_set_???_fn(). See libpng-manual.txt for * more information. */ -#if !defined(PNG_NO_STDIO) +#ifdef PNG_STDIO_SUPPORTED /* Initialize the input/output for the PNG file to the default functions. */ -extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +PNG_EXPORT(74, void, png_init_io, (png_structp png_ptr, png_FILE_p fp)); #endif /* Replace the (error and abort), and warning functions with user @@ -1880,128 +1715,155 @@ extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)) * default function will be used. */ -extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, - png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); +PNG_EXPORT(75, void, png_set_error_fn, + (png_structp png_ptr, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warning_fn)); /* Return the user pointer associated with the error functions */ -extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); +PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structp png_ptr)); /* Replace the default data output functions with a user supplied one(s). * If buffered output is not used, then output_flush_fn can be set to NULL. * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time * output_flush_fn will be ignored (and thus can be NULL). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. */ -extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, - png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); +PNG_EXPORT(77, void, png_set_write_fn, (png_structp png_ptr, png_voidp io_ptr, + png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); /* Replace the default data input function with a user supplied one. */ -extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, - png_voidp io_ptr, png_rw_ptr read_data_fn)); +PNG_EXPORT(78, void, png_set_read_fn, (png_structp png_ptr, png_voidp io_ptr, + png_rw_ptr read_data_fn)); /* Return the user pointer associated with the I/O functions */ -extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); +PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_structp png_ptr)); -extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, - png_read_status_ptr read_row_fn)); +PNG_EXPORT(80, void, png_set_read_status_fn, (png_structp png_ptr, + png_read_status_ptr read_row_fn)); -extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, - png_write_status_ptr write_row_fn)); +PNG_EXPORT(81, void, png_set_write_status_fn, (png_structp png_ptr, + png_write_status_ptr write_row_fn)); #ifdef PNG_USER_MEM_SUPPORTED /* Replace the default memory allocation functions with user supplied one(s). */ -extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, - png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +PNG_EXPORT(82, void, png_set_mem_fn, (png_structp png_ptr, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); /* Return the user pointer associated with the memory functions */ -extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structp png_ptr)); #endif -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_LEGACY_SUPPORTED) -extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp - png_ptr, png_user_transform_ptr read_user_transform_fn)); +#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structp png_ptr, + png_user_transform_ptr read_user_transform_fn)); #endif -#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_LEGACY_SUPPORTED) -extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp - png_ptr, png_user_transform_ptr write_user_transform_fn)); +#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structp png_ptr, + png_user_transform_ptr write_user_transform_fn)); #endif -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_LEGACY_SUPPORTED) -extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp - png_ptr, png_voidp user_transform_ptr, int user_transform_depth, - int user_transform_channels)); +#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +PNG_EXPORT(86, void, png_set_user_transform_info, (png_structp png_ptr, + png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); /* Return the user pointer associated with the user transform functions */ -extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) - PNGARG((png_structp png_ptr)); +PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, + (png_const_structp png_ptr)); +#endif + +#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED +/* Return information about the row currently being processed. Note that these + * APIs do not fail but will return unexpected results if called outside a user + * transform callback. Also note that when transforming an interlaced image the + * row number is the row number within the sub-image of the interlace pass, so + * the value will increase to the height of the sub-image (not the full image) + * then reset to 0 for the next pass. + * + * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to + * find the output pixel (x,y) given an interlaced sub-image pixel + * (row,col,pass). (See below for these macros.) + */ +PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structp)); +PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structp)); #endif #ifdef PNG_USER_CHUNKS_SUPPORTED -extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, - png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); -extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp - png_ptr)); +PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structp png_ptr)); #endif #ifdef PNG_PROGRESSIVE_READ_SUPPORTED /* Sets the function callbacks for the push reader, and a pointer to a * user-defined structure available to the callback functions. */ -extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, - png_voidp progressive_ptr, - png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, - png_progressive_end_ptr end_fn)); - -/* returns the user pointer associated with the push read functions */ -extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) - PNGARG((png_structp png_ptr)); +PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structp png_ptr, + png_voidp progressive_ptr, png_progressive_info_ptr info_fn, + png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); + +/* Returns the user pointer associated with the push read functions */ +PNG_EXPORT(91, png_voidp, png_get_progressive_ptr, (png_const_structp png_ptr)); + +/* Function to be called when data becomes available */ +PNG_EXPORT(92, void, png_process_data, + (png_structp png_ptr, png_infop info_ptr, + png_bytep buffer, png_size_t buffer_size)); + +/* A function which may be called *only* within png_process_data to stop the + * processing of any more data. The function returns the number of bytes + * remaining, excluding any that libpng has cached internally. A subsequent + * call to png_process_data must supply these bytes again. If the argument + * 'save' is set to true the routine will first save all the pending data and + * will always return 0. + */ +PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structp, int save)); -/* function to be called when data becomes available */ -extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); +/* A function which may be called *only* outside (after) a call to + * png_process_data. It returns the number of bytes of data to skip in the + * input. Normally it will return 0, but if it returns a non-zero value the + * application must skip than number of bytes of input data and pass the + * following data to the next call to png_process_data. + */ +PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structp)); -/* function that combines rows. Not very much different than the - * png_combine_row() call. Is this even used????? +/* Function that combines rows. 'new_row' is a flag that should come from + * the callback and be non-NULL if anything needs to be done; the library + * stores its own version of the new data internally and ignores the passed + * in value. */ -extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, - png_bytep old_row, png_bytep new_row)); +PNG_EXPORT(93, void, png_progressive_combine_row, (png_structp png_ptr, + png_bytep old_row, png_const_bytep new_row)); #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ -extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, - png_uint_32 size)); +PNG_EXPORTA(94, png_voidp, png_malloc, + (png_structp png_ptr, png_alloc_size_t size), + PNG_ALLOCATED); +/* Added at libpng version 1.4.0 */ +PNG_EXPORTA(95, png_voidp, png_calloc, + (png_structp png_ptr, png_alloc_size_t size), + PNG_ALLOCATED); -#if defined(PNG_1_0_X) -# define png_malloc_warn png_malloc -#else /* Added at libpng version 1.2.4 */ -extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, - png_uint_32 size)); -#endif - -/* frees a pointer allocated by png_malloc() */ -extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); +PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_structp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); -#if defined(PNG_1_0_X) -/* Function to allocate memory for zlib. */ -extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, - uInt size)); - -/* Function to free memory for zlib */ -extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); -#endif +/* Frees a pointer allocated by png_malloc() */ +PNG_EXPORT(97, void, png_free, (png_structp png_ptr, png_voidp ptr)); /* Free data that was allocated internally */ -extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 free_me, int num)); -#ifdef PNG_FREE_ME_SUPPORTED +PNG_EXPORT(98, void, png_free_data, + (png_structp png_ptr, png_infop info_ptr, png_uint_32 free_me, int num)); + /* Reassign responsibility for freeing existing data, whether allocated * by libpng or by the application */ -extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, - png_infop info_ptr, int freer, png_uint_32 mask)); -#endif -/* assignments for png_data_freer */ +PNG_EXPORT(99, void, png_data_freer, + (png_structp png_ptr, png_infop info_ptr, int freer, png_uint_32 mask)); + +/* Assignments for png_data_freer */ #define PNG_DESTROY_WILL_FREE_DATA 1 #define PNG_SET_WILL_FREE_DATA 1 #define PNG_USER_WILL_FREE_DATA 2 @@ -2021,38 +1883,59 @@ extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, #define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ #ifdef PNG_USER_MEM_SUPPORTED -extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, - png_uint_32 size)); -extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, - png_voidp ptr)); +PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_structp png_ptr, + png_alloc_size_t size), PNG_ALLOCATED); +PNG_EXPORT(101, void, png_free_default, (png_structp png_ptr, png_voidp ptr)); #endif -extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, - png_voidp s1, png_voidp s2, png_uint_32 size)); - -extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, - png_voidp s1, int value, png_uint_32 size)); - -#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ -extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, - int check)); -#endif /* USE_FAR_KEYWORD */ - +#ifdef PNG_ERROR_TEXT_SUPPORTED /* Fatal error in PNG image of libpng - can't continue */ -extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, - png_const_charp error_message)); +PNG_EXPORTA(102, void, png_error, + (png_structp png_ptr, png_const_charp error_message), + PNG_NORETURN); /* The same, but the chunk name is prepended to the error string. */ -extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, - png_const_charp error_message)); +PNG_EXPORTA(103, void, png_chunk_error, (png_structp png_ptr, + png_const_charp error_message), PNG_NORETURN); + +#else +/* Fatal error in PNG image of libpng - can't continue */ +PNG_EXPORTA(104, void, png_err, (png_structp png_ptr), PNG_NORETURN); +#endif +#ifdef PNG_WARNINGS_SUPPORTED /* Non-fatal error in libpng. Can continue, but may have a problem. */ -extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, - png_const_charp warning_message)); +PNG_EXPORT(105, void, png_warning, (png_structp png_ptr, + png_const_charp warning_message)); /* Non-fatal error in libpng, chunk name is prepended to message. */ -extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, - png_const_charp warning_message)); +PNG_EXPORT(106, void, png_chunk_warning, (png_structp png_ptr, + png_const_charp warning_message)); +#endif + +#ifdef PNG_BENIGN_ERRORS_SUPPORTED +/* Benign error in libpng. Can continue, but may have a problem. + * User can choose whether to handle as a fatal error or as a warning. */ +# undef png_benign_error +PNG_EXPORT(107, void, png_benign_error, (png_structp png_ptr, + png_const_charp warning_message)); + +/* Same, chunk name is prepended to message. */ +# undef png_chunk_benign_error +PNG_EXPORT(108, void, png_chunk_benign_error, (png_structp png_ptr, + png_const_charp warning_message)); + +PNG_EXPORT(109, void, png_set_benign_errors, + (png_structp png_ptr, int allowed)); +#else +# ifdef PNG_ALLOW_BENIGN_ERRORS +# define png_benign_error png_warning +# define png_chunk_benign_error png_chunk_warning +# else +# define png_benign_error png_error +# define png_chunk_benign_error png_chunk_error +# endif +#endif /* The png_set_ functions are for storing values in the png_info_struct. * Similarly, the png_get_ calls are used to read values from the @@ -2067,425 +1950,410 @@ extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, * png_info_struct. */ /* Returns "flag" if chunk data is valid in info_ptr. */ -extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, -png_infop info_ptr, png_uint_32 flag)); +PNG_EXPORT(110, png_uint_32, png_get_valid, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_32 flag)); /* Returns number of bytes needed to hold a transformed row. */ -extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, -png_infop info_ptr)); +PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structp png_ptr, + png_const_infop info_ptr)); -#if defined(PNG_INFO_IMAGE_SUPPORTED) +#ifdef PNG_INFO_IMAGE_SUPPORTED /* Returns row_pointers, which is an array of pointers to scanlines that was -returned from png_read_png(). */ -extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, -png_infop info_ptr)); + * returned from png_read_png(). + */ +PNG_EXPORT(112, png_bytepp, png_get_rows, + (png_const_structp png_ptr, png_const_infop info_ptr)); /* Set row_pointers, which is an array of pointers to scanlines for use -by png_write_png(). */ -extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_bytepp row_pointers)); + * by png_write_png(). + */ +PNG_EXPORT(113, void, png_set_rows, (png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); #endif /* Returns number of color channels in image. */ -extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, -png_infop info_ptr)); +PNG_EXPORT(114, png_byte, png_get_channels, + (png_const_structp png_ptr, png_const_infop info_ptr)); #ifdef PNG_EASY_ACCESS_SUPPORTED /* Returns image width in pixels. */ -extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image height in pixels. */ -extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image bit_depth. */ -extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(117, png_byte, png_get_bit_depth, + (png_const_structp png_ptr, png_const_infop info_ptr)); /* Returns image color_type. */ -extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image filter_type. */ -extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image interlace_type. */ -extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image compression_type. */ -extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structp png_ptr, + png_const_infop info_ptr)); /* Returns image resolution in pixels per meter, from pHYs chunk data. */ -extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, + (png_const_structp png_ptr, png_const_infop info_ptr)); /* Returns pixel aspect ratio, computed from pHYs chunk data. */ -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -#endif +PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed, + (png_const_structp png_ptr, png_const_infop info_ptr)); /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ -extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp -png_ptr, png_infop info_ptr)); -extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp -png_ptr, png_infop info_ptr)); +PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, + (png_const_structp png_ptr, png_const_infop info_ptr)); +PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, + (png_const_structp png_ptr, png_const_infop info_ptr)); #endif /* PNG_EASY_ACCESS_SUPPORTED */ /* Returns pointer to signature string read from PNG header */ -extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, -png_infop info_ptr)); +PNG_EXPORT(130, png_const_bytep, png_get_signature, + (png_const_structp png_ptr, png_infop info_ptr)); -#if defined(PNG_bKGD_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_color_16p *background)); +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(131, png_uint_32, png_get_bKGD, + (png_const_structp png_ptr, png_infop info_ptr, + png_color_16p *background)); #endif -#if defined(PNG_bKGD_SUPPORTED) -extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_color_16p background)); +#ifdef PNG_bKGD_SUPPORTED +PNG_EXPORT(132, void, png_set_bKGD, (png_structp png_ptr, png_infop info_ptr, + png_const_color_16p background)); #endif -#if defined(PNG_cHRM_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, - png_infop info_ptr, double *white_x, double *white_y, double *red_x, - double *red_y, double *green_x, double *green_y, double *blue_x, - double *blue_y)); -#endif -#ifdef PNG_FIXED_POINT_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point - *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, - png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point - *int_blue_x, png_fixed_point *int_blue_y)); -#endif +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structp png_ptr, + png_const_infop info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)); +PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_structp png_ptr, + png_const_infop info_ptr, double *red_X, double *red_Y, double *red_Z, + double *green_X, double *green_Y, double *green_Z, double *blue_X, + double *blue_Y, double *blue_Z)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* Otherwise not implemented */ +PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed, + (png_const_structp png_ptr, + png_const_infop info_ptr, png_fixed_point *int_white_x, + png_fixed_point *int_white_y, png_fixed_point *int_red_x, + png_fixed_point *int_red_y, png_fixed_point *int_green_x, + png_fixed_point *int_green_y, png_fixed_point *int_blue_x, + png_fixed_point *int_blue_y)); +#endif +PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed, + (png_structp png_ptr, png_const_infop info_ptr, + png_fixed_point *int_red_X, png_fixed_point *int_red_Y, + png_fixed_point *int_red_Z, png_fixed_point *int_green_X, + png_fixed_point *int_green_Y, png_fixed_point *int_green_Z, + png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y, + png_fixed_point *int_blue_Z)); #endif -#if defined(PNG_cHRM_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, - png_infop info_ptr, double white_x, double white_y, double red_x, - double red_y, double green_x, double green_y, double blue_x, double blue_y)); -#endif -#ifdef PNG_FIXED_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, - png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point - int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, - png_fixed_point int_blue_y)); -#endif +#ifdef PNG_cHRM_SUPPORTED +PNG_FP_EXPORT(135, void, png_set_cHRM, + (png_structp png_ptr, png_infop info_ptr, + double white_x, double white_y, double red_x, double red_y, double green_x, + double green_y, double blue_x, double blue_y)); +PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_structp png_ptr, + png_infop info_ptr, double red_X, double red_Y, double red_Z, + double green_X, double green_Y, double green_Z, double blue_X, + double blue_Y, double blue_Z)); +PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_white_x, + png_fixed_point int_white_y, png_fixed_point int_red_x, + png_fixed_point int_red_y, png_fixed_point int_green_x, + png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, + png_fixed_point int_red_Z, png_fixed_point int_green_X, + png_fixed_point int_green_Y, png_fixed_point int_green_Z, + png_fixed_point int_blue_X, png_fixed_point int_blue_Y, + png_fixed_point int_blue_Z)); #endif -#if defined(PNG_gAMA_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, - png_infop info_ptr, double *file_gamma)); -#endif -extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_fixed_point *int_file_gamma)); +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, + (png_const_structp png_ptr, png_const_infop info_ptr, + double *file_gamma)); +PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_fixed_point *int_file_gamma)); #endif -#if defined(PNG_gAMA_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, - png_infop info_ptr, double file_gamma)); -#endif -extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_fixed_point int_file_gamma)); +#ifdef PNG_gAMA_SUPPORTED +PNG_FP_EXPORT(139, void, png_set_gAMA, (png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); #endif -#if defined(PNG_hIST_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_16p *hist)); +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(141, png_uint_32, png_get_hIST, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_16p *hist)); #endif -#if defined(PNG_hIST_SUPPORTED) -extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_16p hist)); +#ifdef PNG_hIST_SUPPORTED +PNG_EXPORT(142, void, png_set_hIST, (png_structp png_ptr, + png_infop info_ptr, png_const_uint_16p hist)); #endif -extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, - int *bit_depth, int *color_type, int *interlace_method, - int *compression_method, int *filter_method)); +PNG_EXPORT(143, png_uint_32, png_get_IHDR, + (png_structp png_ptr, png_infop info_ptr, + png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, + int *interlace_method, int *compression_method, int *filter_method)); -extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, - int color_type, int interlace_method, int compression_method, - int filter_method)); +PNG_EXPORT(144, void, png_set_IHDR, + (png_structp png_ptr, png_infop info_ptr, + png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, + int interlace_method, int compression_method, int filter_method)); -#if defined(PNG_oFFs_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, - int *unit_type)); +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(145, png_uint_32, png_get_oFFs, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type)); #endif -#if defined(PNG_oFFs_SUPPORTED) -extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, - int unit_type)); +#ifdef PNG_oFFs_SUPPORTED +PNG_EXPORT(146, void, png_set_oFFs, + (png_structp png_ptr, png_infop info_ptr, + png_int_32 offset_x, png_int_32 offset_y, int unit_type)); #endif -#if defined(PNG_pCAL_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, - int *type, int *nparams, png_charp *units, png_charpp *params)); +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(147, png_uint_32, png_get_pCAL, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, + int *nparams, + png_charp *units, png_charpp *params)); #endif -#if defined(PNG_pCAL_SUPPORTED) -extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, - int type, int nparams, png_charp units, png_charpp params)); +#ifdef PNG_pCAL_SUPPORTED +PNG_EXPORT(148, void, png_set_pCAL, (png_structp png_ptr, + png_infop info_ptr, + png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, + int nparams, png_const_charp units, png_charpp params)); #endif -#if defined(PNG_pHYs_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(149, png_uint_32, png_get_pHYs, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); #endif -#if defined(PNG_pHYs_SUPPORTED) -extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(150, void, png_set_pHYs, + (png_structp png_ptr, png_infop info_ptr, + png_uint_32 res_x, png_uint_32 res_y, int unit_type)); #endif -extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_colorp *palette, int *num_palette)); +PNG_EXPORT(151, png_uint_32, png_get_PLTE, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_colorp *palette, int *num_palette)); -extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_colorp palette, int num_palette)); +PNG_EXPORT(152, void, png_set_PLTE, + (png_structp png_ptr, png_infop info_ptr, + png_const_colorp palette, int num_palette)); -#if defined(PNG_sBIT_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_color_8p *sig_bit)); +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(153, png_uint_32, png_get_sBIT, + (png_const_structp png_ptr, png_infop info_ptr, + png_color_8p *sig_bit)); #endif -#if defined(PNG_sBIT_SUPPORTED) -extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_color_8p sig_bit)); +#ifdef PNG_sBIT_SUPPORTED +PNG_EXPORT(154, void, png_set_sBIT, + (png_structp png_ptr, png_infop info_ptr, png_const_color_8p sig_bit)); #endif -#if defined(PNG_sRGB_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, - png_infop info_ptr, int *intent)); +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structp png_ptr, + png_const_infop info_ptr, int *file_srgb_intent)); #endif -#if defined(PNG_sRGB_SUPPORTED) -extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, - png_infop info_ptr, int intent)); -extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, - png_infop info_ptr, int intent)); +#ifdef PNG_sRGB_SUPPORTED +PNG_EXPORT(156, void, png_set_sRGB, + (png_structp png_ptr, png_infop info_ptr, int srgb_intent)); +PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_structp png_ptr, + png_infop info_ptr, int srgb_intent)); #endif -#if defined(PNG_iCCP_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_charpp name, int *compression_type, - png_charpp profile, png_uint_32 *proflen)); - /* Note to maintainer: profile should be png_bytepp */ +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(158, png_uint_32, png_get_iCCP, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_charpp name, int *compression_type, png_bytepp profile, + png_uint_32 *proflen)); #endif -#if defined(PNG_iCCP_SUPPORTED) -extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_charp name, int compression_type, - png_charp profile, png_uint_32 proflen)); - /* Note to maintainer: profile should be png_bytep */ +#ifdef PNG_iCCP_SUPPORTED +PNG_EXPORT(159, void, png_set_iCCP, + (png_structp png_ptr, png_infop info_ptr, + png_const_charp name, int compression_type, png_const_bytep profile, + png_uint_32 proflen)); #endif -#if defined(PNG_sPLT_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_sPLT_tpp entries)); +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(160, png_uint_32, png_get_sPLT, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_sPLT_tpp entries)); #endif -#if defined(PNG_sPLT_SUPPORTED) -extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_sPLT_tp entries, int nentries)); +#ifdef PNG_sPLT_SUPPORTED +PNG_EXPORT(161, void, png_set_sPLT, + (png_structp png_ptr, png_infop info_ptr, + png_const_sPLT_tp entries, int nentries)); #endif -#if defined(PNG_TEXT_SUPPORTED) +#ifdef PNG_TEXT_SUPPORTED /* png_get_text also returns the number of text chunks in *num_text */ -extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_textp *text_ptr, int *num_text)); +PNG_EXPORT(162, png_uint_32, png_get_text, + (png_const_structp png_ptr, png_const_infop info_ptr, + png_textp *text_ptr, int *num_text)); #endif -/* - * Note while png_set_text() will accept a structure whose text, - * language, and translated keywords are NULL pointers, the structure - * returned by png_get_text will always contain regular - * zero-terminated C strings. They might be empty strings but - * they will never be NULL pointers. +/* Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. */ -#if defined(PNG_TEXT_SUPPORTED) -extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_textp text_ptr, int num_text)); -#endif - -#if defined(PNG_tIME_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_timep *mod_time)); +#ifdef PNG_TEXT_SUPPORTED +PNG_EXPORT(163, void, png_set_text, + (png_structp png_ptr, png_infop info_ptr, + png_const_textp text_ptr, int num_text)); #endif -#if defined(PNG_tIME_SUPPORTED) -extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_timep mod_time)); +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(164, png_uint_32, png_get_tIME, + (png_const_structp png_ptr, png_infop info_ptr, png_timep *mod_time)); #endif -#if defined(PNG_tRNS_SUPPORTED) -extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_bytep *trans, int *num_trans, - png_color_16p *trans_values)); +#ifdef PNG_tIME_SUPPORTED +PNG_EXPORT(165, void, png_set_tIME, + (png_structp png_ptr, png_infop info_ptr, png_const_timep mod_time)); #endif -#if defined(PNG_tRNS_SUPPORTED) -extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_bytep trans, int num_trans, - png_color_16p trans_values)); +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(166, png_uint_32, png_get_tRNS, + (png_const_structp png_ptr, png_infop info_ptr, + png_bytep *trans_alpha, int *num_trans, png_color_16p *trans_color)); #endif -#if defined(PNG_tRNS_SUPPORTED) +#ifdef PNG_tRNS_SUPPORTED +PNG_EXPORT(167, void, png_set_tRNS, + (png_structp png_ptr, png_infop info_ptr, + png_const_bytep trans_alpha, int num_trans, + png_const_color_16p trans_color)); #endif -#if defined(PNG_sCAL_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, - png_infop info_ptr, int *unit, double *width, double *height)); -#else -#ifdef PNG_FIXED_POINT_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, - png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); -#endif -#endif +#ifdef PNG_sCAL_SUPPORTED +PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, + (png_const_structp png_ptr, png_const_infop info_ptr, + int *unit, double *width, double *height)); +#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED +/* NOTE: this API is currently implemented using floating point arithmetic, + * consequently it can only be used on systems with floating point support. + * In any case the range of values supported by png_fixed_point is small and it + * is highly recommended that png_get_sCAL_s be used instead. + */ +PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed, + (png_structp png_ptr, png_const_infop info_ptr, int *unit, + png_fixed_point *width, + png_fixed_point *height)); +#endif +PNG_EXPORT(169, png_uint_32, png_get_sCAL_s, + (png_const_structp png_ptr, png_const_infop info_ptr, + int *unit, png_charpp swidth, png_charpp sheight)); + +PNG_FP_EXPORT(170, void, png_set_sCAL, + (png_structp png_ptr, png_infop info_ptr, + int unit, double width, double height)); +PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_structp png_ptr, + png_infop info_ptr, int unit, png_fixed_point width, + png_fixed_point height)); +PNG_EXPORT(171, void, png_set_sCAL_s, + (png_structp png_ptr, png_infop info_ptr, + int unit, png_const_charp swidth, png_const_charp sheight)); #endif /* PNG_sCAL_SUPPORTED */ -#if defined(PNG_sCAL_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, - png_infop info_ptr, int unit, double width, double height)); -#else -#ifdef PNG_FIXED_POINT_SUPPORTED -extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, - png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); -#endif -#endif -#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ - -#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) -/* provide a list of chunks and how they are to be handled, if the built-in +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +/* Provide a list of chunks and how they are to be handled, if the built-in handling or default unknown chunk handling is not desired. Any chunks not listed will be handled in the default manner. The IHDR and IEND chunks must not be listed. - keep = 0: follow default behavour + keep = 0: follow default behavior = 1: do not keep = 2: keep only if safe-to-copy = 3: keep even if unsafe-to-copy */ -extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp - png_ptr, int keep, png_bytep chunk_list, int num_chunks)); -extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, - png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); -extern PNG_EXPORT(void, png_set_unknown_chunk_location) - PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); -extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp - png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); -#endif -#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep - chunk_name)); +PNG_EXPORT(172, void, png_set_keep_unknown_chunks, + (png_structp png_ptr, int keep, + png_const_bytep chunk_list, int num_chunks)); +PNG_EXPORT(173, int, png_handle_as_unknown, (png_structp png_ptr, + png_const_bytep chunk_name)); +#endif +#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structp png_ptr, + png_infop info_ptr, png_const_unknown_chunkp unknowns, + int num_unknowns)); +PNG_EXPORT(175, void, png_set_unknown_chunk_location, + (png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structp png_ptr, + png_const_infop info_ptr, png_unknown_chunkpp entries)); #endif /* Png_free_data() will turn off the "valid" flag for anything it frees. - If you need to turn it off for a chunk that your application has freed, - you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ -extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, - png_infop info_ptr, int mask)); + * If you need to turn it off for a chunk that your application has freed, + * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); + */ +PNG_EXPORT(177, void, png_set_invalid, + (png_structp png_ptr, png_infop info_ptr, int mask)); -#if defined(PNG_INFO_IMAGE_SUPPORTED) +#ifdef PNG_INFO_IMAGE_SUPPORTED /* The "params" pointer is currently not used and is for future expansion. */ -extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, - png_infop info_ptr, - int transforms, - png_voidp params)); -extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, - png_infop info_ptr, - int transforms, - png_voidp params)); -#endif - -/* Define PNG_DEBUG at compile time for debugging information. Higher - * numbers for PNG_DEBUG mean more debugging information. This has - * only been added since version 0.95 so it is not implemented throughout - * libpng yet, but more support will be added as needed. - */ -#ifdef PNG_DEBUG -#if (PNG_DEBUG > 0) -#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) -#include -#if (PNG_DEBUG > 1) -#define png_debug(l,m) _RPT0(_CRT_WARN,m) -#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m,p1) -#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m,p1,p2) -#endif -#else /* PNG_DEBUG_FILE || !_MSC_VER */ -#ifndef PNG_DEBUG_FILE -#define PNG_DEBUG_FILE stderr -#endif /* PNG_DEBUG_FILE */ -#if (PNG_DEBUG > 1) -#define png_debug(l,m) \ -{ \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ -} -#define png_debug1(l,m,p1) \ -{ \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ -} -#define png_debug2(l,m,p1,p2) \ -{ \ - int num_tabs=l; \ - fprintf(PNG_DEBUG_FILE,"%s"m,(num_tabs==1 ? "\t" : \ - (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ -} -#endif /* (PNG_DEBUG > 1) */ -#endif /* _MSC_VER */ -#endif /* (PNG_DEBUG > 0) */ -#endif /* PNG_DEBUG */ -#ifndef png_debug -#define png_debug(l, m) -#endif -#ifndef png_debug1 -#define png_debug1(l, m, p1) -#endif -#ifndef png_debug2 -#define png_debug2(l, m, p1, p2) +PNG_EXPORT(178, void, png_read_png, (png_structp png_ptr, png_infop info_ptr, + int transforms, png_voidp params)); +PNG_EXPORT(179, void, png_write_png, (png_structp png_ptr, png_infop info_ptr, + int transforms, png_voidp params)); #endif -#if 0 -extern PNG_EXPORT(png_bytep,png_sig_bytes) PNGARG((void)); -#endif - -extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); -extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); -extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); -extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); +PNG_EXPORT(180, png_const_charp, png_get_copyright, + (png_const_structp png_ptr)); +PNG_EXPORT(181, png_const_charp, png_get_header_ver, + (png_const_structp png_ptr)); +PNG_EXPORT(182, png_const_charp, png_get_header_version, + (png_const_structp png_ptr)); +PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, + (png_const_structp png_ptr)); #ifdef PNG_MNG_FEATURES_SUPPORTED -extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp - png_ptr, png_uint_32 mng_features_permitted)); +PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structp png_ptr, + png_uint_32 mng_features_permitted)); #endif /* For use in png_set_keep_unknown, added to version 1.2.6 */ @@ -2494,93 +2362,140 @@ extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp #define PNG_HANDLE_CHUNK_IF_SAFE 2 #define PNG_HANDLE_CHUNK_ALWAYS 3 -/* Added to version 1.2.0 */ -#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -#if defined(PNG_MMX_CODE_SUPPORTED) -#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ -#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ -#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 -#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 -#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 -#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 -#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 -#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 -#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ - -#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ - | PNG_ASM_FLAG_MMX_READ_INTERLACE \ - | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ - | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ - | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ - | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) -#define PNG_MMX_WRITE_FLAGS ( 0 ) - -#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ - | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ - | PNG_MMX_READ_FLAGS \ - | PNG_MMX_WRITE_FLAGS ) - -#define PNG_SELECT_READ 1 -#define PNG_SELECT_WRITE 2 -#endif /* PNG_MMX_CODE_SUPPORTED */ - -#if !defined(PNG_1_0_X) -/* pngget.c */ -extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) - PNGARG((int flag_select, int *compilerID)); - -/* pngget.c */ -extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) - PNGARG((int flag_select)); - -/* pngget.c */ -extern PNG_EXPORT(png_uint_32,png_get_asm_flags) - PNGARG((png_structp png_ptr)); - -/* pngget.c */ -extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) - PNGARG((png_structp png_ptr)); - -/* pngget.c */ -extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) - PNGARG((png_structp png_ptr)); - -/* pngset.c */ -extern PNG_EXPORT(void,png_set_asm_flags) - PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); - -/* pngset.c */ -extern PNG_EXPORT(void,png_set_mmx_thresholds) - PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, - png_uint_32 mmx_rowbytes_threshold)); - -#endif /* PNG_1_0_X */ - -#if !defined(PNG_1_0_X) -/* png.c, pnggccrd.c, or pngvcrd.c */ -extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); -#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ - /* Strip the prepended error numbers ("#nnn ") from error and warning - * messages before passing them to the error or warning handler. */ + * messages before passing them to the error or warning handler. + */ #ifdef PNG_ERROR_NUMBERS_SUPPORTED -extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp - png_ptr, png_uint_32 strip_mode)); +PNG_EXPORT(185, void, png_set_strip_error_numbers, + (png_structp png_ptr, + png_uint_32 strip_mode)); #endif -#endif /* PNG_1_0_X */ - -/* Added at libpng-1.2.6 */ +/* Added in libpng-1.2.6 */ #ifdef PNG_SET_USER_LIMITS_SUPPORTED -extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp - png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); -extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp - png_ptr)); -extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp - png_ptr)); -#endif +PNG_EXPORT(186, void, png_set_user_limits, (png_structp png_ptr, + png_uint_32 user_width_max, png_uint_32 user_height_max)); +PNG_EXPORT(187, png_uint_32, png_get_user_width_max, + (png_const_structp png_ptr)); +PNG_EXPORT(188, png_uint_32, png_get_user_height_max, + (png_const_structp png_ptr)); +/* Added in libpng-1.4.0 */ +PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structp png_ptr, + png_uint_32 user_chunk_cache_max)); +PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max, + (png_const_structp png_ptr)); +/* Added in libpng-1.4.1 */ +PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structp png_ptr, + png_alloc_size_t user_chunk_cache_max)); +PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max, + (png_const_structp png_ptr)); +#endif + +#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) +PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, + (png_const_structp png_ptr, png_const_infop info_ptr)); + +PNG_FP_EXPORT(196, float, png_get_x_offset_inches, + (png_const_structp png_ptr, png_const_infop info_ptr)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed, + (png_structp png_ptr, png_const_infop info_ptr)); +#endif + +PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structp png_ptr, + png_const_infop info_ptr)); +#ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */ +PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed, + (png_structp png_ptr, png_const_infop info_ptr)); +#endif + +# ifdef PNG_pHYs_SUPPORTED +PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structp png_ptr, + png_const_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, + int *unit_type)); +# endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS_SUPPORTED */ + +/* Added in libpng-1.4.0 */ +#ifdef PNG_IO_STATE_SUPPORTED +PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_structp png_ptr)); + +PNG_EXPORTA(200, png_const_bytep, png_get_io_chunk_name, + (png_structp png_ptr), PNG_DEPRECATED); +PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type, + (png_const_structp png_ptr)); + +/* The flags returned by png_get_io_state() are the following: */ +# define PNG_IO_NONE 0x0000 /* no I/O at this moment */ +# define PNG_IO_READING 0x0001 /* currently reading */ +# define PNG_IO_WRITING 0x0002 /* currently writing */ +# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ +# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ +# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ +# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ +# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ +# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ +#endif /* ?PNG_IO_STATE_SUPPORTED */ + +/* Interlace support. The following macros are always defined so that if + * libpng interlace handling is turned off the macros may be used to handle + * interlaced images within the application. + */ +#define PNG_INTERLACE_ADAM7_PASSES 7 -/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ +/* Two macros to return the first row and first column of the original, + * full, image which appears in a given pass. 'pass' is in the range 0 + * to 6 and the result is in the range 0 to 7. + */ +#define PNG_PASS_START_ROW(pass) (((1U&~(pass))<<(3-((pass)>>1)))&7) +#define PNG_PASS_START_COL(pass) (((1U& (pass))<<(3-(((pass)+1)>>1)))&7) + +/* Two macros to help evaluate the number of rows or columns in each + * pass. This is expressed as a shift - effectively log2 of the number or + * rows or columns in each 8x8 tile of the original image. + */ +#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) +#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) + +/* Hence two macros to determine the number of rows or columns in a given + * pass of an image given its height or width. In fact these macros may + * return non-zero even though the sub-image is empty, because the other + * dimension may be empty for a small image. + */ +#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) +#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) + +/* For the reader row callbacks (both progressive and sequential) it is + * necessary to find the row in the output image given a row in an interlaced + * image, so two more macros: + */ +#define PNG_ROW_FROM_PASS_ROW(yIn, pass) \ + (((yIn)<>(((7-(off))-(pass))<<2)) & 0xFU) | \ + ((0x01145AF0U>>(((7-(off))-(pass))<<2)) & 0xF0U)) + +#define PNG_ROW_IN_INTERLACE_PASS(y, pass) \ + ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1) +#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ + ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED /* With these routines we avoid an integer divide, which will be slower on @@ -2595,908 +2510,103 @@ extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] */ - /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ -# define png_composite(composite, fg, alpha, bg) \ - { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ - + (png_uint_16)(bg)*(png_uint_16)(255 - \ - (png_uint_16)(alpha)) + (png_uint_16)128); \ +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ + * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 \ + - (png_uint_16)(alpha)) + 128); \ (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } -# define png_composite_16(composite, fg, alpha, bg) \ - { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ - + (png_uint_32)(bg)*(png_uint_32)(65535L - \ - (png_uint_32)(alpha)) + (png_uint_32)32768L); \ +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ + * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(65535 \ + - (png_uint_32)(alpha)) + 32768); \ (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } -#else /* standard method using integer division */ +#else /* Standard method using integer division */ -# define png_composite(composite, fg, alpha, bg) \ - (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ - (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ - (png_uint_16)127) / 255) +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + 127) / 255) # define png_composite_16(composite, fg, alpha, bg) \ (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ - (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ - (png_uint_32)32767) / (png_uint_32)65535L) - + (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ + 32767) / 65535) #endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ -/* Inline macros to do direct reads of bytes from the input buffer. These - * require that you are using an architecture that uses PNG byte ordering - * (MSB first) and supports unaligned data storage. I think that PowerPC - * in big-endian mode and 680x0 are the only ones that will support this. - * The x86 line of processors definitely do not. The png_get_int_32() - * routine also assumes we are using two's complement format for negative - * values, which is almost certainly true. - */ -#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) -# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) -# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) -# define png_get_int_32(buf) ( *((png_int_32p) (buf))) -#else -extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); -extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); -extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); -#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ -extern PNG_EXPORT(png_uint_32,png_get_uint_31) - PNGARG((png_structp png_ptr, png_bytep buf)); +#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); +PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); +PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); +#endif + +PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_structp png_ptr, + png_const_bytep buf)); /* No png_get_int_16 -- may be added if there's a real need for it. */ -/* Place a 32-bit number into a buffer in PNG byte order (big-endian). - */ -extern PNG_EXPORT(void,png_save_uint_32) - PNGARG((png_bytep buf, png_uint_32 i)); -extern PNG_EXPORT(void,png_save_int_32) - PNGARG((png_bytep buf, png_int_32 i)); +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); +#endif +#ifdef PNG_SAVE_INT_32_SUPPORTED +PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); +#endif /* Place a 16-bit number into a buffer in PNG byte order. * The parameter is declared unsigned int, not png_uint_16, * just to avoid potential problems on pre-ANSI C compilers. */ -extern PNG_EXPORT(void,png_save_uint_16) - PNGARG((png_bytep buf, unsigned int i)); +#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED +PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); /* No png_save_int_16 -- may be added if there's a real need for it. */ - -/* ************************************************************************* */ - -/* These next functions are used internally in the code. They generally - * shouldn't be used unless you are writing code to add or replace some - * functionality in libpng. More information about most functions can - * be found in the files where the functions are located. - */ - -#if defined(PNG_INTERNAL) - -/* Various modes of operation. Note that after an init, mode is set to - * zero automatically when the structure is created. - */ -#define PNG_HAVE_IHDR 0x01 -#define PNG_HAVE_PLTE 0x02 -#define PNG_HAVE_IDAT 0x04 -#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ -#define PNG_HAVE_IEND 0x10 -#define PNG_HAVE_gAMA 0x20 -#define PNG_HAVE_cHRM 0x40 -#define PNG_HAVE_sRGB 0x80 -#define PNG_HAVE_CHUNK_HEADER 0x100 -#define PNG_WROTE_tIME 0x200 -#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 -#define PNG_BACKGROUND_IS_GRAY 0x800 -#define PNG_HAVE_PNG_SIGNATURE 0x1000 -#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ - -/* flags for the transformations the PNG library does on the image data */ -#define PNG_BGR 0x0001 -#define PNG_INTERLACE 0x0002 -#define PNG_PACK 0x0004 -#define PNG_SHIFT 0x0008 -#define PNG_SWAP_BYTES 0x0010 -#define PNG_INVERT_MONO 0x0020 -#define PNG_DITHER 0x0040 -#define PNG_BACKGROUND 0x0080 -#define PNG_BACKGROUND_EXPAND 0x0100 - /* 0x0200 unused */ -#define PNG_16_TO_8 0x0400 -#define PNG_RGBA 0x0800 -#define PNG_EXPAND 0x1000 -#define PNG_GAMMA 0x2000 -#define PNG_GRAY_TO_RGB 0x4000 -#define PNG_FILLER 0x8000L -#define PNG_PACKSWAP 0x10000L -#define PNG_SWAP_ALPHA 0x20000L -#define PNG_STRIP_ALPHA 0x40000L -#define PNG_INVERT_ALPHA 0x80000L -#define PNG_USER_TRANSFORM 0x100000L -#define PNG_RGB_TO_GRAY_ERR 0x200000L -#define PNG_RGB_TO_GRAY_WARN 0x400000L -#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ - /* 0x800000L Unused */ -#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ -#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ - /* 0x4000000L unused */ - /* 0x8000000L unused */ - /* 0x10000000L unused */ - /* 0x20000000L unused */ - /* 0x40000000L unused */ - -/* flags for png_create_struct */ -#define PNG_STRUCT_PNG 0x0001 -#define PNG_STRUCT_INFO 0x0002 - -/* Scaling factor for filter heuristic weighting calculations */ -#define PNG_WEIGHT_SHIFT 8 -#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) -#define PNG_COST_SHIFT 3 -#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) - -/* flags for the png_ptr->flags rather than declaring a byte for each one */ -#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 -#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 -#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 -#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 -#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 -#define PNG_FLAG_ZLIB_FINISHED 0x0020 -#define PNG_FLAG_ROW_INIT 0x0040 -#define PNG_FLAG_FILLER_AFTER 0x0080 -#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 -#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 -#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 -#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 -#define PNG_FLAG_FREE_PLTE 0x1000 -#define PNG_FLAG_FREE_TRNS 0x2000 -#define PNG_FLAG_FREE_HIST 0x4000 -#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L -#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L -#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L -#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L -#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L -#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L -#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ -#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ - /* 0x800000L unused */ - /* 0x1000000L unused */ - /* 0x2000000L unused */ - /* 0x4000000L unused */ - /* 0x8000000L unused */ - /* 0x10000000L unused */ - /* 0x20000000L unused */ - /* 0x40000000L unused */ - -#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ - PNG_FLAG_CRC_ANCILLARY_NOWARN) - -#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ - PNG_FLAG_CRC_CRITICAL_IGNORE) - -#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ - PNG_FLAG_CRC_CRITICAL_MASK) - -/* save typing and make code easier to understand */ - -#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ - abs((int)((c1).green) - (int)((c2).green)) + \ - abs((int)((c1).blue) - (int)((c2).blue))) - -/* Added to libpng-1.2.6 JB */ -#define PNG_ROWBYTES(pixel_bits, width) \ - ((pixel_bits) >= 8 ? \ - ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ - (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) - -/* PNG_OUT_OF_RANGE returns true if value is outside the range - ideal-delta..ideal+delta. Each argument is evaluated twice. - "ideal" and "delta" should be constants, normally simple - integers, "value" a variable. Added to libpng-1.2.6 JB */ -#define PNG_OUT_OF_RANGE(value, ideal, delta) \ - ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) - -/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ -#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) -/* place to hold the signature string for a PNG file. */ -#ifdef PNG_USE_GLOBAL_ARRAYS - PNG_EXPORT_VAR (const png_byte FARDATA) png_sig[8]; -#else -#if 0 -#define png_sig png_sig_bytes(NULL) -#endif -#endif -#endif /* PNG_NO_EXTERN */ - -/* Constant strings for known chunk types. If you need to add a chunk, - * define the name here, and add an invocation of the macro in png.c and - * wherever it's needed. - */ -#define PNG_IHDR const png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} -#define PNG_IDAT const png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} -#define PNG_IEND const png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} -#define PNG_PLTE const png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} -#define PNG_bKGD const png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} -#define PNG_cHRM const png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} -#define PNG_gAMA const png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} -#define PNG_hIST const png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} -#define PNG_iCCP const png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} -#define PNG_iTXt const png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} -#define PNG_oFFs const png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} -#define PNG_pCAL const png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} -#define PNG_sCAL const png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} -#define PNG_pHYs const png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} -#define PNG_sBIT const png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} -#define PNG_sPLT const png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} -#define PNG_sRGB const png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} -#define PNG_tEXt const png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} -#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} -#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} -#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} - -#ifdef PNG_USE_GLOBAL_ARRAYS -PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_IDAT[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_IEND[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_PLTE[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_bKGD[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_cHRM[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_gAMA[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_hIST[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_iCCP[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_iTXt[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_oFFs[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_pCAL[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_sCAL[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_pHYs[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_sBIT[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_sPLT[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_sRGB[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5]; -PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5]; -#endif /* PNG_USE_GLOBAL_ARRAYS */ - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Initialize png_ptr struct for reading, and allocate any other memory. - * (old interface - DEPRECATED - use png_create_read_struct instead). - */ -extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); -#undef png_read_init -#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ - PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); -#endif - -extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, - png_const_charp user_png_ver, png_size_t png_struct_size)); -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, - png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t - png_info_size)); -#endif - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Initialize png_ptr struct for writing, and allocate any other memory. - * (old interface - DEPRECATED - use png_create_write_struct instead). - */ -extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); -#undef png_write_init -#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ - PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); -#endif - -extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, - png_const_charp user_png_ver, png_size_t png_struct_size)); -extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, - png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t - png_info_size)); - -/* Allocate memory for an internal libpng struct */ -PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); - -/* Free memory from internal libpng struct */ -PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); - -PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr - malloc_fn, png_voidp mem_ptr)); -PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, - png_free_ptr free_fn, png_voidp mem_ptr)); - -/* Free any memory that info_ptr points to and reset struct. */ -PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, - png_infop info_ptr)); - -#ifndef PNG_1_0_X -/* Function to allocate memory for zlib. */ -PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); - -/* Function to free memory for zlib */ -PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); - -#ifdef PNG_SIZE_T -/* Function to convert a sizeof an item to png_sizeof item */ - PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); -#endif - -/* Next four functions are used internally as callbacks. PNGAPI is required - * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ - -PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, - png_bytep data, png_size_t length)); - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t length)); #endif -PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, - png_bytep data, png_size_t length)); - -#if defined(PNG_WRITE_FLUSH_SUPPORTED) -#if !defined(PNG_NO_STDIO) -PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); -#endif -#endif -#else /* PNG_1_0_X */ -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t length)); -#endif -#endif /* PNG_1_0_X */ - -/* Reset the CRC variable */ -PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); - -/* Write the "data" buffer to whatever output you are using. */ -PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, - png_size_t length)); - -/* Read data from whatever input you are using into the "data" buffer */ -PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, - png_size_t length)); - -/* Read bytes into buf, and update png_ptr->crc */ -PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, - png_size_t length)); - -/* Decompress data in a chunk that uses compression */ -#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ - defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) -PNG_EXTERN png_charp png_decompress_chunk PNGARG((png_structp png_ptr, - int comp_type, png_charp chunkdata, png_size_t chunklength, - png_size_t prefix_length, png_size_t *data_length)); -#endif - -/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ -PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); - -/* Read the CRC from the file and compare it to the libpng calculated CRC */ -PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); - -/* Calculate the CRC over a section of data. Note that we are only - * passing a maximum of 64K on systems that have this as a memory limit, - * since this is the maximum buffer size we can specify. +#ifdef PNG_USE_READ_MACROS +/* Inline macros to do direct reads of bytes from the input buffer. + * The png_get_int_32() routine assumes we are using two's complement + * format for negative values, which is almost certainly true. */ -PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, - png_size_t length)); - -#if defined(PNG_WRITE_FLUSH_SUPPORTED) -PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); -#endif - -/* simple function to write the signature */ -PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); - -/* write various chunks */ - -/* Write the IHDR chunk, and update the png_struct with the necessary - * information. - */ -PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, - png_uint_32 height, - int bit_depth, int color_type, int compression_method, int filter_method, - int interlace_method)); - -PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, - png_uint_32 num_pal)); - -PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, - png_size_t length)); - -PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); - -#if defined(PNG_WRITE_gAMA_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); -#endif -#ifdef PNG_FIXED_POINT_SUPPORTED -PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point - file_gamma)); -#endif -#endif - -#if defined(PNG_WRITE_sBIT_SUPPORTED) -PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, - int color_type)); -#endif - -#if defined(PNG_WRITE_cHRM_SUPPORTED) -#ifdef PNG_FLOATING_POINT_SUPPORTED -PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, - double white_x, double white_y, - double red_x, double red_y, double green_x, double green_y, - double blue_x, double blue_y)); -#endif -#ifdef PNG_FIXED_POINT_SUPPORTED -PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, - png_fixed_point int_white_x, png_fixed_point int_white_y, - png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point - int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, - png_fixed_point int_blue_y)); -#endif -#endif - -#if defined(PNG_WRITE_sRGB_SUPPORTED) -PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, - int intent)); -#endif - -#if defined(PNG_WRITE_iCCP_SUPPORTED) -PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, - png_charp name, int compression_type, - png_charp profile, int proflen)); - /* Note to maintainer: profile should be png_bytep */ -#endif - -#if defined(PNG_WRITE_sPLT_SUPPORTED) -PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, - png_sPLT_tp palette)); -#endif - -#if defined(PNG_WRITE_tRNS_SUPPORTED) -PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, - png_color_16p values, int number, int color_type)); -#endif - -#if defined(PNG_WRITE_bKGD_SUPPORTED) -PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, - png_color_16p values, int color_type)); -#endif - -#if defined(PNG_WRITE_hIST_SUPPORTED) -PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, - int num_hist)); -#endif - -#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ - defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) -PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, - png_charp key, png_charpp new_key)); -#endif - -#if defined(PNG_WRITE_tEXt_SUPPORTED) -PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, - png_charp text, png_size_t text_len)); -#endif - -#if defined(PNG_WRITE_zTXt_SUPPORTED) -PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, - png_charp text, png_size_t text_len, int compression)); -#endif - -#if defined(PNG_WRITE_iTXt_SUPPORTED) -PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, - int compression, png_charp key, png_charp lang, png_charp lang_key, - png_charp text)); -#endif - -#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ -PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, - png_infop info_ptr, png_textp text_ptr, int num_text)); -#endif - -#if defined(PNG_WRITE_oFFs_SUPPORTED) -PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, - png_int_32 x_offset, png_int_32 y_offset, int unit_type)); -#endif - -#if defined(PNG_WRITE_pCAL_SUPPORTED) -PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, - png_int_32 X0, png_int_32 X1, int type, int nparams, - png_charp units, png_charpp params)); -#endif - -#if defined(PNG_WRITE_pHYs_SUPPORTED) -PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, - png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, - int unit_type)); -#endif - -#if defined(PNG_WRITE_tIME_SUPPORTED) -PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, - png_timep mod_time)); -#endif - -#if defined(PNG_WRITE_sCAL_SUPPORTED) -#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) -PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, - int unit, double width, double height)); -#else -#ifdef PNG_FIXED_POINT_SUPPORTED -PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, - int unit, png_charp width, png_charp height)); -#endif -#endif -#endif - -/* Called when finished processing a row of data */ -PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); - -/* Internal use only. Called before first row of data */ -PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); +# define png_get_uint_32(buf) \ + (((png_uint_32)(*(buf)) << 24) + \ + ((png_uint_32)(*((buf) + 1)) << 16) + \ + ((png_uint_32)(*((buf) + 2)) << 8) + \ + ((png_uint_32)(*((buf) + 3)))) + + /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the + * function) incorrectly returned a value of type png_uint_32. + */ +# define png_get_uint_16(buf) \ + ((png_uint_16) \ + (((unsigned int)(*(buf)) << 8) + \ + ((unsigned int)(*((buf) + 1))))) -#if defined(PNG_READ_GAMMA_SUPPORTED) -PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +# define png_get_int_32(buf) \ + ((png_int_32)((*(buf) & 0x80) \ + ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \ + : (png_int_32)png_get_uint_32(buf))) #endif -/* combine a row of data, dealing with alpha, etc. if requested */ -PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, - int mask)); - -#if defined(PNG_READ_INTERLACING_SUPPORTED) -/* expand an interlaced row */ -/* OLD pre-1.0.9 interface: -PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, - png_bytep row, int pass, png_uint_32 transformations)); +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project + * defs */ -PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); -#endif - -/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ - -#if defined(PNG_WRITE_INTERLACING_SUPPORTED) -/* grab pixels out of a row for an interlaced pass */ -PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, - png_bytep row, int pass)); -#endif - -/* unfilter a row */ -PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, - png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); - -/* Choose the best filter to use and filter the row data */ -PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, - png_row_infop row_info)); - -/* Write out the filtered row. */ -PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, - png_bytep filtered_row)); -/* finish a row while reading, dealing with interlacing passes, etc. */ -PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); - -/* initialize the row buffers, etc. */ -PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); -/* optional call to update the users info structure */ -PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, - png_infop info_ptr)); - -/* these are the functions that do the transformations */ -#if defined(PNG_READ_FILLER_SUPPORTED) -PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, - png_bytep row, png_uint_32 filler, png_uint_32 flags)); -#endif - -#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ - defined(PNG_READ_STRIP_ALPHA_SUPPORTED) -PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, - png_bytep row, png_uint_32 flags)); -#endif - -#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) -PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) -PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) -PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop - row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) -PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_READ_PACK_SUPPORTED) -PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_SHIFT_SUPPORTED) -PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, - png_color_8p sig_bits)); -#endif - -#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) -PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_16_TO_8_SUPPORTED) -PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_READ_DITHER_SUPPORTED) -PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, - png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); -# if defined(PNG_CORRECT_PALETTE_SUPPORTED) -PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, - png_colorp palette, int num_palette)); -# endif -#endif - -#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) -PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); -#endif - -#if defined(PNG_WRITE_PACK_SUPPORTED) -PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, - png_bytep row, png_uint_32 bit_depth)); -#endif - -#if defined(PNG_WRITE_SHIFT_SUPPORTED) -PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, - png_color_8p bit_depth)); -#endif - -#if defined(PNG_READ_BACKGROUND_SUPPORTED) -#if defined(PNG_READ_GAMMA_SUPPORTED) -PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, - png_color_16p trans_values, png_color_16p background, - png_color_16p background_1, - png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, - png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, - png_uint_16pp gamma_16_to_1, int gamma_shift)); -#else -PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, - png_color_16p trans_values, png_color_16p background)); -#endif -#endif - -#if defined(PNG_READ_GAMMA_SUPPORTED) -PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, - png_bytep gamma_table, png_uint_16pp gamma_16_table, - int gamma_shift)); -#endif - -#if defined(PNG_READ_EXPAND_SUPPORTED) -PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, - png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); -PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, - png_bytep row, png_color_16p trans_value)); -#endif - -/* The following decodes the appropriate chunks, and does error correction, - * then calls the appropriate callback for the chunk if it is valid. +/* The last ordinal number (this is the *last* one already used; the next + * one to use is one more than this.) Maintainer, remember to add an entry to + * scripts/symbols.def as well. */ - -/* decode the IHDR chunk */ -PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); - -#if defined(PNG_READ_bKGD_SUPPORTED) -PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_cHRM_SUPPORTED) -PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_gAMA_SUPPORTED) -PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_hIST_SUPPORTED) -PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_iCCP_SUPPORTED) -extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif /* PNG_READ_iCCP_SUPPORTED */ - -#if defined(PNG_READ_iTXt_SUPPORTED) -PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_oFFs_SUPPORTED) -PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_pCAL_SUPPORTED) -PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_pHYs_SUPPORTED) -PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_sBIT_SUPPORTED) -PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); +#ifdef PNG_EXPORT_LAST_ORDINAL + PNG_EXPORT_LAST_ORDINAL(233); #endif -#if defined(PNG_READ_sCAL_SUPPORTED) -PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_sPLT_SUPPORTED) -extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif /* PNG_READ_sPLT_SUPPORTED */ - -#if defined(PNG_READ_sRGB_SUPPORTED) -PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_tEXt_SUPPORTED) -PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_tIME_SUPPORTED) -PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_tRNS_SUPPORTED) -PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -#if defined(PNG_READ_zTXt_SUPPORTED) -PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, - png_uint_32 length)); -#endif - -PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); - -PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, - png_bytep chunk_name)); - -/* handle the transformations for reading and writing */ -PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); - -PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); - -#ifdef PNG_PROGRESSIVE_READ_SUPPORTED -PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, - png_uint_32 length)); -PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t buffer_length)); -PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, - png_bytep buffer, png_size_t buffer_length)); -PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); -PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); -PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, - png_infop info_ptr)); -PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); -#if defined(PNG_READ_tEXt_SUPPORTED) -PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -#endif -#if defined(PNG_READ_zTXt_SUPPORTED) -PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -#endif -#if defined(PNG_READ_iTXt_SUPPORTED) -PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, - png_infop info_ptr, png_uint_32 length)); -PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, - png_infop info_ptr)); -#endif - -#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ - -#ifdef PNG_MNG_FEATURES_SUPPORTED -PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, - png_bytep row)); -PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, - png_bytep row)); -#endif - -#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) -#if defined(PNG_MMX_CODE_SUPPORTED) -/* png.c */ /* PRIVATE */ -PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); -#endif -#endif - -#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) -PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr, -png_infop info_ptr)); - -PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr, -png_infop info_ptr)); - -PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr, -png_infop info_ptr)); - -PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr, -png_infop info_ptr)); - -PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr, -png_infop info_ptr)); - -#if defined(PNG_pHYs_SUPPORTED) -PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr, -png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); -#endif /* PNG_pHYs_SUPPORTED */ -#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ - -/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ - -#endif /* PNG_INTERNAL */ - #ifdef __cplusplus } #endif #endif /* PNG_VERSION_INFO_ONLY */ -/* do not put anything past this line */ +/* Do not put anything past this line */ #endif /* PNG_H */ diff --git a/doomsday/external/libpng/portable/include/pngconf.h b/doomsday/external/libpng/portable/include/pngconf.h index 07344bacb8..05dd2928f5 100644 --- a/doomsday/external/libpng/portable/include/pngconf.h +++ b/doomsday/external/libpng/portable/include/pngconf.h @@ -1,11 +1,16 @@ /* pngconf.h - machine configurable file for libpng * - * libpng version 1.2.15 - January 5, 2007 - * For conditions of distribution and use, see copyright notice in png.h - * Copyright (c) 1998-2007 Glenn Randers-Pehrson + * libpng version 1.5.5 - September 22, 2011 + * + * Copyright (c) 1998-2011 Glenn Randers-Pehrson * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + * */ /* Any machine specific code is near the front of this file, so if you @@ -17,244 +22,57 @@ #ifndef PNGCONF_H #define PNGCONF_H -#define PNG_1_2_X - -/* - * PNG_USER_CONFIG has to be defined on the compiler command line. This - * includes the resource compiler for Windows DLL configurations. +#ifndef PNG_BUILDING_SYMBOL_TABLE +/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C + * definition file for machine specific limits, this may impact the + * correctness of the definitons below (see uses of INT_MAX). */ -#ifdef PNG_USER_CONFIG -# ifndef PNG_USER_PRIVATEBUILD -# define PNG_USER_PRIVATEBUILD +# ifndef PNG_NO_LIMITS_H +# include # endif -#include "pngusr.h" -#endif -/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */ -#ifdef PNG_CONFIGURE_LIBPNG -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif -#endif - -/* - * Added at libpng-1.2.8 - * - * If you create a private DLL you need to define in "pngusr.h" the followings: - * #define PNG_USER_PRIVATEBUILD - * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons." - * #define PNG_USER_DLLFNAME_POSTFIX - * e.g. // private DLL "libpng13gx.dll" - * #define PNG_USER_DLLFNAME_POSTFIX "gx" - * - * The following macros are also at your disposal if you want to complete the - * DLL VERSIONINFO structure. - * - PNG_USER_VERSIONINFO_COMMENTS - * - PNG_USER_VERSIONINFO_COMPANYNAME - * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS +/* For the memory copy APIs (i.e. the standard definitions of these), + * because this file defines png_memcpy and so on the base APIs must + * be defined here. */ - -#ifdef __STDC__ -#ifdef SPECIALBUILD -# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\ - are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.") -#endif - -#ifdef PRIVATEBUILD -# pragma message("PRIVATEBUILD is deprecated.\ - Use PNG_USER_PRIVATEBUILD instead.") -# define PNG_USER_PRIVATEBUILD PRIVATEBUILD -#endif -#endif /* __STDC__ */ - -#ifndef PNG_VERSION_INFO_ONLY - -/* End of material added to libpng-1.2.8 */ - -/* This is the size of the compression buffer, and thus the size of - * an IDAT chunk. Make this whatever size you feel is best for your - * machine. One of these will be allocated per png_struct. When this - * is full, it writes the data to the disk, and does some other - * calculations. Making this an extremely small size will slow - * the library down, but you may want to experiment to determine - * where it becomes significant, if you are concerned with memory - * usage. Note that zlib allocates at least 32Kb also. For readers, - * this describes the size of the buffer available to read the data in. - * Unless this gets smaller than the size of a row (compressed), - * it should not make much difference how big this is. - */ - -#ifndef PNG_ZBUF_SIZE -# define PNG_ZBUF_SIZE 8192 -#endif - -/* Enable if you want a write-only libpng */ - -#ifndef PNG_NO_READ_SUPPORTED -# define PNG_READ_SUPPORTED -#endif - -/* Enable if you want a read-only libpng */ - -#ifndef PNG_NO_WRITE_SUPPORTED -# define PNG_WRITE_SUPPORTED -#endif - -/* Enabled by default in 1.2.0. You can disable this if you don't need to - support PNGs that are embedded in MNG datastreams */ -#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) -# ifndef PNG_MNG_FEATURES_SUPPORTED -# define PNG_MNG_FEATURES_SUPPORTED +# ifdef BSD +# include +# else +# include # endif -#endif -#ifndef PNG_NO_FLOATING_POINT_SUPPORTED -# ifndef PNG_FLOATING_POINT_SUPPORTED -# define PNG_FLOATING_POINT_SUPPORTED +/* For png_FILE_p - this provides the standard definition of a + * FILE + */ +# ifdef PNG_STDIO_SUPPORTED +# include # endif #endif -/* If you are running on a machine where you cannot allocate more - * than 64K of memory at once, uncomment this. While libpng will not - * normally need that much memory in a chunk (unless you load up a very - * large file), zlib needs to know how big of a chunk it can use, and - * libpng thus makes sure to check any memory allocation to verify it - * will fit into memory. -#define PNG_MAX_MALLOC_64K +/* This controls optimization of the reading of 16 and 32 bit values + * from PNG files. It can be set on a per-app-file basis - it + * just changes whether a macro is used to the function is called. + * The library builder sets the default, if read functions are not + * built into the library the macro implementation is forced on. */ -#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) -# define PNG_MAX_MALLOC_64K +#ifndef PNG_READ_INT_FUNCTIONS_SUPPORTED +# define PNG_USE_READ_MACROS #endif - -/* Special munging to support doing things the 'cygwin' way: - * 'Normal' png-on-win32 defines/defaults: - * PNG_BUILD_DLL -- building dll - * PNG_USE_DLL -- building an application, linking to dll - * (no define) -- building static library, or building an - * application and linking to the static lib - * 'Cygwin' defines/defaults: - * PNG_BUILD_DLL -- (ignored) building the dll - * (no define) -- (ignored) building an application, linking to the dll - * PNG_STATIC -- (ignored) building the static lib, or building an - * application that links to the static lib. - * ALL_STATIC -- (ignored) building various static libs, or building an - * application that links to the static libs. - * Thus, - * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and - * this bit of #ifdefs will define the 'correct' config variables based on - * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but - * unnecessary. - * - * Also, the precedence order is: - * ALL_STATIC (since we can't #undef something outside our namespace) - * PNG_BUILD_DLL - * PNG_STATIC - * (nothing) == PNG_USE_DLL - * - * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent - * of auto-import in binutils, we no longer need to worry about - * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, - * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes - * to __declspec() stuff. However, we DO need to worry about - * PNG_BUILD_DLL and PNG_STATIC because those change some defaults - * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. - */ -#if defined(__CYGWIN__) -# if defined(ALL_STATIC) -# if defined(PNG_BUILD_DLL) -# undef PNG_BUILD_DLL -# endif -# if defined(PNG_USE_DLL) -# undef PNG_USE_DLL -# endif -# if defined(PNG_DLL) -# undef PNG_DLL -# endif -# if !defined(PNG_STATIC) -# define PNG_STATIC -# endif -# else -# if defined (PNG_BUILD_DLL) -# if defined(PNG_STATIC) -# undef PNG_STATIC -# endif -# if defined(PNG_USE_DLL) -# undef PNG_USE_DLL -# endif -# if !defined(PNG_DLL) -# define PNG_DLL -# endif -# else -# if defined(PNG_STATIC) -# if defined(PNG_USE_DLL) -# undef PNG_USE_DLL -# endif -# if defined(PNG_DLL) -# undef PNG_DLL -# endif -# else -# if !defined(PNG_USE_DLL) -# define PNG_USE_DLL -# endif -# if !defined(PNG_DLL) -# define PNG_DLL -# endif -# endif -# endif +#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) +# if PNG_DEFAULT_READ_MACROS +# define PNG_USE_READ_MACROS # endif #endif -/* This protects us against compilers that run on a windowing system - * and thus don't have or would rather us not use the stdio types: - * stdin, stdout, and stderr. The only one currently used is stderr - * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will - * prevent these from being compiled and used. #defining PNG_NO_STDIO - * will also prevent these, plus will prevent the entire set of stdio - * macros and functions (FILE *, printf, etc.) from being compiled and used, - * unless (PNG_DEBUG > 0) has been #defined. +/* COMPILER SPECIFIC OPTIONS. * - * #define PNG_NO_CONSOLE_IO - * #define PNG_NO_STDIO + * These options are provided so that a variety of difficult compilers + * can be used. Some are fixed at build time (e.g. PNG_API_RULE + * below) but still have compiler specific implementations, others + * may be changed on a per-file basis when compiling against libpng. */ -#if defined(_WIN32_WCE) -# include - /* Console I/O functions are not supported on WindowsCE */ -# define PNG_NO_CONSOLE_IO -# ifdef PNG_DEBUG -# undef PNG_DEBUG -# endif -#endif - -#ifdef PNG_BUILD_DLL -# ifndef PNG_CONSOLE_IO_SUPPORTED -# ifndef PNG_NO_CONSOLE_IO -# define PNG_NO_CONSOLE_IO -# endif -# endif -#endif - -# ifdef PNG_NO_STDIO -# ifndef PNG_NO_CONSOLE_IO -# define PNG_NO_CONSOLE_IO -# endif -# ifdef PNG_DEBUG -# if (PNG_DEBUG > 0) -# include -# endif -# endif -# else -# if !defined(_WIN32_WCE) -/* "stdio.h" functions are not supported on WindowsCE */ -# include -# endif -# endif - -/* This macro protects us against machines that don't have function +/* The PNGARG macro protects us against machines that don't have function * prototypes (ie K&R style headers). If your compiler does not handle * function prototypes, define this macro and use the included ansi2knr. * I've always been able to use _NO_PROTO as the indicator, but you may @@ -263,824 +81,351 @@ */ #ifndef PNGARG -#ifdef OF /* zlib prototype munger */ -# define PNGARG(arglist) OF(arglist) -#else +# ifdef OF /* zlib prototype munger */ +# define PNGARG(arglist) OF(arglist) +# else -#ifdef _NO_PROTO -# define PNGARG(arglist) () -# ifndef PNG_TYPECAST_NULL -# define PNG_TYPECAST_NULL -# endif -#else -# define PNGARG(arglist) arglist -#endif /* _NO_PROTO */ +# ifdef _NO_PROTO +# define PNGARG(arglist) () +# else +# define PNGARG(arglist) arglist +# endif /* _NO_PROTO */ -#endif /* OF */ +# endif /* OF */ #endif /* PNGARG */ -/* Try to determine if we are compiling on a Mac. Note that testing for - * just __MWERKS__ is not good enough, because the Codewarrior is now used - * on non-Mac platforms. - */ -#ifndef MACOS -# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ - defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) -# define MACOS -# endif -#endif - -/* enough people need this for various reasons to include it here */ -#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) -# include -#endif - -#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) -# define PNG_SETJMP_SUPPORTED -#endif - -#ifdef PNG_SETJMP_SUPPORTED -/* This is an attempt to force a single setjmp behaviour on Linux. If - * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. - */ - -# ifdef __linux__ -# ifdef _BSD_SOURCE -# define PNG_SAVE_BSD_SOURCE -# undef _BSD_SOURCE +/* Function calling conventions. + * ============================= + * Normally it is not necessary to specify to the compiler how to call + * a function - it just does it - however on x86 systems derived from + * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems + * and some others) there are multiple ways to call a function and the + * default can be changed on the compiler command line. For this reason + * libpng specifies the calling convention of every exported function and + * every function called via a user supplied function pointer. This is + * done in this file by defining the following macros: + * + * PNGAPI Calling convention for exported functions. + * PNGCBAPI Calling convention for user provided (callback) functions. + * PNGCAPI Calling convention used by the ANSI-C library (required + * for longjmp callbacks and sometimes used internally to + * specify the calling convention for zlib). + * + * These macros should never be overridden. If it is necessary to + * change calling convention in a private build this can be done + * by setting PNG_API_RULE (which defaults to 0) to one of the values + * below to select the correct 'API' variants. + * + * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. + * This is correct in every known environment. + * PNG_API_RULE=1 Use the operating system convention for PNGAPI and + * the 'C' calling convention (from PNGCAPI) for + * callbacks (PNGCBAPI). This is no longer required + * in any known environment - if it has to be used + * please post an explanation of the problem to the + * libpng mailing list. + * + * These cases only differ if the operating system does not use the C + * calling convention, at present this just means the above cases + * (x86 DOS/Windows sytems) and, even then, this does not apply to + * Cygwin running on those systems. + * + * Note that the value must be defined in pnglibconf.h so that what + * the application uses to call the library matches the conventions + * set when building the library. + */ + +/* Symbol export + * ============= + * When building a shared library it is almost always necessary to tell + * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' + * is used to mark the symbols. On some systems these symbols can be + * extracted at link time and need no special processing by the compiler, + * on other systems the symbols are flagged by the compiler and just + * the declaration requires a special tag applied (unfortunately) in a + * compiler dependent way. Some systems can do either. + * + * A small number of older systems also require a symbol from a DLL to + * be flagged to the program that calls it. This is a problem because + * we do not know in the header file included by application code that + * the symbol will come from a shared library, as opposed to a statically + * linked one. For this reason the application must tell us by setting + * the magic flag PNG_USE_DLL to turn on the special processing before + * it includes png.h. + * + * Four additional macros are used to make this happen: + * + * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from + * the build or imported if PNG_USE_DLL is set - compiler + * and system specific. + * + * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to + * 'type', compiler specific. + * + * PNG_DLL_EXPORT Set to the magic to use during a libpng build to + * make a symbol exported from the DLL. Not used in the + * public header files; see pngpriv.h for how it is used + * in the libpng build. + * + * PNG_DLL_IMPORT Set to the magic to force the libpng symbols to come + * from a DLL - used to define PNG_IMPEXP when + * PNG_USE_DLL is set. + */ + +/* System specific discovery. + * ========================== + * This code is used at build time to find PNG_IMPEXP, the API settings + * and PNG_EXPORT_TYPE(), it may also set a macro to indicate the DLL + * import processing is possible. On Windows/x86 systems it also sets + * compiler-specific macros to the values required to change the calling + * conventions of the various functions. + */ +#if ( defined(_Windows) || defined(_WINDOWS) || defined(WIN32) ||\ + defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) ) &&\ + ( defined(_X86_) || defined(_X64_) || defined(_M_IX86) ||\ + defined(_M_X64) || defined(_M_IA64) ) + /* Windows system (DOS doesn't support DLLs) running on x86/x64. Includes + * builds under Cygwin or MinGW. Also includes Watcom builds but these need + * special treatment because they are not compatible with GCC or Visual C + * because of different calling conventions. + */ +# if PNG_API_RULE == 2 + /* If this line results in an error, either because __watcall is not + * understood or because of a redefine just below you cannot use *this* + * build of the library with the compiler you are using. *This* build was + * build using Watcom and applications must also be built using Watcom! + */ +# define PNGCAPI __watcall +# endif + +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGCAPI __cdecl +# if PNG_API_RULE == 1 +# define PNGAPI __stdcall # endif -# ifdef _SETJMP_H - /* If you encounter a compiler error here, see the explanation - * near the end of INSTALL. - */ - __png.h__ already includes setjmp.h; - __dont__ include it again.; +# else + /* An older compiler, or one not detected (erroneously) above, + * if necessary override on the command line to get the correct + * variants for the compiler. + */ +# ifndef PNGCAPI +# define PNGCAPI _cdecl # endif -# endif /* __linux__ */ - - /* include setjmp.h for error handling */ -# include - -# ifdef __linux__ -# ifdef PNG_SAVE_BSD_SOURCE -# define _BSD_SOURCE -# undef PNG_SAVE_BSD_SOURCE +# if PNG_API_RULE == 1 && !defined(PNGAPI) +# define PNGAPI _stdcall # endif -# endif /* __linux__ */ -#endif /* PNG_SETJMP_SUPPORTED */ - -#ifdef BSD -# include -#else -# include -#endif - -/* Other defines for things like memory and the like can go here. */ -#ifdef PNG_INTERNAL - -#include - -/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which - * aren't usually used outside the library (as far as I know), so it is - * debatable if they should be exported at all. In the future, when it is - * possible to have run-time registry of chunk-handling functions, some of - * these will be made available again. -#define PNG_EXTERN extern - */ -#define PNG_EXTERN - -/* Other defines specific to compilers can go here. Try to keep - * them inside an appropriate ifdef/endif pair for portability. - */ +# endif /* compiler/api */ + /* NOTE: PNGCBAPI always defaults to PNGCAPI. */ -#if defined(PNG_FLOATING_POINT_SUPPORTED) -# if defined(MACOS) - /* We need to check that hasn't already been included earlier - * as it seems it doesn't agree with , yet we should really use - * if possible. - */ -# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) -# include -# endif -# else -# include -# endif -# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) - /* Amiga SAS/C: We must include builtin FPU functions when compiling using - * MATH=68881 - */ -# include +# if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD) + ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed # endif -#endif - -/* Codewarrior on NT has linking problems without this. */ -#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) -# define PNG_ALWAYS_EXTERN -#endif - -/* This provides the non-ANSI (far) memory allocation routines. */ -#if defined(__TURBOC__) && defined(__MSDOS__) -# include -# include -#endif - -/* I have no idea why is this necessary... */ -#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ - defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) -# include -#endif -/* This controls how fine the dithering gets. As this allocates - * a largish chunk of memory (32K), those who are not as concerned - * with dithering quality can decrease some or all of these. - */ -#ifndef PNG_DITHER_RED_BITS -# define PNG_DITHER_RED_BITS 5 -#endif -#ifndef PNG_DITHER_GREEN_BITS -# define PNG_DITHER_GREEN_BITS 5 -#endif -#ifndef PNG_DITHER_BLUE_BITS -# define PNG_DITHER_BLUE_BITS 5 -#endif - -/* This controls how fine the gamma correction becomes when you - * are only interested in 8 bits anyway. Increasing this value - * results in more memory being used, and more pow() functions - * being called to fill in the gamma tables. Don't set this value - * less then 8, and even that may not work (I haven't tested it). - */ +# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ + (defined(__BORLANDC__) && __BORLANDC__ < 0x500) + /* older Borland and MSC + * compilers used '__export' and required this to be after + * the type. + */ +# ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP +# endif +# define PNG_DLL_EXPORT __export +# else /* newer compiler */ +# define PNG_DLL_EXPORT __declspec(dllexport) +# ifndef PNG_DLL_IMPORT +# define PNG_DLL_IMPORT __declspec(dllimport) +# endif +# endif /* compiler */ -#ifndef PNG_MAX_GAMMA_8 -# define PNG_MAX_GAMMA_8 11 -#endif +#else /* !Windows/x86 */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# define PNGAPI _System +# else /* !Windows/x86 && !OS/2 */ + /* Use the defaults, or define PNG*API on the command line (but + * this will have to be done for every compile!) + */ +# endif /* other system, !OS/2 */ +#endif /* !Windows/x86 */ -/* This controls how much a difference in gamma we can tolerate before - * we actually start doing gamma conversion. - */ -#ifndef PNG_GAMMA_THRESHOLD -# define PNG_GAMMA_THRESHOLD 0.05 +/* Now do all the defaulting . */ +#ifndef PNGCAPI +# define PNGCAPI #endif - -#endif /* PNG_INTERNAL */ - -/* The following uses const char * instead of char * for error - * and warning message functions, so some compilers won't complain. - * If you do not want to use const, define PNG_NO_CONST here. - */ - -#ifndef PNG_NO_CONST -# define PNG_CONST const -#else -# define PNG_CONST +#ifndef PNGCBAPI +# define PNGCBAPI PNGCAPI #endif - -/* The following defines give you the ability to remove code from the - * library that you will not be using. I wish I could figure out how to - * automate this, but I can't do that without making it seriously hard - * on the users. So if you are not using an ability, change the #define - * to and #undef, and that part of the library will not be compiled. If - * your linker can't find a function, you may want to make sure the - * ability is defined here. Some of these depend upon some others being - * defined. I haven't figured out all the interactions here, so you may - * have to experiment awhile to get everything to compile. If you are - * creating or using a shared library, you probably shouldn't touch this, - * as it will affect the size of the structures, and this will cause bad - * things to happen if the library and/or application ever change. - */ - -/* Any features you will not be using can be undef'ed here */ - -/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user - * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS - * on the compile line, then pick and choose which ones to define without - * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED - * if you only want to have a png-compliant reader/writer but don't need - * any of the extra transformations. This saves about 80 kbytes in a - * typical installation of the library. (PNG_NO_* form added in version - * 1.0.1c, for consistency) - */ - -/* The size of the png_text structure changed in libpng-1.0.6 when - * iTXt support was added. iTXt support was turned off by default through - * libpng-1.2.x, to support old apps that malloc the png_text structure - * instead of calling png_set_text() and letting libpng malloc it. It - * was turned on by default in libpng-1.3.0. - */ - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -# ifndef PNG_NO_iTXt_SUPPORTED -# define PNG_NO_iTXt_SUPPORTED -# endif -# ifndef PNG_NO_READ_iTXt -# define PNG_NO_READ_iTXt -# endif -# ifndef PNG_NO_WRITE_iTXt -# define PNG_NO_WRITE_iTXt -# endif -#endif - -#if !defined(PNG_NO_iTXt_SUPPORTED) -# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) -# define PNG_READ_iTXt -# endif -# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) -# define PNG_WRITE_iTXt -# endif +#ifndef PNGAPI +# define PNGAPI PNGCAPI #endif -/* The following support, added after version 1.0.0, can be turned off here en - * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility - * with old applications that require the length of png_struct and png_info - * to remain unchanged. +/* PNG_IMPEXP may be set on the compilation system command line or (if not set) + * then in an internal header file when building the library, otherwise (when + * using the library) it is set here. */ - -#ifdef PNG_LEGACY_SUPPORTED -# define PNG_NO_FREE_ME -# define PNG_NO_READ_UNKNOWN_CHUNKS -# define PNG_NO_WRITE_UNKNOWN_CHUNKS -# define PNG_NO_READ_USER_CHUNKS -# define PNG_NO_READ_iCCP -# define PNG_NO_WRITE_iCCP -# define PNG_NO_READ_iTXt -# define PNG_NO_WRITE_iTXt -# define PNG_NO_READ_sCAL -# define PNG_NO_WRITE_sCAL -# define PNG_NO_READ_sPLT -# define PNG_NO_WRITE_sPLT -# define PNG_NO_INFO_IMAGE -# define PNG_NO_READ_RGB_TO_GRAY -# define PNG_NO_READ_USER_TRANSFORM -# define PNG_NO_WRITE_USER_TRANSFORM -# define PNG_NO_USER_MEM -# define PNG_NO_READ_EMPTY_PLTE -# define PNG_NO_MNG_FEATURES -# define PNG_NO_FIXED_POINT_SUPPORTED -#endif - -/* Ignore attempt to turn off both floating and fixed point support */ -#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ - !defined(PNG_NO_FIXED_POINT_SUPPORTED) -# define PNG_FIXED_POINT_SUPPORTED -#endif - -#ifndef PNG_NO_FREE_ME -# define PNG_FREE_ME_SUPPORTED -#endif - -#if defined(PNG_READ_SUPPORTED) - -#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ - !defined(PNG_NO_READ_TRANSFORMS) -# define PNG_READ_TRANSFORMS_SUPPORTED -#endif - -#ifdef PNG_READ_TRANSFORMS_SUPPORTED -# ifndef PNG_NO_READ_EXPAND -# define PNG_READ_EXPAND_SUPPORTED -# endif -# ifndef PNG_NO_READ_SHIFT -# define PNG_READ_SHIFT_SUPPORTED -# endif -# ifndef PNG_NO_READ_PACK -# define PNG_READ_PACK_SUPPORTED -# endif -# ifndef PNG_NO_READ_BGR -# define PNG_READ_BGR_SUPPORTED -# endif -# ifndef PNG_NO_READ_SWAP -# define PNG_READ_SWAP_SUPPORTED -# endif -# ifndef PNG_NO_READ_PACKSWAP -# define PNG_READ_PACKSWAP_SUPPORTED -# endif -# ifndef PNG_NO_READ_INVERT -# define PNG_READ_INVERT_SUPPORTED -# endif -# ifndef PNG_NO_READ_DITHER -# define PNG_READ_DITHER_SUPPORTED -# endif -# ifndef PNG_NO_READ_BACKGROUND -# define PNG_READ_BACKGROUND_SUPPORTED -# endif -# ifndef PNG_NO_READ_16_TO_8 -# define PNG_READ_16_TO_8_SUPPORTED -# endif -# ifndef PNG_NO_READ_FILLER -# define PNG_READ_FILLER_SUPPORTED -# endif -# ifndef PNG_NO_READ_GAMMA -# define PNG_READ_GAMMA_SUPPORTED -# endif -# ifndef PNG_NO_READ_GRAY_TO_RGB -# define PNG_READ_GRAY_TO_RGB_SUPPORTED -# endif -# ifndef PNG_NO_READ_SWAP_ALPHA -# define PNG_READ_SWAP_ALPHA_SUPPORTED -# endif -# ifndef PNG_NO_READ_INVERT_ALPHA -# define PNG_READ_INVERT_ALPHA_SUPPORTED -# endif -# ifndef PNG_NO_READ_STRIP_ALPHA -# define PNG_READ_STRIP_ALPHA_SUPPORTED -# endif -# ifndef PNG_NO_READ_USER_TRANSFORM -# define PNG_READ_USER_TRANSFORM_SUPPORTED -# endif -# ifndef PNG_NO_READ_RGB_TO_GRAY -# define PNG_READ_RGB_TO_GRAY_SUPPORTED -# endif -#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ - -#if !defined(PNG_NO_PROGRESSIVE_READ) && \ - !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ -# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ -#endif /* about interlacing capability! You'll */ - /* still have interlacing unless you change the following line: */ - -#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ - -#ifndef PNG_NO_READ_COMPOSITE_NODIV -# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ -# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ -# endif -#endif - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Deprecated, will be removed from version 2.0.0. - Use PNG_MNG_FEATURES_SUPPORTED instead. */ -#ifndef PNG_NO_READ_EMPTY_PLTE -# define PNG_READ_EMPTY_PLTE_SUPPORTED -#endif -#endif - -#endif /* PNG_READ_SUPPORTED */ - -#if defined(PNG_WRITE_SUPPORTED) - -# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ - !defined(PNG_NO_WRITE_TRANSFORMS) -# define PNG_WRITE_TRANSFORMS_SUPPORTED -#endif - -#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED -# ifndef PNG_NO_WRITE_SHIFT -# define PNG_WRITE_SHIFT_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_PACK -# define PNG_WRITE_PACK_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_BGR -# define PNG_WRITE_BGR_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_SWAP -# define PNG_WRITE_SWAP_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_PACKSWAP -# define PNG_WRITE_PACKSWAP_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_INVERT -# define PNG_WRITE_INVERT_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_FILLER -# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ -# endif -# ifndef PNG_NO_WRITE_SWAP_ALPHA -# define PNG_WRITE_SWAP_ALPHA_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_INVERT_ALPHA -# define PNG_WRITE_INVERT_ALPHA_SUPPORTED -# endif -# ifndef PNG_NO_WRITE_USER_TRANSFORM -# define PNG_WRITE_USER_TRANSFORM_SUPPORTED -# endif -#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ - -#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \ - !defined(PNG_WRITE_INTERLACING_SUPPORTED) -#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant - encoders, but can cause trouble - if left undefined */ -#endif - -#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ - !defined(PNG_WRITE_WEIGHTED_FILTER) && \ - defined(PNG_FLOATING_POINT_SUPPORTED) -# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED -#endif - -#ifndef PNG_NO_WRITE_FLUSH -# define PNG_WRITE_FLUSH_SUPPORTED -#endif - -#if defined(PNG_1_0_X) || defined (PNG_1_2_X) -/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ -#ifndef PNG_NO_WRITE_EMPTY_PLTE -# define PNG_WRITE_EMPTY_PLTE_SUPPORTED -#endif -#endif - -#endif /* PNG_WRITE_SUPPORTED */ - -#ifndef PNG_1_0_X -# ifndef PNG_NO_ERROR_NUMBERS -# define PNG_ERROR_NUMBERS_SUPPORTED +#ifndef PNG_IMPEXP +# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) + /* This forces use of a DLL, disallowing static linking */ +# define PNG_IMPEXP PNG_DLL_IMPORT # endif -#endif /* PNG_1_0_X */ -#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ - defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) -# ifndef PNG_NO_USER_TRANSFORM_PTR -# define PNG_USER_TRANSFORM_PTR_SUPPORTED +# ifndef PNG_IMPEXP +# define PNG_IMPEXP # endif #endif -#ifndef PNG_NO_STDIO -# define PNG_TIME_RFC1123_SUPPORTED -#endif - -/* This adds extra functions in pngget.c for accessing data from the - * info pointer (added in version 0.99) - * png_get_image_width() - * png_get_image_height() - * png_get_bit_depth() - * png_get_color_type() - * png_get_compression_type() - * png_get_filter_type() - * png_get_interlace_type() - * png_get_pixel_aspect_ratio() - * png_get_pixels_per_meter() - * png_get_x_offset_pixels() - * png_get_y_offset_pixels() - * png_get_x_offset_microns() - * png_get_y_offset_microns() +/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat + * 'attributes' as a storage class - the attributes go at the start of the + * function definition, and attributes are always appended regardless of the + * compiler. This considerably simplifies these macros but may cause problems + * if any compilers both need function attributes and fail to handle them as + * a storage class (this is unlikely.) */ -#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) -# define PNG_EASY_ACCESS_SUPPORTED +#ifndef PNG_FUNCTION +# define PNG_FUNCTION(type, name, args, attributes) attributes type name args #endif -/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 - * even when PNG_USE_PNGVCRD or PNG_USE_PNGGCCRD is not defined. - * - * PNG_NO_ASSEMBLER_CODE disables use of all assembler code and optimized C, - * and removes or includes several functions in the API. - * - * PNG_NO_MMX_CODE disables the use of MMX code without changing the API. - * When MMX code is off, then optimized C replacement functions are used. -*/ -#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) -# ifndef PNG_ASSEMBLER_CODE_SUPPORTED -# define PNG_ASSEMBLER_CODE_SUPPORTED -# endif -# if defined(XP_MACOSX) && !defined(PNG_NO_MMX_CODE) - /* work around Intel-Mac compiler bug */ -# define PNG_NO_MMX_CODE -# endif -# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) && \ - defined(__MMX__) -# define PNG_MMX_CODE_SUPPORTED -# endif -# if !defined(PNG_USE_PNGGCCRD) && !defined(PNG_NO_MMX_CODE) && \ - !defined(PNG_USE_PNGVCRD) && defined(__MMX__) -# define PNG_USE_PNGGCCRD -# endif +#ifndef PNG_EXPORT_TYPE +# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type #endif -/* If you are sure that you don't need thread safety and you are compiling - with PNG_USE_PNGCCRD for an MMX application, you can define this for - faster execution. See pnggccrd.c. -#define PNG_THREAD_UNSAFE_OK -*/ - -#if !defined(PNG_1_0_X) -#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) -# define PNG_USER_MEM_SUPPORTED -#endif -#endif /* PNG_1_0_X */ + /* The ordinal value is only relevant when preprocessing png.h for symbol + * table entries, so we discard it here. See the .dfn files in the + * scripts directory. + */ +#ifndef PNG_EXPORTA -/* Added at libpng-1.2.6 */ -#if !defined(PNG_1_0_X) -#ifndef PNG_SET_USER_LIMITS_SUPPORTED -#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED) -# define PNG_SET_USER_LIMITS_SUPPORTED +# define PNG_EXPORTA(ordinal, type, name, args, attributes)\ + PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \ + extern attributes) #endif -#endif -#endif /* PNG_1_0_X */ -/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter - * how large, set these limits to 0x7fffffffL +/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, + * so make something non-empty to satisfy the requirement: */ -#ifndef PNG_USER_WIDTH_MAX -# define PNG_USER_WIDTH_MAX 1000000L -#endif -#ifndef PNG_USER_HEIGHT_MAX -# define PNG_USER_HEIGHT_MAX 1000000L -#endif +#define PNG_EMPTY /*empty list*/ -/* These are currently experimental features, define them if you want */ +#define PNG_EXPORT(ordinal, type, name, args)\ + PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) -/* very little testing */ -/* -#ifdef PNG_READ_SUPPORTED -# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED -# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED -# endif +/* Use PNG_REMOVED to comment out a removed interface. */ +#ifndef PNG_REMOVED +# define PNG_REMOVED(ordinal, type, name, args, attributes) #endif -*/ -/* This is only for PowerPC big-endian and 680x0 systems */ -/* some testing */ -/* -#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED -# define PNG_READ_BIG_ENDIAN_SUPPORTED +#ifndef PNG_CALLBACK +# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) #endif -*/ - -/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ -/* -#define PNG_NO_POINTER_INDEXING -*/ - -/* These functions are turned off by default, as they will be phased out. */ -/* -#define PNG_USELESS_TESTS_SUPPORTED -#define PNG_CORRECT_PALETTE_SUPPORTED -*/ -/* Any chunks you are not interested in, you can undef here. The - * ones that allocate memory may be expecially important (hIST, - * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info - * a bit smaller. +/* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. + * + * Added at libpng-1.2.41. */ -#if defined(PNG_READ_SUPPORTED) && \ - !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ - !defined(PNG_NO_READ_ANCILLARY_CHUNKS) -# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED -#endif - -#if defined(PNG_WRITE_SUPPORTED) && \ - !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ - !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) -# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED -#endif - -#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED - -#ifdef PNG_NO_READ_TEXT -# define PNG_NO_READ_iTXt -# define PNG_NO_READ_tEXt -# define PNG_NO_READ_zTXt -#endif -#ifndef PNG_NO_READ_bKGD -# define PNG_READ_bKGD_SUPPORTED -# define PNG_bKGD_SUPPORTED -#endif -#ifndef PNG_NO_READ_cHRM -# define PNG_READ_cHRM_SUPPORTED -# define PNG_cHRM_SUPPORTED -#endif -#ifndef PNG_NO_READ_gAMA -# define PNG_READ_gAMA_SUPPORTED -# define PNG_gAMA_SUPPORTED -#endif -#ifndef PNG_NO_READ_hIST -# define PNG_READ_hIST_SUPPORTED -# define PNG_hIST_SUPPORTED -#endif -#ifndef PNG_NO_READ_iCCP -# define PNG_READ_iCCP_SUPPORTED -# define PNG_iCCP_SUPPORTED -#endif -#ifndef PNG_NO_READ_iTXt -# ifndef PNG_READ_iTXt_SUPPORTED -# define PNG_READ_iTXt_SUPPORTED -# endif -# ifndef PNG_iTXt_SUPPORTED -# define PNG_iTXt_SUPPORTED -# endif -#endif -#ifndef PNG_NO_READ_oFFs -# define PNG_READ_oFFs_SUPPORTED -# define PNG_oFFs_SUPPORTED -#endif -#ifndef PNG_NO_READ_pCAL -# define PNG_READ_pCAL_SUPPORTED -# define PNG_pCAL_SUPPORTED -#endif -#ifndef PNG_NO_READ_sCAL -# define PNG_READ_sCAL_SUPPORTED -# define PNG_sCAL_SUPPORTED -#endif -#ifndef PNG_NO_READ_pHYs -# define PNG_READ_pHYs_SUPPORTED -# define PNG_pHYs_SUPPORTED -#endif -#ifndef PNG_NO_READ_sBIT -# define PNG_READ_sBIT_SUPPORTED -# define PNG_sBIT_SUPPORTED -#endif -#ifndef PNG_NO_READ_sPLT -# define PNG_READ_sPLT_SUPPORTED -# define PNG_sPLT_SUPPORTED -#endif -#ifndef PNG_NO_READ_sRGB -# define PNG_READ_sRGB_SUPPORTED -# define PNG_sRGB_SUPPORTED -#endif -#ifndef PNG_NO_READ_tEXt -# define PNG_READ_tEXt_SUPPORTED -# define PNG_tEXt_SUPPORTED -#endif -#ifndef PNG_NO_READ_tIME -# define PNG_READ_tIME_SUPPORTED -# define PNG_tIME_SUPPORTED -#endif -#ifndef PNG_NO_READ_tRNS -# define PNG_READ_tRNS_SUPPORTED -# define PNG_tRNS_SUPPORTED -#endif -#ifndef PNG_NO_READ_zTXt -# define PNG_READ_zTXt_SUPPORTED -# define PNG_zTXt_SUPPORTED -#endif -#ifndef PNG_NO_READ_UNKNOWN_CHUNKS -# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED -# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED -# define PNG_UNKNOWN_CHUNKS_SUPPORTED -# endif -# ifndef PNG_NO_HANDLE_AS_UNKNOWN -# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +#ifndef PNG_NO_PEDANTIC_WARNINGS +# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED +# define PNG_PEDANTIC_WARNINGS_SUPPORTED # endif #endif -#if !defined(PNG_NO_READ_USER_CHUNKS) && \ - defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) -# define PNG_READ_USER_CHUNKS_SUPPORTED -# define PNG_USER_CHUNKS_SUPPORTED -# ifdef PNG_NO_READ_UNKNOWN_CHUNKS -# undef PNG_NO_READ_UNKNOWN_CHUNKS -# endif -# ifdef PNG_NO_HANDLE_AS_UNKNOWN -# undef PNG_NO_HANDLE_AS_UNKNOWN -# endif -#endif -#ifndef PNG_NO_READ_OPT_PLTE -# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ -#endif /* optional PLTE chunk in RGB and RGBA images */ -#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ - defined(PNG_READ_zTXt_SUPPORTED) -# define PNG_READ_TEXT_SUPPORTED -# define PNG_TEXT_SUPPORTED -#endif -#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ +#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED + /* Support for compiler specific function attributes. These are used + * so that where compiler support is available incorrect use of API + * functions in png.h will generate compiler warnings. Added at libpng + * version 1.2.41. + */ +# if defined(__GNUC__) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __attribute__((__noreturn__)) +# endif +# ifndef PNG_ALLOCATED +# define PNG_ALLOCATED __attribute__((__malloc__)) +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __attribute__((__deprecated__)) +# endif +# ifndef PNG_PRIVATE +# if 0 /* Doesn't work so we use deprecated instead*/ +# define PNG_PRIVATE \ + __attribute__((warning("This function is not exported by libpng."))) +# else +# define PNG_PRIVATE \ + __attribute__((__deprecated__)) +# endif +# endif +# endif /* __GNUC__ */ -#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +# if defined(_MSC_VER) && (_MSC_VER >= 1300) +# ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* not supported */ +# endif +# ifndef PNG_NORETURN +# define PNG_NORETURN __declspec(noreturn) +# endif +# ifndef PNG_ALLOCATED +# if defined(_MSC_VER) && (_MSC_VER >= 1300) +# define PNG_ALLOCATED __declspec(restrict) +# endif +# endif +# ifndef PNG_DEPRECATED +# define PNG_DEPRECATED __declspec(deprecated) +# endif +# ifndef PNG_PRIVATE +# define PNG_PRIVATE __declspec(deprecated) +# endif +# endif /* _MSC_VER */ +#endif /* PNG_PEDANTIC_WARNINGS */ -#ifdef PNG_NO_WRITE_TEXT -# define PNG_NO_WRITE_iTXt -# define PNG_NO_WRITE_tEXt -# define PNG_NO_WRITE_zTXt -#endif -#ifndef PNG_NO_WRITE_bKGD -# define PNG_WRITE_bKGD_SUPPORTED -# ifndef PNG_bKGD_SUPPORTED -# define PNG_bKGD_SUPPORTED -# endif +#ifndef PNG_DEPRECATED +# define PNG_DEPRECATED /* Use of this function is deprecated */ #endif -#ifndef PNG_NO_WRITE_cHRM -# define PNG_WRITE_cHRM_SUPPORTED -# ifndef PNG_cHRM_SUPPORTED -# define PNG_cHRM_SUPPORTED -# endif +#ifndef PNG_USE_RESULT +# define PNG_USE_RESULT /* The result of this function must be checked */ #endif -#ifndef PNG_NO_WRITE_gAMA -# define PNG_WRITE_gAMA_SUPPORTED -# ifndef PNG_gAMA_SUPPORTED -# define PNG_gAMA_SUPPORTED -# endif +#ifndef PNG_NORETURN +# define PNG_NORETURN /* This function does not return */ #endif -#ifndef PNG_NO_WRITE_hIST -# define PNG_WRITE_hIST_SUPPORTED -# ifndef PNG_hIST_SUPPORTED -# define PNG_hIST_SUPPORTED -# endif +#ifndef PNG_ALLOCATED +# define PNG_ALLOCATED /* The result of the function is new memory */ #endif -#ifndef PNG_NO_WRITE_iCCP -# define PNG_WRITE_iCCP_SUPPORTED -# ifndef PNG_iCCP_SUPPORTED -# define PNG_iCCP_SUPPORTED -# endif +#ifndef PNG_PRIVATE +# define PNG_PRIVATE /* This is a private libpng function */ #endif -#ifndef PNG_NO_WRITE_iTXt -# ifndef PNG_WRITE_iTXt_SUPPORTED -# define PNG_WRITE_iTXt_SUPPORTED -# endif -# ifndef PNG_iTXt_SUPPORTED -# define PNG_iTXt_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_oFFs -# define PNG_WRITE_oFFs_SUPPORTED -# ifndef PNG_oFFs_SUPPORTED -# define PNG_oFFs_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_pCAL -# define PNG_WRITE_pCAL_SUPPORTED -# ifndef PNG_pCAL_SUPPORTED -# define PNG_pCAL_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_sCAL -# define PNG_WRITE_sCAL_SUPPORTED -# ifndef PNG_sCAL_SUPPORTED -# define PNG_sCAL_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_pHYs -# define PNG_WRITE_pHYs_SUPPORTED -# ifndef PNG_pHYs_SUPPORTED -# define PNG_pHYs_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_sBIT -# define PNG_WRITE_sBIT_SUPPORTED -# ifndef PNG_sBIT_SUPPORTED -# define PNG_sBIT_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_sPLT -# define PNG_WRITE_sPLT_SUPPORTED -# ifndef PNG_sPLT_SUPPORTED -# define PNG_sPLT_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_sRGB -# define PNG_WRITE_sRGB_SUPPORTED -# ifndef PNG_sRGB_SUPPORTED -# define PNG_sRGB_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_tEXt -# define PNG_WRITE_tEXt_SUPPORTED -# ifndef PNG_tEXt_SUPPORTED -# define PNG_tEXt_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_tIME -# define PNG_WRITE_tIME_SUPPORTED -# ifndef PNG_tIME_SUPPORTED -# define PNG_tIME_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_tRNS -# define PNG_WRITE_tRNS_SUPPORTED -# ifndef PNG_tRNS_SUPPORTED -# define PNG_tRNS_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_zTXt -# define PNG_WRITE_zTXt_SUPPORTED -# ifndef PNG_zTXt_SUPPORTED -# define PNG_zTXt_SUPPORTED -# endif -#endif -#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS -# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED -# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED -# define PNG_UNKNOWN_CHUNKS_SUPPORTED -# endif -# ifndef PNG_NO_HANDLE_AS_UNKNOWN -# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED -# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED -# endif +#ifndef PNG_FP_EXPORT /* A floating point API. */ +# ifdef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FP_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args) +# else /* No floating point APIs */ +# define PNG_FP_EXPORT(ordinal, type, name, args) # endif #endif -#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ - defined(PNG_WRITE_zTXt_SUPPORTED) -# define PNG_WRITE_TEXT_SUPPORTED -# ifndef PNG_TEXT_SUPPORTED -# define PNG_TEXT_SUPPORTED +#ifndef PNG_FIXED_EXPORT /* A fixed point API. */ +# ifdef PNG_FIXED_POINT_SUPPORTED +# define PNG_FIXED_EXPORT(ordinal, type, name, args)\ + PNG_EXPORT(ordinal, type, name, args) +# else /* No fixed point APIs */ +# define PNG_FIXED_EXPORT(ordinal, type, name, args) # endif #endif -#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ - -/* Turn this off to disable png_read_png() and - * png_write_png() and leave the row_pointers member - * out of the info structure. +/* The following uses const char * instead of char * for error + * and warning message functions, so some compilers won't complain. + * If you do not want to use const, define PNG_NO_CONST here. + * + * This should not change how the APIs are called, so it can be done + * on a per-file basis in the application. */ -#ifndef PNG_NO_INFO_IMAGE -# define PNG_INFO_IMAGE_SUPPORTED -#endif - -/* need the time information for reading tIME chunks */ -#if defined(PNG_tIME_SUPPORTED) -# if !defined(_WIN32_WCE) - /* "time.h" functions are not supported on WindowsCE */ -# include +#ifndef PNG_CONST +# ifndef PNG_NO_CONST +# define PNG_CONST const +# else +# define PNG_CONST # endif #endif @@ -1089,28 +434,29 @@ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they * don't have to be exactly that size. Some compilers dislike passing * unsigned shorts as function parameters, so you may be better off using - * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may - * want to have unsigned int for png_uint_32 instead of unsigned long. + * unsigned int for png_uint_16. */ +#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL) +typedef unsigned int png_uint_32; +typedef int png_int_32; +#else typedef unsigned long png_uint_32; typedef long png_int_32; +#endif typedef unsigned short png_uint_16; typedef short png_int_16; typedef unsigned char png_byte; -/* This is usually size_t. It is typedef'ed just in case you need it to - change (I'm not sure if you will or not, so I thought I'd be safe) */ -#ifdef PNG_SIZE_T - typedef PNG_SIZE_T png_size_t; -# define png_sizeof(x) png_convert_size(sizeof (x)) +#ifdef PNG_NO_SIZE_T +typedef unsigned int png_size_t; #else - typedef size_t png_size_t; -# define png_sizeof(x) sizeof (x) +typedef size_t png_size_t; #endif +#define png_sizeof(x) (sizeof (x)) /* The following is needed for medium model support. It cannot be in the - * PNG_INTERNAL section. Needs modification for other compilers besides + * pngpriv.h header. Needs modification for other compilers besides * MSC. Model independent support declares all arrays and pointers to be * large using the far keyword. The zlib version used must also support * model independent data. As of version zlib 1.0.4, the necessary changes @@ -1119,27 +465,28 @@ typedef unsigned char png_byte; */ /* Separate compiler dependencies (problem here is that zlib.h always - defines FAR. (SJT) */ + * defines FAR. (SJT) + */ #ifdef __BORLANDC__ # if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) # define LDATA 1 # else # define LDATA 0 # endif - /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ + /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ # if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) -# define PNG_MAX_MALLOC_64K +# define PNG_MAX_MALLOC_64K /* only used in build */ # if (LDATA != 1) # ifndef FAR # define FAR __far # endif # define USE_FAR_KEYWORD # endif /* LDATA != 1 */ - /* Possibly useful for moving data out of default segment. - * Uncomment it if you want. Could also define FARDATA as - * const if your compiler supports it. (SJT) -# define FARDATA FAR - */ + /* Possibly useful for moving data out of default segment. + * Uncomment it if you want. Could also define FARDATA as + * const if your compiler supports it. (SJT) +# define FARDATA FAR + */ # endif /* __WIN32__, __FLAT__, __CYGWIN__ */ #endif /* __BORLANDC__ */ @@ -1150,8 +497,8 @@ typedef unsigned char png_byte; */ /* MSC Medium model */ -#if defined(FAR) -# if defined(M_I86MM) +#ifdef FAR +# ifdef M_I86MM # define USE_FAR_KEYWORD # define FARDATA FAR # include @@ -1169,30 +516,37 @@ typedef unsigned char png_byte; #endif /* Typedef for floating-point numbers that are converted - to fixed-point with a multiple of 100,000, e.g., int_gamma */ + * to fixed-point with a multiple of 100,000, e.g., gamma + */ typedef png_int_32 png_fixed_point; /* Add typedefs for pointers */ -typedef void FAR * png_voidp; -typedef png_byte FAR * png_bytep; -typedef png_uint_32 FAR * png_uint_32p; -typedef png_int_32 FAR * png_int_32p; -typedef png_uint_16 FAR * png_uint_16p; -typedef png_int_16 FAR * png_int_16p; -typedef PNG_CONST char FAR * png_const_charp; -typedef char FAR * png_charp; -typedef png_fixed_point FAR * png_fixed_point_p; - -#ifndef PNG_NO_STDIO -#if defined(_WIN32_WCE) -typedef HANDLE png_FILE_p; -#else -typedef FILE * png_FILE_p; -#endif +typedef void FAR * png_voidp; +typedef PNG_CONST void FAR * png_const_voidp; +typedef png_byte FAR * png_bytep; +typedef PNG_CONST png_byte FAR * png_const_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef PNG_CONST png_uint_32 FAR * png_const_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef PNG_CONST png_int_32 FAR * png_const_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef PNG_CONST png_uint_16 FAR * png_const_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST png_int_16 FAR * png_const_int_16p; +typedef char FAR * png_charp; +typedef PNG_CONST char FAR * png_const_charp; +typedef png_fixed_point FAR * png_fixed_point_p; +typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p; +typedef png_size_t FAR * png_size_tp; +typedef PNG_CONST png_size_t FAR * png_const_size_tp; + +#ifdef PNG_STDIO_SUPPORTED +typedef FILE * png_FILE_p; #endif #ifdef PNG_FLOATING_POINT_SUPPORTED -typedef double FAR * png_doublep; +typedef double FAR * png_doublep; +typedef PNG_CONST double FAR * png_const_doublep; #endif /* Pointers to pointers; i.e. arrays */ @@ -1211,273 +565,32 @@ typedef double FAR * FAR * png_doublepp; /* Pointers to pointers to pointers; i.e., pointer to array */ typedef char FAR * FAR * FAR * png_charppp; -#if defined(PNG_1_0_X) || defined(PNG_1_2_X) -/* SPC - Is this stuff deprecated? */ -/* It'll be removed as of libpng-1.3.0 - GR-P */ -/* libpng typedefs for types in zlib. If zlib changes - * or another compression library is used, then change these. - * Eliminates need to change all the source files. - */ -typedef charf * png_zcharp; -typedef charf * FAR * png_zcharpp; -typedef z_stream FAR * png_zstreamp; -#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */ - -/* - * Define PNG_BUILD_DLL if the module being built is a Windows - * LIBPNG DLL. - * - * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. - * It is equivalent to Microsoft predefined macro _DLL that is - * automatically defined when you compile using the share - * version of the CRT (C Run-Time library) - * - * The cygwin mods make this behavior a little different: - * Define PNG_BUILD_DLL if you are building a dll for use with cygwin - * Define PNG_STATIC if you are building a static library for use with cygwin, - * -or- if you are building an application that you want to link to the - * static library. - * PNG_USE_DLL is defined by default (no user action needed) unless one of - * the other flags is defined. - */ - -#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) -# define PNG_DLL -#endif -/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. - * When building a static lib, default to no GLOBAL ARRAYS, but allow - * command-line override - */ -#if defined(__CYGWIN__) -# if !defined(PNG_STATIC) -# if defined(PNG_USE_GLOBAL_ARRAYS) -# undef PNG_USE_GLOBAL_ARRAYS -# endif -# if !defined(PNG_USE_LOCAL_ARRAYS) -# define PNG_USE_LOCAL_ARRAYS -# endif -# else -# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) -# if defined(PNG_USE_GLOBAL_ARRAYS) -# undef PNG_USE_GLOBAL_ARRAYS -# endif -# endif -# endif -# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) -# define PNG_USE_LOCAL_ARRAYS -# endif -#endif - -/* Do not use global arrays (helps with building DLL's) - * They are no longer used in libpng itself, since version 1.0.5c, - * but might be required for some pre-1.0.5c applications. - */ -#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) -# if defined(PNG_NO_GLOBAL_ARRAYS) || (defined(__GNUC__) && defined(PNG_DLL)) -# define PNG_USE_LOCAL_ARRAYS +/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, + * and no smaller than png_uint_32. Casts from png_size_t or png_uint_32 + * to png_alloc_size_t are not necessary; in fact, it is recommended + * not to use them at all so that the compiler can complain when something + * turns out to be problematic. + * Casts in the other direction (from png_alloc_size_t to png_size_t or + * png_uint_32) should be explicitly applied; however, we do not expect + * to encounter practical situations that require such conversions. + */ +#if defined(__TURBOC__) && !defined(__FLAT__) + typedef unsigned long png_alloc_size_t; +#else +# if defined(_MSC_VER) && defined(MAXSEG_64K) + typedef unsigned long png_alloc_size_t; # else -# define PNG_USE_GLOBAL_ARRAYS -# endif -#endif - -#if defined(__CYGWIN__) -# undef PNGAPI -# define PNGAPI __cdecl -# undef PNG_IMPEXP -# define PNG_IMPEXP -#endif - -/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", - * you may get warnings regarding the linkage of png_zalloc and png_zfree. - * Don't ignore those warnings; you must also reset the default calling - * convention in your compiler to match your PNGAPI, and you must build - * zlib and your applications the same way you build libpng. - */ - -#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) -# ifndef PNG_NO_MODULEDEF -# define PNG_NO_MODULEDEF -# endif -#endif - -#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) -# define PNG_IMPEXP -#endif - -#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ - (( defined(_Windows) || defined(_WINDOWS) || \ - defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) - -# ifndef PNGAPI -# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) -# define PNGAPI __cdecl -# else -# define PNGAPI _cdecl -# endif -# endif - -# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ - 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) -# define PNG_IMPEXP -# endif - -# if !defined(PNG_IMPEXP) - -# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol -# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol - - /* Borland/Microsoft */ -# if defined(_MSC_VER) || defined(__BORLANDC__) -# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) -# define PNG_EXPORT PNG_EXPORT_TYPE1 -# else -# define PNG_EXPORT PNG_EXPORT_TYPE2 -# if defined(PNG_BUILD_DLL) -# define PNG_IMPEXP __export -# else -# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in - VC++ */ -# endif /* Exists in Borland C++ for - C++ classes (== huge) */ -# endif -# endif - -# if !defined(PNG_IMPEXP) -# if defined(PNG_BUILD_DLL) -# define PNG_IMPEXP __declspec(dllexport) -# else -# define PNG_IMPEXP __declspec(dllimport) -# endif -# endif -# endif /* PNG_IMPEXP */ -#else /* !(DLL || non-cygwin WINDOWS) */ -# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) -# ifndef PNGAPI -# define PNGAPI _System -# endif -# else -# if 0 /* ... other platforms, with other meanings */ -# endif -# endif -#endif - -#ifndef PNGAPI -# define PNGAPI -#endif -#ifndef PNG_IMPEXP -# define PNG_IMPEXP -#endif - -#ifdef PNG_BUILDSYMS -# ifndef PNG_EXPORT -# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END -# endif -# ifdef PNG_USE_GLOBAL_ARRAYS -# ifndef PNG_EXPORT_VAR -# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT + /* This is an attempt to detect an old Windows system where (int) is + * actually 16 bits, in that case png_malloc must have an argument with a + * bigger size to accomodate the requirements of the library. + */ +# if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \ + (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL) + typedef DWORD png_alloc_size_t; +# else + typedef png_size_t png_alloc_size_t; # endif # endif #endif -#ifndef PNG_EXPORT -# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol -#endif - -#ifdef PNG_USE_GLOBAL_ARRAYS -# ifndef PNG_EXPORT_VAR -# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type -# endif -#endif - -/* User may want to use these so they are not in PNG_INTERNAL. Any library - * functions that are passed far data must be model independent. - */ - -#ifndef PNG_ABORT -# define PNG_ABORT() abort() -#endif - -#ifdef PNG_SETJMP_SUPPORTED -# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) -#else -# define png_jmpbuf(png_ptr) \ - (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) -#endif - -#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ -/* use this to make far-to-near assignments */ -# define CHECK 1 -# define NOCHECK 0 -# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) -# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) -# define png_strcpy _fstrcpy -# define png_strncpy _fstrncpy /* Added to v 1.2.6 */ -# define png_strlen _fstrlen -# define png_memcmp _fmemcmp /* SJT: added */ -# define png_memcpy _fmemcpy -# define png_memset _fmemset -#else /* use the usual functions */ -# define CVT_PTR(ptr) (ptr) -# define CVT_PTR_NOCHECK(ptr) (ptr) -# define png_strcpy strcpy -# define png_strncpy strncpy /* Added to v 1.2.6 */ -# define png_strlen strlen -# define png_memcmp memcmp /* SJT: added */ -# define png_memcpy memcpy -# define png_memset memset -#endif -/* End of memory model independent support */ - -/* Just a little check that someone hasn't tried to define something - * contradictory. - */ -#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) -# undef PNG_ZBUF_SIZE -# define PNG_ZBUF_SIZE 65536L -#endif - -#ifdef PNG_READ_SUPPORTED -/* Prior to libpng-1.0.9, this block was in pngasmrd.h */ -#if defined(PNG_INTERNAL) - -/* These are the default thresholds before the MMX code kicks in; if either - * rowbytes or bitdepth is below the threshold, plain C code is used. These - * can be overridden at runtime via the png_set_mmx_thresholds() call in - * libpng 1.2.0 and later. The values below were chosen by Intel. - */ - -#ifndef PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT -# define PNG_MMX_ROWBYTES_THRESHOLD_DEFAULT 128 /* >= */ -#endif -#ifndef PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT -# define PNG_MMX_BITDEPTH_THRESHOLD_DEFAULT 9 /* >= */ -#endif - -/* Set this in the makefile for VC++ on Pentium, not here. */ -/* Platform must be Pentium. Makefile must assemble and load pngvcrd.c . - * MMX will be detected at run time and used if present. - */ -#ifdef PNG_USE_PNGVCRD -# define PNG_HAVE_ASSEMBLER_COMBINE_ROW -# define PNG_HAVE_ASSEMBLER_READ_INTERLACE -# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW -#endif - -/* Set this in the makefile for gcc/as on Pentium, not here. */ -/* Platform must be Pentium. Makefile must assemble and load pnggccrd.c . - * MMX will be detected at run time and used if present. - */ -#ifdef PNG_USE_PNGGCCRD -# define PNG_HAVE_ASSEMBLER_COMBINE_ROW -# define PNG_HAVE_ASSEMBLER_READ_INTERLACE -# define PNG_HAVE_ASSEMBLER_READ_FILTER_ROW -#endif -/* - see pnggccrd.c for info about what is currently enabled */ - -#endif /* PNG_INTERNAL */ -#endif /* PNG_READ_SUPPORTED */ - -/* Added at libpng-1.2.8 */ -#endif /* PNG_VERSION_INFO_ONLY */ - #endif /* PNGCONF_H */ diff --git a/doomsday/external/libpng/portable/include/pnglibconf.h b/doomsday/external/libpng/portable/include/pnglibconf.h new file mode 100644 index 0000000000..8022a5a881 --- /dev/null +++ b/doomsday/external/libpng/portable/include/pnglibconf.h @@ -0,0 +1,187 @@ + +/* libpng STANDARD API DEFINITION */ + +/* pnglibconf.h - library build configuration */ + +/* libpng version 1.5.4 - last changed on June 22, 2011 */ + +/* Copyright (c) 1998-2011 Glenn Randers-Pehrson */ + +/* This code is released under the libpng license. */ +/* For conditions of distribution and use, see the disclaimer */ +/* and license in png.h */ + +/* pnglibconf.h */ +/* Derived from: scripts/pnglibconf.dfa */ +/* If you edit this file by hand you must obey the rules expressed in */ +/* pnglibconf.dfa with respect to the dependencies between the following */ +/* symbols. It is much better to generate a new file using */ +/* scripts/libpngconf.mak */ + +#ifndef PNGLCONF_H +#define PNGLCONF_H +/* settings */ +#define PNG_API_RULE 0 +#define PNG_CALLOC_SUPPORTED +#define PNG_COST_SHIFT 3 +#define PNG_DEFAULT_READ_MACROS 1 +#define PNG_GAMMA_THRESHOLD_FIXED 5000 +#define PNG_MAX_GAMMA_8 11 +#define PNG_QUANTIZE_BLUE_BITS 5 +#define PNG_QUANTIZE_GREEN_BITS 5 +#define PNG_QUANTIZE_RED_BITS 5 +#define PNG_sCAL_PRECISION 5 +#define PNG_USER_CHUNK_CACHE_MAX 0 +#define PNG_USER_CHUNK_MALLOC_MAX 0 +#define PNG_USER_HEIGHT_MAX 1000000 +#define PNG_USER_WIDTH_MAX 1000000 +#define PNG_WEIGHT_SHIFT 8 +#define PNG_ZBUF_SIZE 8192 +/* end of settings */ +/* options */ +#define PNG_16BIT_SUPPORTED +#define PNG_ALIGN_MEMORY_SUPPORTED +#define PNG_BENIGN_ERRORS_SUPPORTED +#define PNG_bKGD_SUPPORTED +#define PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED +#define PNG_CHECK_cHRM_SUPPORTED +#define PNG_cHRM_SUPPORTED +#define PNG_CONSOLE_IO_SUPPORTED +#define PNG_CONVERT_tIME_SUPPORTED +#define PNG_EASY_ACCESS_SUPPORTED +/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ +#define PNG_ERROR_TEXT_SUPPORTED +#define PNG_FIXED_POINT_SUPPORTED +#define PNG_FLOATING_ARITHMETIC_SUPPORTED +#define PNG_FLOATING_POINT_SUPPORTED +#define PNG_gAMA_SUPPORTED +#define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +#define PNG_hIST_SUPPORTED +#define PNG_iCCP_SUPPORTED +#define PNG_INCH_CONVERSIONS_SUPPORTED +#define PNG_INFO_IMAGE_SUPPORTED +#define PNG_IO_STATE_SUPPORTED +#define PNG_iTXt_SUPPORTED +#define PNG_MNG_FEATURES_SUPPORTED +#define PNG_oFFs_SUPPORTED +#define PNG_pCAL_SUPPORTED +#define PNG_pHYs_SUPPORTED +#define PNG_POINTER_INDEXING_SUPPORTED +#define PNG_PROGRESSIVE_READ_SUPPORTED +#define PNG_READ_16BIT_SUPPORTED +#define PNG_READ_ALPHA_MODE_SUPPORTED +#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_READ_BACKGROUND_SUPPORTED +#define PNG_READ_BGR_SUPPORTED +#define PNG_READ_bKGD_SUPPORTED +#define PNG_READ_cHRM_SUPPORTED +#define PNG_READ_COMPOSITE_NODIV_SUPPORTED +#define PNG_READ_COMPRESSED_TEXT_SUPPORTED +#define PNG_READ_EXPAND_16_SUPPORTED +#define PNG_READ_EXPAND_SUPPORTED +#define PNG_READ_FILLER_SUPPORTED +#define PNG_READ_gAMA_SUPPORTED +#define PNG_READ_GAMMA_SUPPORTED +#define PNG_READ_GRAY_TO_RGB_SUPPORTED +#define PNG_READ_hIST_SUPPORTED +#define PNG_READ_iCCP_SUPPORTED +#define PNG_READ_INTERLACING_SUPPORTED +#define PNG_READ_INT_FUNCTIONS_SUPPORTED +#define PNG_READ_INVERT_ALPHA_SUPPORTED +#define PNG_READ_INVERT_SUPPORTED +#define PNG_READ_iTXt_SUPPORTED +#define PNG_READ_oFFs_SUPPORTED +#define PNG_READ_OPT_PLTE_SUPPORTED +#define PNG_READ_PACK_SUPPORTED +#define PNG_READ_PACKSWAP_SUPPORTED +#define PNG_READ_pCAL_SUPPORTED +#define PNG_READ_pHYs_SUPPORTED +#define PNG_READ_QUANTIZE_SUPPORTED +#define PNG_READ_RGB_TO_GRAY_SUPPORTED +#define PNG_READ_sBIT_SUPPORTED +#define PNG_READ_SCALE_16_TO_8_SUPPORTED +#define PNG_READ_sCAL_SUPPORTED +#define PNG_READ_SHIFT_SUPPORTED +#define PNG_READ_sPLT_SUPPORTED +#define PNG_READ_sRGB_SUPPORTED +#define PNG_READ_STRIP_16_TO_8_SUPPORTED +#define PNG_READ_STRIP_ALPHA_SUPPORTED +#define PNG_READ_SUPPORTED +#define PNG_READ_SWAP_ALPHA_SUPPORTED +#define PNG_READ_SWAP_SUPPORTED +#define PNG_READ_tEXt_SUPPORTED +#define PNG_READ_TEXT_SUPPORTED +#define PNG_READ_tIME_SUPPORTED +#define PNG_READ_TRANSFORMS_SUPPORTED +#define PNG_READ_tRNS_SUPPORTED +#define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_READ_USER_CHUNKS_SUPPORTED +#define PNG_READ_USER_TRANSFORM_SUPPORTED +#define PNG_READ_zTXt_SUPPORTED +#define PNG_SAVE_INT_32_SUPPORTED +#define PNG_sBIT_SUPPORTED +#define PNG_sCAL_SUPPORTED +#define PNG_SEQUENTIAL_READ_SUPPORTED +#define PNG_SET_CHUNK_CACHE_LIMIT_SUPPORTED +#define PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED +#define PNG_SETJMP_SUPPORTED +#define PNG_SET_USER_LIMITS_SUPPORTED +#define PNG_sPLT_SUPPORTED +#define PNG_sRGB_SUPPORTED +#define PNG_STDIO_SUPPORTED +#define PNG_tEXt_SUPPORTED +#define PNG_TEXT_SUPPORTED +#define PNG_TIME_RFC1123_SUPPORTED +#define PNG_tIME_SUPPORTED +#define PNG_tRNS_SUPPORTED +#define PNG_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_USER_CHUNKS_SUPPORTED +#define PNG_USER_LIMITS_SUPPORTED +#define PNG_USER_MEM_SUPPORTED +#define PNG_USER_TRANSFORM_INFO_SUPPORTED +#define PNG_USER_TRANSFORM_PTR_SUPPORTED +#define PNG_WARNINGS_SUPPORTED +#define PNG_WRITE_16BIT_SUPPORTED +#define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#define PNG_WRITE_BGR_SUPPORTED +#define PNG_WRITE_bKGD_SUPPORTED +#define PNG_WRITE_cHRM_SUPPORTED +#define PNG_WRITE_COMPRESSED_TEXT_SUPPORTED +#define PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED +#define PNG_WRITE_FILLER_SUPPORTED +#define PNG_WRITE_FILTER_SUPPORTED +#define PNG_WRITE_FLUSH_SUPPORTED +#define PNG_WRITE_gAMA_SUPPORTED +#define PNG_WRITE_hIST_SUPPORTED +#define PNG_WRITE_iCCP_SUPPORTED +#define PNG_WRITE_INTERLACING_SUPPORTED +#define PNG_WRITE_INT_FUNCTIONS_SUPPORTED +#define PNG_WRITE_INVERT_ALPHA_SUPPORTED +#define PNG_WRITE_INVERT_SUPPORTED +#define PNG_WRITE_iTXt_SUPPORTED +#define PNG_WRITE_oFFs_SUPPORTED +#define PNG_WRITE_OPTIMIZE_CMF_SUPPORTED +#define PNG_WRITE_PACK_SUPPORTED +#define PNG_WRITE_PACKSWAP_SUPPORTED +#define PNG_WRITE_pCAL_SUPPORTED +#define PNG_WRITE_pHYs_SUPPORTED +#define PNG_WRITE_sBIT_SUPPORTED +#define PNG_WRITE_sCAL_SUPPORTED +#define PNG_WRITE_SHIFT_SUPPORTED +#define PNG_WRITE_sPLT_SUPPORTED +#define PNG_WRITE_sRGB_SUPPORTED +#define PNG_WRITE_SUPPORTED +#define PNG_WRITE_SWAP_ALPHA_SUPPORTED +#define PNG_WRITE_SWAP_SUPPORTED +#define PNG_WRITE_tEXt_SUPPORTED +#define PNG_WRITE_TEXT_SUPPORTED +#define PNG_WRITE_tIME_SUPPORTED +#define PNG_WRITE_TRANSFORMS_SUPPORTED +#define PNG_WRITE_tRNS_SUPPORTED +#define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +#define PNG_WRITE_USER_TRANSFORM_SUPPORTED +#define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#define PNG_WRITE_zTXt_SUPPORTED +#define PNG_zTXt_SUPPORTED +/* end of options */ +#endif /* PNGLCONF_H */ diff --git a/doomsday/external/libpng/win32/libpng13.dll b/doomsday/external/libpng/win32/libpng13.dll deleted file mode 100644 index 6e0d4ab4a3d37ee217b7fbd3cc13f941fda01a36..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 135168 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 I4>|CE0OHRPg8%>k diff --git a/doomsday/external/libpng/win32/libpng13.lib b/doomsday/external/libpng/win32/libpng13.lib deleted file mode 100644 index 4f77d60204b8c4eed1ce5df80c56deeeac2ce1fd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 45914 zcmeHQYmi+TmbEd-du)`!A?A`-d0q@#UHNXZGyg`Mq;yAJ#KR^AAmevk#p=-$t$4 zgJ_pqh)&)@bm~h)r@c#b`m2`CSV&~(2|Ph(&PeD=JV9qoOXx3ng3cbWR9Qj9v}#d8 z+wlZd53tm?iOA63@C5a*O6YYwK?7SY)ut0M4I9RA4484IT=yH@B(-jva^d~$)SDum(%H&GWRghuY{8vj? zqa83^gR*A2c1A**@nnJ=(-z1WLK$rVU5EEK^g5oP>rwB9UcwV}!&eh}5l_&K2Pbqp zo}im{PY7w>1iBgJV+eJ5Gw7Bj2|bS|=+>DD-H0dCKP=tWCNlH~JVCdwNC@w6JLrx_ zEZw;;ks-99J3)7$Tn#nxWcsb8yN@L@gm=Chbk9Kv-HRva-Wds9jwciP1=D?N5<*_? z1KmHE5YoLL^Z?Q|^a7rs2WKUOcJm<9dzKzTehmE%PtaDBv!R#q1U-y8VtNGcVF-2f z2-CZk9z{7C`Zb=Q$Bsw{x{rY#f6USoz&C`ld;;_&>cbH7^d!^UmbMKL8AAKq26}2i zLeJm{+KzM#-HIpZ>1hd#})Gd;5`q1W&PJ-2s4oA6}%v!%-)L^}pO+hgf;=rL{D z$I^w{h?ve=XX%dls9(?((=9!_6?&ix7h0;`iSZHCx2L7Ee}nN9RC(RfroSLv&;an5 zF1g;)#oN&jLACP|dK*vBHON2H!*eWM@CN!Z=%Q7YHlV#QZAASrJ>F~S>NnBPKKhWBDENw=4Fpc58n67%n(mJHebkiE9N@eNs%THXfvaB{WmSrXALMLJcRxUaDgySlU4_|pWRO+MSl?wDLeG~POfyz*`y1vz4 z9jR5u@vGggQ9RP?_Yc?lS65o~A*&&RQf6Xob*0v9HkwXKFhaSt)#g}zEKQFkQLePPeo+) z^jk|s9pg1cyGj1^ahy$CDE2QMQ{k-p=p^W6hHCA~(j|*mSP>u663dsZJjzShke28> z?wG}1!iEBgdK(2a-X0cWo~32`m#jG6i`h_CqB2-tR~yiBju%J|SI5R`BP}7DastW5 zNTXS4uOCm!luM*v@IvX)@n)^nsyD_kiVP0cnivK)DAfXi;&ei6pMZ@CHOJRC>qEmy z-?gusvb3yeI+gKu(kWP0u(a%8eWZ=t=$BDUEkAVl@fcINEpxIql$CI`Bjp@VOAjwS zX{Arkh5`u;C3r)OfI?32iln)+@-!@8Yt@fDa=Dkap+I7^I#jC+*K`%s6*o^~ZGAxY z1gnrR1Nkvj#7MOtqS%^W|kj zfy9z;i8RJdD3Cy>9;sAY<26iY&1$>e5Gm%wb3sihFo60IYaiaujQfrP4` zmI(zC7~FlCwM;0GSaHk|Lc)XsiTcnO%AqO7K`f3OOUt&G9xrAV8ww;=oN$uIYnxCY zQCla5zqSc!2`r$-8f(WY{loZ6lw!yav|4CIMnyM>iGZJ@)oxbDT7!+|XpUwOr?uBq zN9tlqOM+TvU8ONN*upS7TJLW*#zcOyF$J3A+>!DWT|}s7`FZ_nT_qc*wbvKEZ#Jet z)4i6PI8sFy5$a{%$*X4Ly!L2yWTeq=+nf7a#MVap$Je7xV8NfrD2|fk8q$)2<0Uav zjba^C8y#=2uZ&~XwF&32g-)~4k7b8g++mOs93`2KYW%xNFfu<$kdb0Y!e#eU?7946v>!SAdzO#Bw|8YiKP8I z5d;I7iE*r+?N&$NDX!Gu>fL}XMXj1_!Z4jkmX~F=Uv>MCmhh`?mIznf%=4>mAJS>` zRr^;DH5(JI292EH1=2&wglWV$pyU0zoCU&lx#PJN9rw797o^wltJ}=_*{Bu?6sI#% zTT>gc)fJ|YL>23f)!v4Z?ju)g?9UV<}^G4YQ0~y${DzhtdDm}a`o$nhG8@N zmRP!HG=sPzZNGfaPeI2AsrbF3uLQA4496!C*JN#y}p7l>n5B$$zb@g!nvc5?t6Ltj(L?ZLBZ4be(%f~3ir;2 zm+qZ?C`bbm+?@kZ-ewDSpp)*mO{&3un|W%;tYAaMW*o5sD2mrON=mflkRNFA?%a1m zKBw?iY5I5=sr9W5UiNLz$&(ZVj%&2ejL*g(GeYI*1+S6?%n=ajp!xQXx}n?!M0~r7 zlOZ!AioF@$HQ;)U^ni(Tkp@J(IfOCh5L=!$mkA?RPV7&GaOMm`#-&@$3^O0WBeWOh-NZka(bO-&q&MGC0P)-!9mCNjT6L#7FWjK=>q$+(in2c)4PR~?>DRXnw zrsA^NZqw{A^sd=*k)kXq6AV*IH_lci*g2=nq&Ld2Psz4AY}_kzES_R`Ijdb4f|}zc ztNq5ffpwZWY8jgt?Q>gzf+(*m?b%$WGVG{aW-X8J zwRkMVdeqzW6vNB;0!orq3@<0jClS;fFKOD0$wwln7+%gDSz_A4@v+TQ$Saa|)vM*1 z>oxk36PQp;ek_L5%8$ut+6?BZhEZPETJCV%I9Qz+NpcnPyfmMiYFW+kl8I4n6wPQ5 z`GSeNWs58~!t0HWuB)^r#>X2xC~+fH3@^uLXVundWpJcAG+J#XHpVPBUn6-JDGrvG z<;LeyPhb)F3VOJ3S33SSpco$IbRYZT?j54?y z?|lu*@mk~^^jFZTEqEu;^6OAupvBjt>_K0>f#^lh!8gK}5w!bFkO%eMjC_KYz{mJ` z(9B!mQwjP9sC^sJA3!T^M;f3Ym0y9;>&{T6iW-AEgB&^^dAXvV!L2hiU^ zYwiOMXz+f>f{uNF=mpTM2T?Yl_dxB3h<*oJzLn@@(6)z>27J~wgWd)8JxcUz&=HRz z9`xAb(0>B&3EKThV1eES4QxYsf)+f5`UcI~4!=&&w5Q?c3;Hc+*)v41f%bk5Z42~g z(1R%Bo@WtLh$ZHd)%`R^>;SPwt_Yb*`5LTsG{z+ zUku+|w9B_a3s5I>kcT%eKz*Qo4?;Vbu@Uu#_kI&~_SQPoJ?ifrw3WT_e0>aMi#lBe z{u_^A{TqFVzD>{5bowxTg!ZBr zX>a-{eV=|n`_RW|27R3NrBBd)^hx>@eVS&{{xpj|LkG}j>2q`-9YjB)&(p#51^Oa= zi4LJJ)1fq*=FnW~p?TCxU!nPQ7=4w#Mhobt^mF3eh>Eu-V<1UiwH)8q6EeUnzuNwktqrZ?zydW}w@ zQ|VRu4?2y$MW@plbS9leXH$h%QI-0rp9ZK#gY+g1(J*#vA zfo`Om=w|vc-9oq0ZFD=`L3h$!bT{2Y_tJfIKRrMX(nGYB9;PSgS$c#XrN{oiM*h#$ z$gY^~ z{>$}2cJ~mE&E1vA4MdK*jMn-c_>=k!xowiz3rSEHoz1I`3Em`eRh925Q#Gr1$%r_K z`d2O5|M2R~o?Cla=7nd|%yT;pyN}WGE>3MvSZN22qdJxF{FxJAUe+FNVzBqHKA=G= zoqKnN3HU?o9k^&}MZ2>yzGgZiIeW}YEIdQxoaLVva!hzCXLzN3B=t+}*!wY%H$IR> zE{$f#6DXtyet8++u>+${Ej(=FtQR{ZYF*?{|gX{tbV zog@JmQNecAMvckJ0pUeyRsO+YP3koB-8nu}h zE*A|ixC&x;#-qmNLRrQ6!%T)J}AoAOdST*?s^IL|9s73T@)i?RKU^!~FG7M3>0 zQZ_cnv}-vTa?`5gd9QaafMH=vOC?gCzG>{e;aSsc@(S(^CpI&epgdJKs_9xz=i6Dx zoSxiwJDzt)=ajtjxe4j3xj9#DT`JiNbZLxm0aur3^DJIY$=kXFM>IO`r_8VEeUeSc zEK;1FU7n;NZ^v>h?=s8E)^?S~rEaYpm)fgbv~|D8cr8fBjiOtoehsL~#7x%GB9%hr z*rHUNutGV$a5Cf9Pc2KucSN1d$)%8IZE|s`9VwGs8WSdm%Z%odX?SNe$Ew6AW*F5D zYZzUeM_$;Lo%M({6YEfFHxfMIN~CN>Mx-{%t6X_QQ`(1EB*!u&*xDv!B9t{K;S^uL zG!sPXl4?T2snmv3=g}nS{5;d3n=(8Ds|1EN4E!NNW?hiR*}Xv;RJI(;M%8kPNq zWxRzZ>qg{!nm83d`EbZjJ{%IBQ6@=dB|dP;Aiz?7<}o2*k8w)I65|4X9%Auu9x^;( zP}$+#!*Z7bQ*e>Av$EvHVbYIW_EVOXR9)Q0b3A8FabY{#@d`iX%>ZA!oyIs{S&T=M-GS60@x7=CZEy8Ny28Qa6HT z4zk}k$RrYMCRMyQJor{7=XmjH9?q;EYdGX5bQ4NHN?}6jgl` z?@1+6yMpEfS6|R6aoflCp{&=dx;~e8UB|C5`2GC~!-d4H8uuFZixnC6=q=BiDhMajQOQgCG?oh5~?yX0Zg zHx`0GDsz)V%&s;aUmiYOd<(HM1pTaho+*)`AXxrYpl zjIdAZj=sX$bJ$_Y_gGi$v22%JY0ZxwJ?ca7&D)*K&n|}y)cPid4mimM2|jV~jdX$J zxrnA8aY&uFx(Cd0QG4T$Ux5B6VeE?MB0BWtM6Nes!^aPPfWUKd%wI$^U!I2NUhoLy zpFL%!4x+uLzaLCakbn3^4}9$-$MaWBT8+W>%!5{Ze&({JCmd&D!(V%X!J3=`!S#^; znvUP^Gk-}Oyape#;C&B#Z6p2jpAM0A_=jI`8o6vQg4ZTyKo+~JB zj@-}WkLYJTj?Z%cnZ+$Ki%PJLk$dJR%_uph>1$Fp2pzfB7oEW+l ztPGTCv-7@^-*P?+#BCv}u%b&G>O8LzRGx%wDPva=*yyJYl@|;W)$C{z>w1@{ZYdSC zr~`rcd@(AFF2x^$!PH}q*N|~o?OaeBy;@m~1 zzZ2~@QnnvR(Q-cht6*iIOxeap2wuXP8g(Z_g$=l4)VcX11TRc+g-E03HKEQ&hk5yk zp8?vp^AW@5(>Z2A`{7>t!4R{!yL61()03aq8NlRSkf~F9QYR};jSXemPESECehe5N zayaG~P{DMbpMsvjD-qsOnf&-eMg=AVW%4wyV6Of&aK5Xtk`qjc(0Q-#DVViB0jv)@ zJU%foChDof`iR6b2Jr5%=0*A&@8V3IalV`_-JI=qi5Xef{U8ssrJB47lxZumy4y?Q znZtpp%Ny@#)AGcJ^^!wx1tk~`c?C23EMOTU5?gzDRF&={T_MKCINqJ7 zIW#9}3aaCIJ~j^U{Hw4gWgLj*Zl**u2YFMMJ09uM+zGFpE)fgX7Q7GV7L$W$e1f_| zjg={{wo_Dd9NHaLY?X0(wVTrX9V^3sVeyBor_m8{7i}lLc0baMQH-^QB*=b!G_mip1 z7axRrEOu_0IxIdE^jPdVGj&*eQ0cMQF{eAM^!PcjvCjk!pSgRi)Q?vI%0QW37i%A1 zk$A?1N2cC+KZ{|_S6KXo-l@YnOkuHub9Y#=bHq0!mUEw0a57M)#$sr1Wzg^y0STZ2 z-J-poMGKC4By=gX$SRPXMbg%<{K2{%BV#9rUsI^sXI%rDm>y9tPGSX z;n*y@AcN|iO7CJmh_EW+~itrtY zQbC(#`{@%7$s$a~zQ5ocjBW6X9a?f-NM)<@Q9WYQctInjUz6?CH9F%B(z z!A!z*+{a_H`%5*VoioWS;W)grxMFw*H#57 z1EtzY1n-9mFTD#cAyh4v!Hd<~$r5iee90m^g;Nxkzs9aI*LkZfSZ(s|?o@?{&lM^t z8R)hgPm@Sf?6>x<5NlHWRbpOUrz=Ep#b16sKo+Me=rUy+^TR)*2;F{~pgY_Gj|)EY zJ+lbc|1;$7unXo3KC?fo7~A|GWd+=EpXn{=rF^P>b`dgs6^h+7t;l*;-ukh@5IJ!gY zEwFg8pTsY+Xqm5kbcY_x>wrX0z9BMoXte;1|KE3aXtD8kFpDO?f1-e8piF;^o!ks5 zT=Q`inY_wzDXhp&ZdhVXvA=0O#F~`(J64kCC`9wsnXXDQW^G%ou!2w8bcb3nSF^wA zNCq|eUQSntv6b_vM4SX4-Wb-H#F_-(*4U|DLt&+UnCXXvRDpK9@`zcbp3=yZaaLO} zU$C$6c!1`=fz)LVBdzq@98B|tB?T!1WyZCbRk$e;^FH4s!6tP?ZAs)Q_B?G%tSR<9 zolscad!EL6#2ST_d^M}98jGzD*M?~3|FkQ(&ii}8oXg(q>olJF;8%C3u^zErp$gwt zbE1GxLMdn&DAN~XwYfnePYzn7bT?+u{D;tFt~%e*#Ac84GN}49Yh5B2jOV=mKR+MY zJ2!<@+j(1#jO-UEbn%Hem0=ku)0$$d@(T+P^A?kx;>Ok@n-ng8WM8JopNChbaWpWsslYf*&)L)^LU>%oj zY=qgYkogmr3aayREwHTa51gw*tmGeXbcYzr-8B+%ihcX9Rao8o_RlM@6SEi5mJrK- zT2vLL43uf3v9i2QVRnC?AZE+FUScUPc>jM>WZpWTbz|P}Hx#0GJJ-kVn7^h_*#|%Q zqN~cN43w$S*r;=32GK7T&F4`im>L(#AjfuEH%Vmsb)N25rv|aa*?Vh>o_wRXE2NmW%xx)B_yJ%A+3{Qw%iZk`b5gz{7~8ep zks|qjMWiZ91VYhp`bxLV zS?8;OSUw*Nkwb^nj`JCt5g*N>g)XU+iuX(oUf`74FS^XErm00DV%uG#f3NDI{k(d2M!!CT%$g@ ze*b>ef32x7|0W;hsJH|1$w%#9F;{;3Rm{Qfs&@({z51{7E5=H?w_>LJ_OI~EZ;t-W zQ@=B>uO!ZNH7N5r9FubTJB)R|KuG=Ta5#_HH^=R8jD|#7Ra&4a$KmiI%s)PLnDXL3 z^VhLBPhhT}=W;kD2Y^z>{8iD#g?Wy9h6120&rwFWX?YG8iuU?9C(rTXK!>C7HJ5|n z+5Q_dInNOV%jy1|=)Yl}|GKKGarL@hDF7dKI64FldER3ni-!SAnMi#S1q#9aiF2o4 z>%Z3FIOt}iZ-O-D;J26-mH1bTloJ)0!`%<*#Y$F=6}{kEPn@X$FC73l$Vh0mrhuDU zHTQaei0mLkf!ovzuK2{cH_W~jfKvwp7&3Jf;L)`L{C2nkHr@udPO-Nt41R_n2*{nM9;V!kEiazBk$l`M{LY7 z2nBwP+$SdDvCECL&>%eSdKA$MjzsQRELJuakNC%UTrv}nCojfh(-6S@aTMU*T7bt( zBa!CD{4RF!WIXOILiD)ryH5-q9 zpQ7x^=OS(Pfp{EqCLYfpgS65C$gO1V#p{rE8j;TYBSH@tNPEwN=m3U%2jQ`qgbqCg zxt~#pb+hmoH5`w7PD9!$zr)W|SB};N`5_AWB&%om`4;}{*?y2kWc#|0`$ideyMD&)=Pf^;4Aox3L^j3eswS9o-u|!%$1kW+LmGbkyjNJEVz@M-RfAHhcx)afn zIe@$U+X$^=qno`M8Grv59*g!xM&w+iE!&7k_W_6wT7u9_HopywUPMB7GxP^q@g}TV z#I86DkDt@pmk{av)u4MR?e99`tC@kcd92pO0ff%}J90NNZ4R*mtY-_3~LO!MAy8A7=<*5}{HBm5&g9%#bjzI*XF{s}zt zXxWRY{XZX$&{M4WF9^J79`GGA457(i!y}IwQ8xB-7`mEV&CJ8Y#kO@)G0M&wfsEfg zgXpw<5jvf4-^oSvh?9{!=_o|+VQajfSR&^jt%TBe^$~!4_9~)}9EZom5oSZd5_X<9@v7=Z4cnFZ6KoOeGiXUD7s;^x~2a>#$~L>AR?Gar{$+{T|{c{T#e`f z&mnXONg8Z)chlkJu~j^!aYvwTsjnwpVGH~wm(1)eh!b#PvLRv zDR_K;5*~k`|6BYlLeCz6$0}C(2%5mSSMc}?ebau#x0X%v5{AA$0B{TFxX;JZV{GMg zMDLbP|R5)29IPj|d(=rDv_* zgwU-=AmdNJM<~eNs=acOi5QyU%y-M5tm5LT`A%__KA0zV=I$4UmJQsfy}%k#^)|02xS|Tt;mj^<6x! zege@jJ?6@}h%TqKU;Y6?jbj}S8M^F!?3KV?3G9`?UJ2}#z+MULmB9Zr2~-%Jb)Bsa zhvVW)E{&`$?(Xhhg8{#znf3VRqk$T?quLoiDNvK|UNE?F)E1Z5@VU#P6F=d z+KLQ^=fT!MH0LN^zESE9)s4z=IIg++in{egTGSamWM_A`@z<;VUzUOqelQ?Z{EQ+$ zrziON@s#2`@2S5D`##;^+Y#R2d%tXh?}Kk_@cr|=4ZfWNH~2mru)+7yAsc)j4+zwF z-M8=4=JUEyI=(NWIaPUq_U`yNu-yN437%~D@^gLOK$rXWeVYk4(w86hp@!ZvqclG< zW#Epb&OWaFi>$N?Qs<#?lie6PEE>gA}ZQTpkrFGV-M+udEao{Xc; zNB>jRIdZ-O(r`opzXLTPiJb_~x#h-ds%GAJ%eDUMxi@^lVPt0gp@LPAaSYQ6_2UJcGyXh>89t~1rH}N8{=2`CZhJBk=@w$yXLt#{OhA)_H_%=fWVEP0| z74TtS7lBGU!X?P-66VPhMExujvm55s%L@CJpDBKJf3H<=}ta2XtPX z=Y@KTc1B|`70?XVd3&^^P0Z-4B?-M3O?{n4ePK3Z>Z{GyMT3OeJgY)O5e#fE^bbQ6 z`m5XS$aOgCcJW!=ACLfa#1F7CVZDAcIZ)H(@SkAp)J>(_sBjw#$#0pxCWrT`2^oXZ z`ejp-UaFFW%=NPj5a#7JLd8ypL-95dp|V-d=payrm|;*-g~64DU^?RKDvR!?Gz{}n zjl6jk8uX-p{)d=okBXPD;zns#d9(wZqv|N#27a}Z*0rie**;Axr9v{> z_bkX3-NmX{uhx^BhGJ%UuySVA(J!4-$+)2AVj<`fzu`vh!){SD zTp{7wBsX6gvlf6KjwUMsWUen2uH4GhOeBhy)Z zu;DBCcoRCCqw1K-?1hp&xU$ylYd`4hCAQ@3hP*c$DzX&x6%p2qIPXyQNI$VG;%EtueJ6#Sxy3$0FG12K# zHhJ#fgm-&p8!~~>5x>TCG5bI%=#oTP7(;Xwm5i=Al!~gCKl9N=)N3D`Zi94|UJ<9$9wyn0}Nmg;#mL&=Q zep1|Bx4rw<5WfcZj;JNAgt)dcN|is1fFf0#AQgJdNK=JsX z1=?0CG>M9WW_|x`+*}kQ0GsM&G*!ips#1+KdvE-A1Pqa~ zN(tZLw~Ibe`D|pA{J~QL(wd1=?0C^oWYpU_-piv;eA_y@xkt?=h5a z{LQu9-Klb=+xrw)F%YAovg}Aw_WpYl_p}5uk1u9*S9aee_MrS&f%p#2$pg)WXn_v@ zXc_-u|4WCsuT`ltk zKPF~oBfg7EC^t~4A-2++Hs*=y*?c3D-2V!fV(_Q)Fb#}jT-pUg;`q6=GZ4!|zD#b9 znB~G~k)~E2-5+BIO#Xtc)o3f7uvu5!6>mGWRSbsgp);6+_P^T(lUbkA-upLyhHA&r zTe$}GSh4RJ2tX2T43h#ShmVoTF<9;n)=K~#iZ@) z_0q)pBx~-e|1|)qD_LD}V5zkJaY@PdJm(JVI?5AVh-jN{8wR&Bj@%~0iEV+JZJruV zH*$U31hNp*NoV}c1S(83&uQ~*LNO_~Ny=?9eA{3MV||-+;Y~*AriQYd(3FAE_@4~l zrVSJGqL`6K!@hj_OrmEH!v&K?;2pHV7ahI97t??;MI1rh%`0~JhjPs)UpgP!kx zO<13U9#4g5G;^ZIU?z!VwUCnEj)jy*{*<&@`tvPZEu|P?cU`Y5mE+)r!%;wJNR=bB zLWFOwx^Z`wQ~LC0eF2Dlya?jbUQ?`}AqxX-$f+tJHLS{TsHv1%eY{>}qlopy7VXhg zXqR1~g6LQg?nHYb}Nk|_7e_hF`spPJ zJ=+e{bh~ZCbu*V!2pv@jXd(~!- zWq@W~#ZR>W+O)@ZgujqIwnCUzrQTQ4+K`D*nO1Gi;_zu|v_)Zl4VpO9Rt!m-i{D&ZhY3;ngt{i_qwD0`5(*K;k^slTc z@yx;=c89+IOQ6pa1`hw%lIl-s==xU=Vh)yM%jOi7`@fhp^mvWyv(kU`JTD>s4?`00 z!y$<*B8omPMJzCHj-$HY)_=q&#Y-g9AC8Q{=%Fn*4o{$Ty!kleSkf>i%n1iaOCE>B zDv$9uc5Qu#M7IX{j61jfBU9r`sL=}TzCIlo9h&wuyQe)({}S}s!=5tIuly3|pCI}> z#?+tC$7GuJG&{I4$$9(=d(1zHO;c7CwJEbtvC z@;^$+Kd`;fKZN6J*$xb}UT&0n!#T}`XcAeezHfS-`c@z#O;7zQgiN|FPyH_>1GMQv zw$|1%x77Rk!PpHj)9NLyfN4X_w2-6?VcJkLZIPr6Wm=(`wph{%nKs-^dqC2LGwoP2 zZKh*)0T?l0*3d;v%3hXg?dFgVOu%)-Qaa&Y6y%T{$t>vg^k3M$^}|%rY`A^` zuQ|%7@P-F8JCM<*p=LpEhSYDGsvk~KVd=_0S?EoYMtH6?JIs(&b=OOE4WBZ!b{$hD z#&w)9wsXK`XcNLlMFANF#y%NM(}=R*{}AE7KsbhDQCxCJA)FYsTprH4SI>f85Bn=l z*q@LtpATaw2F{kbqL3^6K(ggIe@F%7{GWIh(}b=ZqzvMaH!!})r2*bA}>p)wCPDu$Yc4i4<<2fznS zz?~ZfQ2dC-b%;?hJd9(k@FF_pP^02lrojK`l%YmNAyIk*IF*C-9&a7TYj@o~xU$~F z{C$NPRnRa67EGlHbGr$XUpHn!clY5aKg!JWw+mJqLMdCt7Lj@rx$+t#AKD zV$bJ8>N4Jy@lugk_vzyJahe&f{y44Q^63c$SDFgOA^{ZK%%WLYVWL)j^XI8w3*%Py zsJ0n3pXfL}^*@$8S}5K>0~9S3FWn(T3&k6C2%%G|5i__$4CXd5lACmWmOKm?t4d3n zbWC}hWjaRxvJ&BhNyiO}#QX*RQ_HCs z{`C}TQ=x5A2RL)pL|?D#K*H-ddBf_yUKf>Ev!ghBriCB6VVO^5TK}IZY+Y}%Rf{tI z3Nf<-P1Bk~J#-CZmYg`nr~`S*nfQC;!6XloN|nsh-o+{i99jF{o-)otzGxMY?@6j6 zf$eVpaH+*%W-Yv`Rje+-@kMq==r*&rfh_3v=ntHU{vbclI#G?UvGti9%`E7RmHM8F z`Ud8Wb}TqvYD@3QQCayIJv>B$Qq*XvzEM0nK3Lobc6AEW3EH%aem#|7i)X=K(s&8u z3DiAFB;%AwnBI3&6nfd%v#0)k$e5z>)Q1o<&B5#Ei92+3=(BRGF}A`u3M;BgSd+wv z1MN7*kK@QNVMq;1D>F)mgmdChERwkVY9?{7Ljwa1B6v1LZnD1F#a-dk51^Gpc zA9Bw^-YLgFEf9fHyc|x;y8Q_~4)Mf)a3N(4t_d*rmt;K#yJkFokJ}d<;Rqq(0}@Lv z4YK%>o?I6Av7?030Yg%vH~K)Y^UhHRwztxma&;1T?E-$Ebq#bZ()@Sb) zxo6?OD1TX&&qn^!zGVGQ{{r~a>X+}jKn7*eyPuPtIM}&0ntXq4Hls<==Ty9+BJFG0 zr)XcVCE8cg`3q+?-v8QJ$T8f3Xm~jitwgorJmDpK)9m;vBEfms7Yqky<7ucT)^z0M z5uSFyZhVAU<=qwe>a4?g;56)u25O?R3ba#Rv5J;QZ(SpmGJMhaX{u!R0hQKCm%(XD zjkQXteaLY!>_dJNiBl8%;QfU+c>ifCfxJNpUk51X zKCmuFJAlanb+8%XJ*fkcN80{d`V%=nR?S^g%mHwQY$Dij_=hK-)LF<>^DxQX&(MIo zXfaQqP_-vpK~I(TlG5u zBZMMfz8~$n3w3nhOc`{T4;?0&*)LHORHFxn4WaF#2dBj=Sl%Io^%kzmj^3c5r^6)AlweDL@SGLNZyY$?_bT?FU13WeY{V z0{`I34%3Y5QEz3&&kARMBxrXO)yqLx74^u!ZkXpbYw#eE~r0-rOE*?xgm z6kY@yutF3C3V~+ag$G}kIEQwqDA65%%Wmc0MPjyACH!O@e^uwjz5}AHUD57r(Is@1Nt(364&~pBH~e;xAdV zpD!lzO6woM8)iDZ5&$RQ^egsV^2RuXN1lsHJFBpmsbk_kI#Js$w8+TB0fnmKKM>&% zOe4$13Fr!UsDX&p5$7(p;lT5SlcSf3TyWCae*wBOR~6oj>kLHsK4JpqbPHzx%Bg0X zoFj?u_~6Q8&7`Yz5)a5~(t%y>`AX!}J^oiB*Z%7SwBc+mEjxLOeAD*-lw3(A)(F5z zHRkEMMYyXtM=Ohl#9~~r?+kD_X1Vy9vvl?sK2FoZu}mFzs%r9J)WQ}KDay{0L>JGH zyYskJrOFPobV0%!Ntop>sGQ}hoc5ZyHw7JiST$1|Ip@0*facN?=f0|7p{?N5q=GkE z1X*dMUw z)=R+Wh<16V-$NV_@J0#=y0B0t#1U6I2a-8SlK4dF6G&uQPb5x-Bz{9LiZ5Bf=WB}F zbE@~RTxPbH6I9LOBaw^tax`kkMI&{-9Qt=+C>b(=9SS)1_x@71WVWuiC}p&PUx<)h zv8RC}MWt{1r6?#?uSg`@r^6)S3F7)oDNY+rs?e2UC+_Sjbdmx#CFAlJsUVssj9ug# zXr_@m(1qk`j#aZ5TshkmOH6rr7A7w6-t@!E8(tPXuF@^l~ZEvXd7=c+W< z$HR;31wy5CN=hxBv0B(`Y$hJib12Cu{wiXnWo4B9agS2GuGksCL5k8+6DD_rGPzhk zMWQ{4#KP=IY!D5)Vw>gN^j;)(EmI2qDY8+E+9VQ(XGh|CP2#rHBtDQz=EwNW7?9YK zM50Ay_9ZBXCNU^Ai9xC%$6j{{iKR&-F3XO@Lyst3JPI5sbaAt;#kUlRO-Up^Qq82V zTAZm#l%yt6ui8`WAVp$F5{YkTN8*p7Pgm@(m}IA@#cWMtC9?7^odN>g0&r~gbgKP+@ zIf=yh>_`MPiEpPS@qL`($51GCogxuUBJqYupieh=q$V*sHHix~37(onEjp4&+?gGT zUyCGMv6p}&MZ36Kx9$fOiLN9PLo5>Gt)fZ8DV+Jhc3rfX*3aLbMU$}eM`GrQ6GUZ}ki*s~JIydHuEqy~NHS;P@=S*I24Bkl4{ zpY!uTGs|Ps_c4Vs(7ay7=}g#QF$!HwkfJ5bsA6L`geKoTR&#e|$SZC#p){5}hWKQ_ zl|`2-7jBgq$*H|N+(3kq$O)a9$gm_5pP9(8BoZlJOq1daBe6H{n~;IJ^yZxzNxXMz z-kD*oJ7B=Q5^=@*Hs!d5IQbnZs}8+*=TbyiCZ+;Od?qBrl1QX#(IVWyaDw-0yf~_7 z?JnW3Ec(ii=qz3FL-k(S!#`x4V|t}~luuf8Xohp$vx^R2z@)|A-Uf%VUOW^Y+x~tf z*UvHeIZZ^sTiB%XR56ssV@`-;d9o9X$2-D7FI4)TYCKr^zCtn#GPJTk7D&KQejK zwgeU*5}hVix<>LH(%xpH5__19N+d2>-J@`^y7xRP{U6Y}=#!_RMW0>hxYtYo1A0F$ zp+5f{kqdkUC0Dd$1)lyZnI^h~;`E-4BoRhlqs6s>gv2e7e5ug91`Ibz@|{^!e6zgO zx*1tTK3OT;j0=_;28ZMtC5;<`%x%yzD+;v(o#$@#nmquRUboJHXW)hIkuQV#*u_*h z&N#N4Q|{Zveq_=t%mSgYkOd=)a#%84+AdrRr==~p^+&CR-S>UfFri4Pg;iUOoLcBZ zaO)O|mq&l}kT%d3Rq&+mnJwBVZ4V2}fHo}*@8)R6fd`yW^U9ux4Vk%8gUQhn6Kx7X zgjG%GGguS;BU&ygNHs)FNa?Y3OijbMZh*`A4;WV#ex}dy}9 zCfqaYPvG!k-JbfYWoCayI_CPTC#bG|>#+vw5+iZN@Ua05|E)FGw(p8bSn&ng$~uB}-L$sDP~tSSHJe--h*d7D*IaaXZY$x9dS^ z3rQo1PPM2HUC~jf-uN2{V=ocT@k$}L3X*{CPXGxa)9;f9Vdg~y%tVGIk^aC;Oxqa% zvUmNZX?f~<*Pj_x_WE~_67Pm1D@pYi6}dC_Ah3mRh@7McvFe}P%>d~B1dy)3>O6YX zUnN@gC$naUWVW6V+efbMr5H}sznY7`YU|A$vK%hf?24bHhb-?lic(qU-C#h zi!7{x=6a~fQB4aii{^Zr2Ee@|7=Wd2iOvpeEEMg}j=hQk@xy@pU)B9%8yFc}d8LWE zL%bY&WsTYs)WdpgEgS`#z`Kv!_&{tpVtAwCt|L`cWmfZihRj~Xo|f^`J*yTnx-OavlAh&tGO`Miqd4tBXD9Lkt^ENT76{}U5(qDJ zDda|oI~kr;gVi{TC;c&IR0AgF;6fyJ4r=Jf%8W(Wvg`O3^zu z@L?`^OK3PBdHn{a@f*uDEQ9papQo4jOXgs^%Tqr_MH4n!quR$!%3&%g(R{-Z zN+Ph9&wieJK662Yjf~(V!IT4?Uh~8g4pt=Y6mr*a_Nb8uH&){vVbo2kuVgVfy7E5L z6PHClS|YX_#|YLe6xijg{(4H>t{T0Iry7^DdZ_m8*V!;OX^b1}7+ux4DVQAugz35? zHFjq*c9(_SWy5}MD(wBL@g|{#{SeL6OZO(K=~2aE&tSyW``%n!>f^4#%lQcjg{&7Av_uYcC~oqp0nd^76)@jb43?G~WlN}}=eUU6K5ppFn=}g7s zA0vrcA8az223s0!K43%fn#kT2@1ad-Fa>{UH8{bBvEIZOI{|~r-WSORYBu+%XKt!` zzPBh*&yzLEBxSg0#C&B@l%a2_1@g2^K4ioArYHv0j)l+=dtdGvsA+d5E5ntF$qQ^K z7ipBwroon^jD+#`x1l)S|`1giH zrH@l!($}(oLtncbroq1U*uhTkHTyZeuKk_fPW&w?aC*xQaC$f5?{jygdkcOgB_QLQ z^)PuE-;CpWqwRegF(D5B(AQ%O5N=?Yi5SZ*X1GX(g;ja6L)4_#)|0zcN?R@A_)n1W zpce-Y=y$j_!vO<_4&~8;5N(qKh6Wjr)(XW?1G`ToS|flQ86gLn+fg!aZc;~-Ys<== zi}kQXsk~}@;sCuKOF63!=#xtS1vZ!%>)xA_{`2!<94aU1NR>#!$d3%gWweorZtl~0 zR!J>Jx*`rFCKB+4m(v6eN#TVZEGH~;6lfduF=~za2o;u>kjzmZv(>1NdFH5(np8(A zu>uIR;l&(!BVfqL3cll}9(;4S0lufC;(JVQz6mFMb6x;cf#wbbu()w123-FN1UA=l-T^_wZsC+S1|F*IsBP4+e?*`XkQ59!QObRcKY6u=Z-ewDTsIXd@a)C{e zH2H<3-wc0oNlX1dHS6!9e>exR#QeuRL%cxQ0QhnE=TaDS5nLiET0$oE-VqZL`(Dhj z?|ZS9YWna|J*6Y7H6cQoyIH!vMu?#1Zk84fED(tfPw+!Lg&R_H>9d?IB5zlW4hWfL z(Wk`W$P`=T9xlZ)`R1^%gZGYFA0+6&b)%RlJL7Sw)887{=+4pf&f0hC%% z{gKANe;8768DYI?XM+Tdy33Txg7V+G=Zh zW>Wk4(cNEMgi`-Ps7?Gw&--94D|PtyZ2MVN_XXO|*>EHlXJ-4EFJ|b99icMIqH|S) zVzc->?WdZHO$m#(%>UxM#QbAxFtM{*7y_ytrYUroE>xdf2u=uX4oh_%Bk`FuS$~2i zMs5P-aM?U^&a}s%_VD6bJk699l2R`zEE@K$(DMR4mBX}zEfMfs48zw|IMzwM4tO~{ z8Jf4W*emeN@mH`|uZz4-0UR>gisu0_F{hBt84I*)kcI2==rJlDi>RTNUgz`Uj+6Er zPY_={hok6#LsTE&P%fEu8@WW)ZAD~~Q`USYM{|_~;r>8ce0Ks+EfG;nSP1IKtynQR zI#8?u{&@v_*=8nBj_yj>TY*Vlqo%Gkq5KrHNQ>P^e=wL~U) zHB+~!`Uz9q`s208Ahg&dq_0ITtkGiWi}9Ap(J5xxp0K$UE#Zm;lcK5Nn!k)Df@RBr zghmIS7klU5qQ&0oy%++cQk8lI`zefDF5PMXljkQZd4h_^mWk9-l_<1I$kzZN<`oc` z?v;*L!ZCX#Ac5@r=#{=HLc-aBM6c9xr{+rbjLM^rsW>W<)DZ=xr0R(1_0SPrhNS;F z6~zIpB{2-ohCv-BKR) znRIzOHs*TY`IgX-cFm*?wZNPsHU*~w%X=FbG;M#iu`}Y^B1JLdFcy*{^X1Tg!9@gH z@8bKDwmNZr$X2JPlyhU9Z1uQ9aWyMPA=e|a55Gy?yzv8jq`$7x;kQ&B9-Sw3;7!Y5 zcc;AP&bmFM($&sf`!U#=dl$8xns^QR9RSp=rwY+H#({k{4%wsI1n4c$XaVxJAuM}z z|K-D(eU9G(%@4x@c=S{#*dZF zOTC*X92GnO|2mnICGG=JjaweM?i{ zuQLYX5P#nO8T|P-U^cz(YrvIUFr}g8vvQ&h;yrQtZ)c!pCq6Zc%Q*PWS$LqfTHb0> zJi((Pyn;kWW;x2D<)U+baOiBn8s?`IcTSGJStY(qFmRa1e~MrsEExcAE0Un}9pE&4 zg~AK&*+TtymPI?n=V2CXzGY0gAbo#7@nY{Ssxaas5K)ZdjS4&$j>9SYqISN~xRad+ z7T=v%6Wl2;yhj^C%nn6<3xNP!PO+g-ka4^fu~HY>&O)Ag?t{zK0;Ny~2zZ`5K(N11 zJx(PAcAdiOjP}`USbA0nmY6qdmdJQe^=M>>BHd)S4(yqF;041AT8`J+E{z zzU!dA9mP)#FF?H`zQqv6&hlu32*GXatR(HqR&MHq{o<${eR5A3J^BWe67|%ssA9-~(-b#3#x%<@B6cnOl)vci3Ry+||X!UaSo(w&76J3_nME?vI6!9%X z6UEr<@8XYoG|^>AP4rPa{AvZS8K~lpT3c~3=}Jho+GVCVZWVF3O)gVIPc@;(D`<=! z!CQWLgeNS<2t7DYTC(dDSn`u|k}Ua&TR3*4_%L>K0GhIvv12}hpZaN9(iAC+-W<;%BFu0yRxMzWxTlF%rQvRXPJa&CURCx;JUfRu;ZV zGixe~o~&G595;xsF#Cl!LCC0BA^if%2N_4d@W`xU7KxO$lt*Ww)ni0qDi5WB>*HIQ z=t3`g6-3DsR`?Vl_eX@kO4=DuL;&(F$lyA#&~gEFy`17LkO%ZnFG! z)8yz+Zzeg6ikeJ+4cLUgMkL{{n+Vm@UpMvi*Ew_PuPJdO!l(Fa39RK){51pc*IP~# zf1Phi^fxF9X5g~&&pVCRDzeduJR1)e7evGlsU!X)4E@fSD>wPCWMmPjyo z5Fm^e)V&^c3IKg)N!oiouCick_j)Xq#H4#Yf+`7ka;rG3;vvhYF=xq> z6h;Ro)s=*j*!#2w_v zco|Jwt3ibvDhm&TxUClbb324E^=u|E1YdFYw>{#t9o&cim)G ze@+rZ_gck!-8C_*7p-e8;BP1m^|+d0o%pvbuV#2a0mp{BuzY(69w3*@+XsqgR4rM; zCss;bvn$iMQXiHL|OVSj2O*N6&`Kr*;q(VoeDRjL`j}@pwo01B3Dr@g$ z5z92CHEpJC&DL)i>TNYPp*qcGi}BpCY}#&I#e!C}Labd)d)rhjh38`601 zCEnjbo_4%=VIT$5&Wuc-Z$my(BR?6)<9-`v`?*MG798&s(JJ$O?OHM4*fx0K_~A)N z)m?ENVSc|axaa^nlLPV5&#@6 z7~MpEC4f4+)wr}0;iPeCc@%JA7CXIJ`oACD;{w|*IKWlv|#Smz3(if0` zjOW<1$#||4j&O|+=9E01Q}<l*%+%3 zAScl3;yp4i#C^i!IhoK1ODlLV5UAL5e<1A^0}Y&(2AYoe3o=ZmjL_w5ilA@aq?Tyz=z8M#ChH!LIFx_SXOV<6hr>oqw{f{T0|HRIvW za9}QtXgaG7r)1j=@l2DWuZ!P?P})T(?eR_VCqyh{6=E5F`R5di)R$e3)c07{_iKnH z+ux-aJdz!F)j)-GAhw$|z6a89nbyr3!=WLJ#l%=q;C_kr8e{nc564(jlhzRabg5ud zD6O>bBI*3tT8t=BD0$`eXK4ym>Ovtk47IJiZju~Xc@3hvy@q-hTNp>MCETIj zN9N7Xg)&;Qu8;ktLZnvDHLvekb(@n^x6dvy>t-$I>brkqe^cv)$>Yu6S@36OW@3b$ z2{fTME*2HU7AvgDT+FkuV)4x;;gyqxyVUEQUr$qLzN%{K_0B&6Q>aR%r(W;;R1A|hd?weaSyM{6-r1I> z&{$okl+nr1cp=tN~za)kF?%-cj7Z$`x|^AmuK!fG>0GMx}~AYR&O< zEyvT-P)BP#17SlN`KTlM$-&Yj-6C|P>Ph6kq~@X^^UNcL$MFm3I8^E+s6h>y|6ohy zp+%MYYg=k3cu}d3*iv^`so%DxPPbBPY^jx2>W#M4*;Z<~EwuogVUXg*AO(I8LsAZ# z75RUBBT)eb*8Lvzfd#P!MisOwUT75$S;gb$_bUEos^a|Wgd)AuD!aT#*}(RX?Q{dp za{%h_&jt@`+z5>fO+~^pOnmjNaHAhSugzDBm|QneEB7qa8ot`1AhT-ly_e@1J{yQsI$>B(gnLx9jB;<<8RCF=s?rsZWQ;W+Fj=0B=FsVyGMT>$2t2sib z5TDV=5*8c3DiOKGpSJ)M8$VF#NDVa4%gDw=VFN~KvB9vg!GICuvnWU~%?9xqjgo0f zV^k6w1W;@gSZo*}uVvPsoo6cBd^2gA_0hI9rJzZHudtB(-U3&z_9@hBR4R{Hxz!P? z{*#Cnvlw)N#orgoP&lz=c9mt>g^74BhO#K&87``U!Nie+OIiONcp!1Ed9#EJk=V!shv+ zJ=S6TFGD2$wiUvX`D4%b-Sz&Q(i^T$UJ4PTN663#WHlc>SNxTC1iy~WZ?nTdekgW~ zRZH#K*NLgYUFX-$<1GFheq`O;efUs}0-4@GM~+7DgL7#pK!7x-PJ7BkiZr)QyF(Bw zI4{4F%_T+N%*7iRc!m>EZVur?EdB%ePMv1x24%t6JWvduX2Vmc(}wvHJQVxSoaMAi zA7hmsuC_GvRI@>ux9aa4 z^$?lcE6g`AuZ;V+J7E@(lrl3U8zp6Y5s53~&G75kS+6u((=U{QWTe*$@xY@t0whBt zx7ASi;kudlkJBLGHK!tGjn{C0HNX4_cEG|EXxBTLS0eB;i)GR!@kIa8ASc&PA-nRRD z^!n!IAP5<&dt(gw=yV|FR3Fb)AKuHoW486-y`|UUv@p-u%R8Oj|Ac&btaG+b*+?&~ zQsU=lfXcU^j;cI%yWS_h!EDIAk$aQb%dxZP^4wF8I$A6)1B)?9F}eJ-7niKF@EyO} z;<7gsR@5{U*4H&ty`k7YDO~Ef>uh|3!-5huQU$Qa+3;ty#>GFI=JZ~Mzq{~vDgG`5 z$G73H8{rZ7{RF?3690pNtn9yvW{(e(U1_TA3FTemmy3+%)NQP#HYkxfv(O~O2iL6| z1Ce9Be>}U2{MUU$0K9eSX<~cshEi`RG+M$1{6x8QT$r@&JAMxFOqgSD3`c|9ZnSB; z__C^>QX;BhnKH?zq_`XSxnOnDUO$Bqtyu?I+Wli*?3F=~F0FBnbgvY1 zpk}CpUlY@F+9_wL{urWLxC2s6)%DVO)~G#bf?#o>!PgaX4UYdAXz)Q-&%I6fu3?~N z2;QI@%{FZ!|9D&ic^OQ<_a%@RpCphI1Pc)jzD^T)AezJdBHWOJPe(E+@CBYlPot_> zH32vH*^HGVVbNM`Lr3h`#oDi_Wo4DqZkz#fa4>_hUT9P}JW&o3!@x#q$| zUd84H*Wi%vx3(0#jjOR4)teh84ay1S(}7zw8hpPEO&pM;S9D^P@T0Pf!aE(lCXt~I z?waFO@0K*;D5$yEhOv`eL&)>-24af{0e4GS^jdUo&0EO5sWmqj1Dn#$n>Oa=mgdhe zyfeas8;YHw@y_^zv0Erz(!~`dou?Uo`qD7LiLg=rsL9DRRU!myF zFx)dRb89GbhAMszeVJUX=*^XtI|FmJ8DV!r#m}KDL9YyLg|Y=(3an!VtRn{BfT@4V zdU!pNg)~!2Nuf#9g9|A=Gs3c1V8|29qQCa6D&SDUv&ud4<;l_erHQzV9fmA8-1JJW z`hICghB4FOS}=fO2;j5iUKTu97)%fK%|5J4ZfW7A-M>!qrRLe2bLz)|$Fl zB)V8+_!hBEMSek%_hM?1$)PJ}w;p73jM7CW6O#tyj9gb1eL=y3#UAy* zUehA8R#UvrkuQ`-e`vynpQZ`x6%F6g8okyL_F+c8DD10^p`TK-el6+-UoG`B6ANr2 zXtowL_I~~h@wMgMKfo^GvGF&x0Z?a`fMMj&fval?d zVXg!oN>KtTO80V#a3Xjb3DO|>U{lhG#z;<&udH-&*ue?pDT-n^I0_{*kgHou)H(3T zH3ultMnsCZ>V&;bY<#j9(#QQ<<+rUdva z5@0|@)e4X&GSDhv+7PT<3Yc+aQ$IPAvKO0TjZ7jwzsQgTBO(PGDO@AJA&g^J zglLG6dSC|JJ`H8(`=|m}EOyEpK8jZ{abyYy}o+b_(mx4v$8id1S7bUb%ic6)=uu|J<3Cn*_ zL0c_BRHQ&YNQFi90yGhI$dyxb*$4qBh9DR&g@zzgOt$_z@Z@d5m8hu)@NL0m2o*}` zK`XRahnk7fh!FVIj&QIZzlJsOG3ikj}eAZOhtx#7ks7Mz(eB}e6y zq{wkfnQ_Qz3(mvSB+IanWx$ZEB9WOVa+*+PdQp(X78Do}#zsaMgJb#>j%Yta7#Z2f zoNy!4j3A%k;Ao^MjO#iEgoDEoZ41uE)1=L?&}P7ptfC;b8&W8D|}((JT}6_no)*WuS#x^v=BRa zoQ0-l8d-}5F;b2icL76e6d#WwJ$90XR<)zr6Cj`UdTn;oT&&Ih=_G4ymUCe&oSb?p zM5p&`wg99FJ_b3Cw-M%^&Gom=zIE<@`7SK`I>X-ZUJ2}#z!#T5R_klGzV6H4R$8!a z#4;>M20GoZ4;>!8b+kB@ZNru#?ahvl){pn|+<>`Thu4#MDASDY%9Z<{u%d=Vze0F0 z^ywGOdELk5v8_w5giiwr2~R`Vz83lY6P087oK?-Leu?!+uS1<6-4pAPtm>Y|hx@ja z=rXQvw!(2|+CSc7^@YZiO8cy*slLqmu<#X|CX%k6N%;5%iPU#EdM*3=o3H!4TOVTL zR(Zu}+rV}h>$bdRJfr_O4&Ah`3+v=*L4GSBI7BA9W>`<}M2Fgip|iesZq!J&0d)Zr zc|boJM^eg#Y?I+0zao#c{OkQAzC9}YN34o^fi%ZopaM?+;VO{pKR&Kr+@;|;rs*~o zKiU$iqu5MK7yufhGAKZ$Y^*r?qyV@lF~47+rod4%Xa?51#~g}hXTufo$ylMu^%b1; z@ZC9%nqv`J*Wo$!l{Jih{QeBtM=a=()EOUExfx0T(X!~v$BQSi<3u_p7G0QF9M3_p z#5xfhg_vixuWOB?7N?rpJ*z7^N4~)9aOgy2iQmwQxDHr%M-e^rl5I4zJ!{M1r!Z7I zfkUvwEjyf3`!I09A41*4zUN_Nx8^6XG`(K|yjp2;jlU4t?tr!6I#7IPtHW8XUX|wc zFgOS%q$^{PovanW8EXZK7$ zTcs;=OCm^orBLV+BAF3hTufX_B0|wq|0@hNtrS?Cr~b#1!YX)z%Taw&Q|Cg$k$R4A z8~F^plM_~fwTyZ^_bec6P$H{B+aAD%-|$E~epr5Wh?Hk;H%ciX)tb;WdvpKx2G|Jw8i!`Mv!(deqxWR49)&c z8!Ns9-nn%G0%Xr3@P!%wfO59ve$&RmUpC{Kz!zma&RZ*${y&FJ#5m{V)l8lsT@eL< z7fD61*xbN!TLHo|xIU@Gq3tL&&?Gm%eFIC?7MKo-qXIygwkvHJE#7|>YocPX(2JBd z4gmu=4V`8msDnNn6HOjf#kL~X{noI>jKq6x;9e(VfiT_%xIESjvZ`A*fdOxLuuE9>{mNYmERJ+5`m-<=D?$+Ur3BF^Sv_OYd#YfiJ(K=v(PJF1a>}BY9!bV=5KNV;1sPBM0Rv5|sOm3Pq0SPk!SfOhJ|XjiHduZ zc2rizlRZ#b8BfK2qkMLQFdGu5Tq|A}LlYHn`iHAPu76VePGC~ne*K~O9Fav|e`q#- z<8vj0(%c$-<9(HBCBd?`glQrwPYQ4sdTZ@zRwA)kNvR5WNy|?2^&k-?8Qa50^)j~O zfV4q6J|%11eF&PNQi``BMCpb~pNn0CUrvbxB_>A5gd{0q)lvOfI-_l;dtoSg>QsCL zX?eE|WSSa{Ze6>O{nzRse+D|Ri53pdM{w)oeE#_%cKll(XJ$hq!=Z|n-bBe>TB5(j zzRnjWy0$k_${{V$OZEiO=Y%Nrmz{XGAHD}_x}rDHjN+ZWCx|}Tn`lPyetg&-sOeMK zQiqq3lOXoJ^rfB%H}sS}E62LX6B(wi-Gew%PyJyjvhZda2EW{W&-FE7NZ%sI z6`sR!h1k0=9F>Jr4C?3r{IfWif&n4kXoFp!Ab-%NjV03Wl!9Kt0MGL0J*#lq9lq^; zNv>w{DbGnS^?_&gYo6sVMC#qOsML&bu!M+K>z@c?>vp+w*RAVvhk|$&jYRk(L@LRX zIss7K)KK6J72rixb#?$OVtpUd*c~39%#z1(ibwS$=L2_x$0>urmW@eu5+r*;K9wbt zSn#1B)lY;!yTzn4US(sGCq*Dib+AO3hrsg(g!22@fJ}k+f|}GXRh3hKIb+AbTgJYP zQvx((HG_BtTE>eoGI^*)cAL0pq&ePvoblHm;vP6V4X^%n;1}hy?d!e?ShKIQqlizF zj6`3@Oe?8J*F~D~lO#9M*I5Oal%jw*5CU1Qk|Wq8|NJy7M>s6vtvW#))oK^o1~N@D{; z8ZlaFj3A9ww9*(s8f6~i3W1s-@?}qg$hiXbF?mGMa%El=iDGlJO)lG}o92nFZAg(# zUj|gPC`d3*gSB%WOa9Jksc{=R#^*XJ@wzB*O9669F>Qf9|8%5BkNhcgkT<1Q9Un-G@DUMH56H6 zMk)AEaB?C~}MOx_79IT&yEn>)%J_Tr20YU7%F(%4(&$KLZd z6d&9#-d_bURziFTjzs3qXe&Mt-9BH9)PrV}9&J%#X&iUR$6@}11N;(2e&~XOSn2E+w2sB3k4Tc?C z>#js~w@$^D8>7Y&9{LS0{uGofaJ(Am-{0cTTbl0aqf*0_)h zZmd2bT^WZX$0j*#92Q0#*6?F1m{^8zQEAnL=|%0lp_i&^D4!lG!;v874pX@|*mG|P zm4P>%i=PQYJj=0z3YM`E$>hU$!3FR#@33`Id4X;@-oavej1+)5H36odr%to0xblzC)`px`C07O9-g>I?jgaJ#u1D zlM0-V!ny`|(brI$mq-7_Mf3&n8APYb!*!uSYI1a4+=R^Iq)g!xEYIfei7&dGzQ!^2y_w`Y6FPhks5Q zVn{BFF2*7r3WR;lftqG%mF^9-$HKF*nb+Z>Y;b_v>!(2e0{?pv1m!H5g-Mx9g?d5> z#c1bf(BOsFhhi3*{&w!>?$7M{tAz?Y^*_ZE#VvtX!?)5tjz(Q^^|z;fp#s3$GpxNR zbRI%V0e*y(Lg!ey+-gy|l~yj7fLONfd7g_9eT~szb?d0lw9>vwgg07h$nLKY^}WN4 z)q*$qE_j0dE0Wl+o@9&S%AB)U(pD34t#~DeswOE+^9d2Uyu2>`HT$5$1yu@QcaE)@ z;G-OVo-8lbQB)W@KH8p6D(d|i$< zq^(W)ZS6OaAr@Rdwfhx#8943RAxWg7Q=JY6iV*^rv)Mr}-Unh(IXBpIZU`+NVCIAb zhTZ!@rb#dD4mHRZ3&b%n#J>7)N_N#kMy0!UdzRPHL573uhVV+Ll@01T&+NGgfqX+i z)t3&`RY|jdj+LDYA>*luFVvTO@)^D|%1#bzJl}^&=`|iCIQ)QLk72+m2-hO~pZd<| zS85ROznB>r-;_YpGQQ!e-I~czwf($r$v&_~{Z=z99T%H+!o(X&_6fFi$v=vE3?{)-m$C~iKX?DC94@<@?$#UU(CkC65DLLKYip|Vx?H}mqzXoU3aPkj# zq^7yyq_gTA+$`@|7^{?JfAJ*f|^Sp(mgBOzEzI6oK0VQdh z<11nZ*_d$(GdS6nU}l9dlN;#BUBd;;k?k*U$Dz4Q?BI3}u+v0#FilxOcAEN;ohFn= zz4d({WCve$b%ybQRiD121MGwZhO&7%D%{}8h6Fc@gqs|^CB6o1gBx7Y7A~z#%MSYA zrNT}v*@0_XM0RRjWTzGgz|K;U#L_rUBG#gxMam*cSrmT?dfiaG4|^W?wgKz5^8jh+ z0^WzkxMw*u&m)SiukJ)Z?0FePCHBl!@-?$i$0U2k7vOU}^_M}r`u-QZ3eZkDh;hRh zSX*}h)5dF6cpqF_=2_(&iTPAVcv2(GAKx~hh1s)t!AQpZ6y@Q>g_t5RAvYZcFyrzk z!@7FIraGl6-zq?7yE!mF*y*@yAVO^u5yHQCKh`_P5#NMY9NMw(mKXD3%&a*I%NB#t zND&6!afVeuc1s3%?iotJAoDPi-SLDRd*6m16vj1za;_AO99PVR3qiNW%lihN7? zY3&sa?oBa#(>a6-rEotDs)&Q;Dkj2R5q}}}v@}&K71|PLa(h$My zDO|cJ{#@)N&4s!>!q?(i?!(*T6G=s0i3fSv>?}hHS(ilnwXRjCsMx8md|ch3-m`CT zG{BHvi5luUj2v|<2fuGE*K@?5jHxrsxWrA~-iOay?rRClJs@rJ_Pt4!_iG4M2GooB zMFLj!E%kywWV>#=TivOFxqnV>J1+jg>;8lnjxZl=pJ9NV8Lvk1{!BZ~0ms!0xi=sL z*2sad#sG6iaDz8ZerzUy)L^3(77=~ppXOkL_oP9Tj&>w>0tnMv$7Y19Dre5{JB;oh zJ?8X&fWLW{4-s7!fQ5ub#mBQaAH{vC%XG(Vj z`;9Q5uM-!fQjeZ=`hb>fawW(FWrOeptw|cCl9WlFpuvIoQN6*YmFNvNy=&_Ya1H?D z2*(y=Gy#m^4-sZn8Qy_#)wQ?Z;E>1v;z`(UR89ON_i)5NHqk#`3Q=Y7k9u!M`^Rc7 z{`T^XDX(VisyaQDyX(YA*m^;$L%YOWb?GA~UC+dVV8})VldpEUMsWqw#jCAQ13WZ$ zdf>}AOXGyC9q09>y|ow>?RF|Hq>?2}Kbh^3VEj9=BFj@K&oR=9({ohgfVd?Kj!bb~ zUYeH^x~e8{@ zi@IeL8}j`HF&#wTFLOVQpo|>zL;ipzTAOTzwme$ zKMJhaKo`G4*hs%v0XD22wn>b*2}X=W)wNm1+axT;!A2UYF@9{pl8)CClnb1ErgVNU z(vek+g7M)BGy#N{Mi^d{Rz_Fa`rSnh6@TG)z}7i))MPDQaC*j}*&^JDiA2S|Uf4*H z7youLs?@k`bu9$P>pE~LC`BB5Ex9_iQk_~>M}OOdH`n*px+kDUCTSX?ltnXD%x426 z*NjR>%h99q0!mP+b2!edB&1!9$yNKO`KAgMJop0WU#z$qTaA`hVCwZS(RwFO=JI-R z!7WePos1~bY1b2YghK2&>X6ZmXjXljg@XveDnlsoa0F4aV|Bf$i0ey)j!huJ^o)uu zU8*4_%TgxA=1scxRREEWtQYvwS&EWQk5LwjhzuAo^bn9RN(Nshw2-DYgtT02spc&r zo%AyJDOT0&e&O2^H|^(5(|-Di{mA$iu0a+Wq&aa-BE1Qfvbd~UNF$I154p@!Hv%T~ z%Awm(LvB__NU94!*?kHMbw#OUDZ$DB{eL-h?1$(ZKbJ7=$}bi_$pg*wlRr;ZZy~Lg z>SaLG%PU@?-Zb7)sh7Z_L@6$p$VwZK>tP$^Da%_*RsT1jS!=o;*Lr_}f~qTlApSV{psG6I_&ta~Lic zXj|ab^JVO%_YFHF(jntYtZAn9D^(M*=fPz+tYBK(fLSJ$>P5czqp{~XeBm$_w8vx5 z5`%t3+9S9yx`N~WG(OFcVl9AF^vzj-Pm;>J$y0Kgu$i3HCs=8_jE2EeZ%SrfY#N+M z>?v{4GRcv(w4YdUHQrm=qnemhpqeX0#Odc1(=f*cl&YdNi!c`$Q{-irRH`w=?~8q6 z@54cY_S|)zRTTjkUQ6!t z>!KbQqOpW^#6b#Pgn_9(&Ps5(jh|r_=b~DjPK^zvH&e^*_+Eow8VLfNJf@eyJCv3H zWAqrghJ|DnE}NTz!^*^`a?@wxdu2T{v58E4o>dW+gc$Zqq!1j!xWFb11uXKA0;Wj# z<+bjFR3fYow_y1zTrz-T1A3NBo*P6kYDUam1wzDdJh400p}JE2fl^QXY}gx`w*GFa zr~XQbLuzUwhJc=bK}@NZGmas=0QcNe-WPkyGR!x3H=Op}jg-(Fxn>XT?hTE%969>O zi<3kJiH}I65F9D{U~Qn|NPIdYS!9P^XPZBgZfENx_UL@=plv$|2T&6b0@y{N$X zladS%5qnlQGCzq7WsT;yteOWC7=RR5DicU-J+DCFabLP5bt^st zD^V_e(>#sv0&H3f?4hNkKnUoAfgK~pdkG=HUyGoYcgpi_dxRs+uJJg^mBE;qfg zGf|z#BW8QooyRSrlSJonwW*_df(SaAjX-)G9Va>>aL-;Oay>D~M**Y;f>6FL&QHu;_c4VU#2E*VgtVZc`>5mus-Y)VqHB|}6- zh}egGEX6rQ>6qw%F{)`d4VRt^@n*B5a*zO>iF}nI?XW)}9TkC1XQIN|nW%3vFiD(= zAPuI4=Jyp0$<78^eS0AZH<~gj!kG{iq|c5@rw|+|?5LOm7a`tLcT`MD>CtsZ#r!0X z-i!nwC!I{?n4eVcF;$M-WGct}q;e0daza+QKfz>nRFZA$s2)(@{7FehcT~(zB14(j z-7Vt@|4Cb*8S+=mkO4@6P>M_>C5ZY^hasQSP?jnfXsHaS46#&YA&JDkp<|W65NkDE zK#2HgxAPH5?*e!{&Il6Nv|AO{b~}eyBwH*|kfw*8zFW{!dqYEnqzJnuD)Aat3c-`T zhR#w}zyek$NLb5jz``dnzFK|~N~B<@ME;5r8PHH#i77#F`33-u2!)~4A{eN|M209) zi7S!VH+1X@aX0Kx2jBy`@-`*r-fFg{Uv0(QTk_QllxpscmoD|&pyu2gAQKXEZ%!jQ z_eN^++?yG|XG9pl+#5E(ccu0V%-;7F-7A6rtOR7eXeS0OvR;&r8Pl4x5Yy{Lftq{= zj@kbaDH!hHBUQ*ZB7Djgmju@G+5e7GqmhB`;f>3-IlbsIFr>lz3Z2|!j-QPYYST4I{@?F8_x|QLv#+~FgY3QGe#INmCAtrX z+aVi}#uq4ptG}4fl}r<0d?){o3Vz}7H=_J{exR2s{wB8{xc1U)nj%g=^QG`&KofWP zni++w6LV1tF9uAP!U5Q8!%mr3psazmEHbrg!swB%V0;x)VN~S00TtYK4<5w}Zmaj> zsl{r&K~>w?x^gAAHDu@v-i4bfC{jA19j{zql*Plf+v;HY*7@*b!MjizX=BGc0I+hE z3SP+#8hq4&wfCvrG>*i>onqgg{R!+u^Z~xJWR7ESN85(Ly+pFQaQ7DAe%^K#pA6j3 zJ@*CSo@*?ij5o31r`UGH|JtA8+SC~CIR3Q#G2a-v^F_?4G3}`Z?t3M| zKN<-J0Qn=54qKXrtbjwZszY~>j?E}09jxm*vwy^VB729Vj)-9WI=hfy)gwW7M4de- z#=Ojt{Uzi{JNtBZXR8M4MssAd(CQGws832WU7Z~)>TDKgX9t5Xth28!=rp2S^_EVS|7XiNWZQfnmqlwwvas4BSCjWT{|eo z(zSm_!XW)y_30;ARL+?O@7C4YUMf0y-6k2v9la`Qh3Ycgp%wwdF1K zeq0g3zP+X*`}mds?Oy*U_r8(BhO3f7*qBD=VRvT3g6$+|<$I+chQL_vvKUreCz%PE z7on&L%`K=kxXgqDK&w38CIqeV!+&AZAr7?2OG{d4%NkeAoRVC%AXO=K7CoVks0m9xq;(Xb9|KTaM6l>j8Zr7` z$)0rz`IzIKZWUf+_yBt^!%^1j@Io;DWrwoL52fIT_Y1By@Rvgl@gW8-MnLl#ET9-O z3Ng6CEkAjcSoEBq;Szb~&fNW#tu!MqkqDr%KskGuFZ^sfib0T-- z+W?LwSXUch3t!ZR35XHCAF2&&vX_bSB+pi23O8hjk8)A=3DLB~s<6}5;#+ZXQoOv= zCuc>9rO!zzlaz}=5Ui!6_)&H#t-2@J{2fpTu@NWM$Jm=SmPIu0C`>C>Dr=PvBpIc7 zSz&ijSbPQf=D=)OVqF<=QJPVs3NvECE3vMOW!c|a9vf8LfI&g|`hhCTa%(C3Zt3zN6oQ*S)Stuv z{2>OL1M-KS@{x;+`C|$Q2dt#1s1xCj|58qnViGI-u|{KAB+nl=YRCOk_=Bfm*~_r} zaqF`Z$XdK{BBYK}mUv?&LZ>)7Zj3`|k;fi8-5&lvWH5fevLjwpswpvto**5M48{3y z!#Lp!=n_~t=?Iwpl9G&haLpRyB}{6}cnQL>4^s;!w)jRTn&IUe%L4t`CI_nUJe*ok z5!^Nh1_N?1ImojUoPPih{gH>>AzJ3yi7^V5Ke#8IT2KkUvx$;y5Z~E{r8#7}V<*K| zloTyBC5bd{`4V&fC>;XQOuaaIjY%nP{d{eG@UHbz{LcGRVKlW4!;%2fral$iwmW#| z1L-wmW2g@#H>axlBVV?uAbO%y47ju79kshhx_t^5;2sH0MW}UT41oKidLg#dxeyzS zUoT}TMx~CLRRv5=L?7_yz4Q&-@IloPgH03M2e)~>)x*hxBpGGX!}-DywB5i472%MI ziqbt(>FGC9=}F8f$?noVf~G3OVyZJ)(PPwY<|i$Ua5Ehv?q+i)|2cT)FY(Zc2mO$g zhr3hqw>=Z`+5on9&FLk7OarDr+=oqMMxdio3#O!et8lPhgRay=Ryk`eCIFM%1o#BL zvlqOGeseTtzkXW_(4Z}UwBKI07^6ZTy#DmmXHLQ?E8PBMcWVbQ(=m0x7i|X=59F@1 zU{FVJaFd-8clRedPiXZtQpnCv1VHv>2%!=DDJCW3+@$;!zO(NbQ>ZatkA;G2%mt!5 zsWCqwq45aKLP+N>L#hc!V7xAY;U!Oyv!%wHkaJ>4H;-&pP0Umk;8K?o!Ks&3psq=t z6IGi17FfYRLVsZHt4dWSV;a;6rG`17%zoBNuA^_|P#6#L0395T%0aU2gHmWEMhv2F zd3XtO>yMmiS|yZdmeb|C>s`W<>VTY-DR(_T|Y~7=Vu6v@^ ztv_l03|Dt)b{{7<|8tCz>t>)EwBLk*sxOh1gv8dDvg4;I zudvWad4=1j%9;qRWQ@Du>hC^o)9& z99X)6o@e{F7%Dn*D5#uuf`|1-&PWTOmSz_M`|K!eNX8qvfSD~Sf+OjBB*c+)DncVr z4C1wcMy8`&is4C&(Mpd|&PaNkELbv%8GqhO9T;prY}IJdIOdvgAJ9VlDb|3Db7?@S zbcj{JAdqAgPzY++Rls1NxC$r)RhIn?6eXhBYOv`5Yc6Much+1S<8?0JUUMO~c+G{V z0oGiIEnagWsw`WlDto9|18o6-tp22>!}6+g+j>Ua-GBI^c|fX}e`WYG0b}+6aQQQP ztk5`XU}%(hB~SR+zv`)C#h9VJphAe|!$wL``{yU2hDiFP2-b#J+*u$WwihKr2uq zf8I-`Yk1w_Q4n&S!PVWNGq@QlUd;4Q7O(F+gNxG+am$pZy@hJT;vXA=f2CFv7@}4(Z(*%v*-Hq-91!BL z5N?C?u#j%q;UkY%Fj{Ix$Fi8W;uD+3OcswzBf62%1v^6=3A%4&blDpjOaQ!;oIdJ} zjHX>YmHw_Y z^giVCl$4d0m6dt%pZ|O>*O}~Va9^XqYZQ2m0L(O8U0dLDN<-ulJPgS^kNuA6qvBbg=KuFH)5utWJFC-=RjVvAO z4_#?6-VIy?JQws8`BU_AXJeWdpTb@FNvNKpcbOR|PtgTWSk?e>?8m>N0A+dFlD$`U zN1UE8PB{nd3AjSj)1a58Cxkp=zV+pos!ObMSf>+c*kJs@!pvdhUGfhG1RI?`?UJdo z>Ev|DIYaa5lJNs~37IbUa1J&|dR{w-XnkN9#@qqw?I`B(9S(5~If;C3Q+BB=e+}mF zlu$N^lp(tj?O^}|tJNCk3@k3LSwVP}>ATFE9d+|fC?^uJY!0mmdV{ogu zc1!!SVokNB{coejh^66OT+)9N}n2VE_A_3spPnALZeYO9+L(T^^isaqlhjXS+?ti8`SMlEZkt<0y_ zhTFS+V;nOI!N^yPQEqMa7lMPsVzY)}l0jHZ1oz==%ndBmKzDCohe1_{9;pth3dPz3 z%Uc?K6!D$J6|T7N)hACyh&?=w9BI_tP5WkN%4463_*V9f(iX)_pNi-f7b^vL6+IO(IA-Aj%=Cb( z3vTEWejp_eMhu9Q&TlMI-_3p=%~q!|=D~>mICYmm(~6cDgh+*`1m#S|K}8;m7!VZ> zM2-)g+;_nS#vM4EQgR0j4qWBdQgQG5qh;A&ftEUpEmf*I-Rs~_$1d>WGceA<_^r}# zbgsXuwqiNP0Q4seTDrvdO;-+cW~Qb1oJhG&V;6MM{+_N@YIqa zQfbrbE~*S9_M8Rus6-z*E+i$z4;G}4NniF}?ZN^I=sgSbAj)7wSaQY7-;`XcpdA%x zhrU@27jN1QoGq~(-q-G?4Xdg}pYk@Ztp769rx&2}2iB+bclAlE7`O!Fvr@2@t-(T% zrE++)oWCgRS(IAO;G!hGy4zVsFnxhe59MJVrpI>juP9yypmABV-sZ1LDi6hL64=HN3!Jd3Dj-!9(p z7_pvSm;DAPO4?rCHa3s-pennq_>G^z#}OD+4pkG<|a4WgTq$p_kgW$ zAByvX@!3)oj8$_4Pl%wOo)iAcQ$qC*X~WdNyHa^=0&jUC8WS2ODr@E`^iSf>q3HK= zq-DROd<$u?vnL}B*c*5W#o@K7%&=3LS7ip7pUsDy%KU6Im~A_6R2RZty_`mI)+_dr)yK6PQ3CX$Cl`e8nLNh&3wM{BI7iCO9cdEG6FX z#0tg}GKMI5@aBd?42{7H07Wr)ttTI2k1?>{=umD=0p(&2<#b~&3~Ly@C{;wi%U^!_ z*a8)L>#%>48Vgb_M$0^<&pwI1??_U-%bCEtc|t~Su`=L>1WbDw`{+Q9m48}b-N zSLLZJUO?HF;$Fj@WD{#UE8w&lefC0Hb;e87D)n5dJ(InOXR#bH%p32eQCuhG=W?_? zS$m6qG~%PG_Ldd64#qToI%z8k)A)(BoXN@=DL&(kw|G{Z&`Q4_lf$sD$8 zK-8DEv6m1%A>O#PtdU7@*?^I2tA7PQ{QBXM6c)nW_pRWvWYdKJzn#gGYq#>Al;`2@ zWcYT#?B64U%F$kxqrIu{?O0C34AWnqSsT+n#tX8mt^-_)WeivbSJNc2BfN*0P`37n z;@*QmRrvPCH%Igi3FL8(fkJ<=0;P6O($|vv#lFmehP?+b+1t^41@tt*^oQ2exQB8b zOy`iiKfFgp@xZ&g!e*b8E9q<<@cz_Pw3z!F=-DRw@^qsVwj;zm6%^`g?P3tzSUdw?n4l zyD;s6hM_CLk#gwMpUZP7%l%_1d)rFZ{t{4DP#>7GnEW;E;y<xm%#hd(MX@m&;AD*d@7hi}3bQ_II>odr=1%2lV9eNyAh|3% z4O5R-+A34{k+VwS$LYXu`!swx{1~Xq%#cxoN84D*A;Ze0VRlc(qV z7GZZ{u$Bn^ZMMIv*0XdZ|^L zkzE%+W21sp?iV;l^w8ZP@26oh#~ky7+n!uvngY%{8~Da|`I_6JS0W87#PN{e_@T<^ ziL9XJnx;cs6GcxgNNjkMlgPE-$r1nW3?rW);QYC<`KUz=tidm9yjqkPZV;^gTzK2nV$m4j@_iTI_d4wMpG*Z>S(_Xev+lz6a=~)l{HedzYjf|e$DNZ63 zY}7_C_NA4$^_d@|A>f2~W49-ICSx--N?5T6#QtZ`w1=t^AygY&e^2V3oR5^y2dme- z!yC$+jxM?IA|VaY25FWpRnn{_s_T%4N(0pPY()6-&t87%CvJ#dxx{nqv>B*`(2I*R zp%;BZY`+*)8G79|A8V&+KTC#>(6eZ;`I|taBg`=dG{h!w1^6pDD~e6P$tJvv^s-Es zTpN>|8Y6tYb~R!;!WsOZX3tjqIE}4IsDScr$Z|wCn{0AJy#M>&9;Y=!=Q7Q9_4EdAcUdaK0pkBcKL-td`?vd*b z85yNSUX@cpE2lfTf7O zf!mu5Kfq3`%@iRA7lHNCfyvJZl`Z+tN`)U_mGzm$*GhuZ9T(|$BxKP%-9Zxt9?(Lj&fkOGGKV8rzd5L)BYDtL9w1dPg z((B+97bl!_9W$W|47q?Aq`ycsuK)%}Frw-7@lve-Ws{Jh@Obb|(x1B^)r+}rU8J1t zk{z%DVpXtdvKgkWdy{P)720kp6u_xS0?Ux<>FReuPhStt5Ivo$Ju>YVnJ8**+C{|) zjlCO9;Ls2IWek~~8suLGojo1lD-q_t+dC0nh;YNTORn3X*)zD z77I%+=Gau1xlX?PPU-|2Qy-V8}*2fL-#ZlHpzW`BO67il09x!<+H*mt=S& ze!%DJSa0otWTF%8knjV^#2yW|)b2{i@f6})YS$$a=2Wz$wlyJ#1ron8k)W#r32#m$ z^p!5o0QsU!GEE}Ick=J3>#I`osuS*f%{*J~eC>|C4Vg-EoP}!Gn}bI>6E4m1V!Fm- z^+uRHECYdpcdcSU^K@W~y!0dK4B;?s`RSU8pRmz}UJ2gW#1`u7Q+Sa~U`RP94K~}z zt2vOK5~pU#Rh(j`!W%)_%~00spt@TT-i7c32p>S$%`j=V#A)f$ww+?c^e8KU}2vUJ7WKNILl*bn<;w!9JU8ehTF3Xg-X; zsK=9TK7vrPc`yFLm`~!l5hH<91!rdF^Oy2jn!DNPp57}3`;-8#OQ(quGM%89WNeq6X{xPeps z=n{;eDek0&qC)v?3BH909~f+7)%`2p9PwF-9fHiDM*#)L8BAW3l+1tt`{Hr=GN(r# zuqyNpTPEO?sTrqoxM?ON>v*);tcu8tkiJi#glml5j9hFCd$$u|QiZ*{3t`IQb(dXp zWi)!_OSDRQxuk7)xFU~jXqd=j@qUF75sX^2uaN=F*DyBHXS-&KC9|a6$88`;60M6M zZ(TN5rLY0#JIZiBgYIibg#!P(k0L*PyNB@lj{|o zLVeO@QUt+q(D77@Na*Yb5qbh-wy&w-^q6v{0&f2gR6JK-9V zD(g8k1GMu+&x|ayc@L|4aL|dHyuU(T?hNta4=z)0oCH50a8%Cg@^MrO;5m1c9B zklQyPNS&=Crgh|2NDHR9(T<*hJ;hG!<1RlQfh|AscvhSo3D|<~GX=w9Fw#l0kV|?% z^L^o-eH-NTFx7Nhi@}XJ|;>8I^!30=~Jq!A)brTfWl3Sdy$6> zf?n{{AWJuT+K2Fbgei{$u*N?nO89Zm{kPrWCp|6UCllc(T56w2)IQ#_;PC|AM5<_! zOB4UsaOs1pSqr)J8k_oyD~wJwB6ZC|WuZ^^O14ow*cMdg-MF*!|vcns~t1At30pMGDW+Y?*pI!v`?n@Qhc61y?G6ryN~7-tO1yj~Rw)vGJRw#n5`H3)pw)?lpG+iT2gq7949_Kh|87D%Wjwf;>zPlYmj;-hb!QBxzC|@;A*b%LsS{KeISTBaOSJD#hc!>3 zKHX%CJS92;mkKdYaP+CKpFU04{B4@wsp3*o#SSP4uwo^6{0f_QT~Xd?ChuD0b?v&I zDbWGhZ`~^`@af~it~{l#JX>uZ`p9nDN$29R86}?UPjA}E7zv-8lIMxN>T7%B=Sw_G zCq`yl#GX@OTg*Miy38%0Jcop5G3U@?c#}cj0#1fwE+iTyqaykaiv+88<@u;9&lsDB zXbptWB#Y2ugAk{0b(t{+p-3JfwKA2~=%dZ9D*x~?;;(3J5R&(&-#xB8QJZHlwEPyW zhgB&o=6tX&6BQW#?1Nly3VD;w7fZ_sC@DVdU1)vCRb`2-vWQxfU3m@)4S@P!X!TeX zH`Aa+JyDlAc#(GBdt7MEcA+%`;r-z?2i|4I%>Ch*4R`Msy4ugK{c^3{es=Dc=Go63 z`=y2UbIX2lfp0%I?U%Q%?dJvxlznlX>R)Fj!PPww@TSH!=Pbnpe9cev8$^V*Z;aB3=V#k z`}_jM;n(22#U<(RlRCHmlSJFu+dj=Cvo~&)V0ZCJU3~bKkBfLLY_G!3wjhgO{2n_u zEs4H^!Nd`;H*8><8oTX6q+1puWAh7b~Gj|7oKF$VC+xT=NBYlxRX6WCC;u zIYb$L()kp9hDR9DW_?yZ;l#Oxy^cdj-ep--1#lcW%i%sMsm zi3$Xw408o8+;JTGu{uTgYXZ0r7q;YRs}J{;X;We?*x&>0Zh!NA(b8Pb70K*phr2$D zgGU1{px`1kwjnvAW2yvxSBpPU`y|~~@U~eObqTSF1Z?&lnw<-5)H68@JT|1mYk=zp zv}qGY+`c+It@orh@EpmF)5bnnh)oV}5WfK%s={lo$J%v^Z%H1n=!c}4k-b)5ec0gj zO_69c1ckfRF0cI%Ho(O64t7vuVEe={?VxN}%-nW}b=;OEqwuT#3aY|emQHXeQEF=3 zVrx7E0R*e$pvt$fkGyCSUV?m5+T?7a+$IFX>cJ57Cm)njD##n^A;_no%gr2u3=Kj4 z6d=3i5F3$e4P@Derfo*}ip!#xU3$%xpSmg@s27@M7jagn`N6a3JW;QnJr zm=+dtA!Cc!sBVD_!DVDHtv-C<+hVjge1PvAqGf1T!zE}8p2mW~-6ALjpylCVWWB3vC|6A($uT}iXF8YgX`J5B3y(q_BU zv_dCMmAO_o3#(>RUp9-e4B7(vnp3zgkkw29l0rZ%`;8{~%pAkoJlOhcdnq&*ciVB`? z3f77WuzRk}_cdINg#mYreYWHUMJ0d#epOB|b^k|c!84^!3v@?O-jA8QNkNRX z=yPcCeo2$QfZd=uP0dY+th2yAT?Fhz1(rM4>`y%ZK0yTIQfY27nq7vQ2;3M)gKlQu z&PzA5HpCc}a<2d^SCuj4BB+c6K#IyxbEoDDXb3^Mz_jF%52*6MR-7P zguz^%ixFn`aR|B)VXiy)|Fc(KcEzi04KkFD5q;7PB8WcWHs$si_!>f=jEhWs+~|{Q zL1^wW)9eu4sOP&dR`A;li>&H5tCTWy6AQ$sQs4z5FQVQCoEutZpA^Yh4Kc9@!o6XI za1J39DJ5>y@394QD$EY^x0r%uC|FoA4x_lb@#Ic-#p8g8@njEPEAA!F09IAF7nR&@ zEBSm;C1;pQHUb`u{%|mLSk=ckNw8ZR&(F5}UzTlmLBDlN5#VF)G3G*l>u zceK^3k%XznVMqoZyf3f1XT`Wk%wp4LWcJM{!%XV6E_E}v0Wc@=m8yz-&%nvEOW}u_ zDs<*x>8AWSNY8#takMHH7BBPD;lp*AzX?T*&Z|aF+C9rfwi_nn)8RkVW!Ac5S%?N~nH$})QWw+W4Nf{^> z!4>}VaeO)#UqkTU$&r~)nDOZss%LZ8x|y%irrsxd0NTk6P7zRygA;94bMGnKCW|4C zQ%74iT~v08DZ3W=FwHzZIw8_+S?02$ydKS)yK3?Aj)Cpd=ZH=+J^!eD`DK1Ii+M8Z zq$M!E=}w2As>?LnPwr&F=9Y_QuvZrbn{I6D7+aaINiH*My5e&1$UIc-;*k%%mpnr1 zf=6zH)>9q<%X_Xt_8w6Cc!ZZB{EyOeFQmU)ZLb_e6S&h=(BHS%)O{+dPJb^$>j&#^ ziaq)}X3O4MRCcB*>+0`|ZQjompG zsOj(dSE9c^ff!eRUs~nr?;ikWzP~R(`QCvUdC`4oXJfqUNh8(I zs9r4We7nLrjm%oHIvzN=U8Yq@(4|Xci%eUCF+ltD5#FX6&?FfL*=J&U>NA)zy zgUzF57D9tU$bMT((C9)okIohIXpw*>ol0)>M~bL9&lHWR8Urz`KXQQ zMhqS5);=PE(TUohOP(>}p(*whi|dRcTxS?uKMMB9y+KR*mcxA1O4@O@z?Q+u!+IPSJU!Z>*xQdcZovB2 zAnWpuu2*ecq}@FP z)<0*clE~|yh=uT1RVi88aiRpAV!=NS_`~R*n*^ZMKi4bxg5!Z*(^WsbT>wC{Y*qau zeBYDmO^4e6t_K&^s-4TPSE15_mmGjsB2`M`A~P*MR~meN3z~uxp<;>-8S;mFcJF(@ zDtuDK9;XTz5!)(CwTj$Izz4dxg8tcxeNP;?5uslxfwSKeCbG*&*d<8tJ~~&>TLZ^o+TCmU;*VB|n(2Mg^l)VHahyZT zVr-?vS$VihbI3I8yq56OiSQpU0_Yd?L(rO{7bd!=kt{)6a zf3Oa7YqSrm+JSzEH}-Hw)oQ^^FgkF$C?se!v)1X+jkTR1rQFWt0ThPHZ^}29PMA}f z+lx=VLv`ApfH)$(;ZD(M@LADKZPYEgt(#}?E^UNdXNS9^`SitV$ok*PBv$uMh^)4l z-TtU+entmqS*u?NtXoE4yZ0gl*)mmU?u zpxHbn)h514;c7NCd8~fN8+Y*5Or1sNk4jP*-`Rm+wYw4ZPafZepDHasb(5cJ^8A$7 z8epV98?AAirRzu-Y4kg#6Y`9-)qJ4VDtJHSQ_Z-Atb10owNIv-GUa%blmuoetB7S<{8#xD4Zh(v7GO3msBTb^Mj z)A7odw4C>Efk5CwxNr$K0&pGTD?*G45W_HU&s0Mly~8shGTqj(L+R!)*^ViaGq+S& zwTrjS9o|LLw+ORp42WkeNupaHe$*K)LEdsSW@^5bdV7m3+L zoxIo=S@>%a5pk4Im$_6q7(81%G(xO2kEqD2m5&jL-TUz%V*F5L!@CRfT&HR@-scqu zJMq@>9GsxuLkEpiz7^df+741lUpz4+Q$w1p!PUHD>HtmG?yb+f-BxTyD z02>BB5FE6jL4WmDK_uU}xr!+b8(5jq#rMCB*+RK-Me#q>cn4fe!SSgVGz*)`y;{w2 z+Fs@D-lgE}dl2KA7yJ|jn|6^Kz~xlyIxirfA3^rL;Er;H{nx|KPNd;eSHA+8T==;S zND4n!lb@&J%UMqaf_P%_*;&CgI}wYWO8LA|ZwlDYi&oI)R8lSruHj7q`K&3Cf~(!% zH?E`|EWExU?V=Un78AZ~IoN>VQj}Rf-wEHivc?HJ`H|oX{?*isXt><5^eo_f?r#QR8awzk(aDE`W8kez<+9EY3 z(###($-naY5(98}cs8onSXfneq6yinp|#yWbs`{c{Ge#y@0*q% z(bt)=5cad2D8m^RV8a;}qV=1F7!Cfztg8!yWJh=t<2d2lBon?(2vmhP1mm|L8hbJm z!l7s_Mmc#qZ;QO02S0(^32$=kme!Rk;Rw1<-2Dabf^B9`@UGGcc<8f7yaeKz(1&5I zY2x_+sKmootdnmU69IshdiyX0>S~&}Z1INSU3v>9Z`e08&CX$5-SHr|{IVYc{@FA8 zktqg7Ov*i<4!N-tlO~{dgjnfHX|;=9l^t>m2)R5Ra-U?Bgm}S(dOdfVrfV!O*l13s zV}^!%Uc7vgl-ocZa!ZQoxuD*dVq+vyKda=jlX-bnup?z7xUxdZrg`m##PufE%V@_s zCrfPWx#t#;SgyJ#mD5p_0->8(#J~`8+dQDSlZQ1_Nh`6z=fWHq2;F1)l&PRixbQ$J zE%VAGN7MT z&8$8c|07_iLlSn+)v0FUEj>gq?4e+C{VfP?XSI{ljBO1D3wwx7G(E&1dx%9+l3N90 zy~)EKvUv!rN*dZQ#f`ioAqWcYl08H4QVZo1qlq6L( zGxw5);9XLH#630DOn|tOy=DI;7 zcVdfF@IWRZzu8Zr|6~Z_=z#gdgJ-@>L(o5H=i${^jf~$J^pK3-6&M+}{}{|<#_#-m z9}HQBkhPmh1Z z7fLSJg{YRAF^M!QjqT)L8J!ux==@6n)L4wpzr$f!wiK$FVElMrv_0$f!gpD1Ybw0U zzETT=iOq0VlnOLU1?ek9@jY;cjL=w5uw?sj@k7TYYd5l3+i~&k@(iRTsY;#=XuQ_U4c7IW8*DangUyK& zNG@TfYS)?h0n<1?Kw2uiu1bi&R{;~^Icu}Lrn;Ff-q(4BEQmHQ7i}!a45GA3=2m9j zXftoj9*^p>ACw81?YmO;U3xn4Fx`izBjLYslEmbDup6odt_HOSXPd6TBTL=~4<*y% zP4PCq_xoUXvN?o^j%J!<=)9p1rAf68G26ulT>iOW{FvsLlOKHWvE=#!P~x3vawn_E zLsU3~sIYqwg3thVm#Kw)%dqqf1Jbt)uy5tkUNc)PLmDfTNk?M+&yk~}c?bTo4nkpA zpfI4HRbr?cOmpqAU1uo7t=|lV1T^CxgVNosASF#P1E9&o0Z=oggmhJ6QtrFmf$9la&QO%P503uS&Y*8@;A*(c6Ah7j>z-SAB;q1M@Fgpd^p}mtWc`z#s zvW1ungYcD3@W&>J$n!^?d>j6_!1QeioYLVfx@3BTDK0O0;>guLP7y=APF3@;>7D#w`(vfa^##DTOG2mAvIZqPnh8@O5vD>XObuOZQrWu|FPNw-K3Gb?+TfV@Ie&0=_jEh>h4q&`zu=#yfe*DVVp{d=fDuWvsq%vJ>?Rc=N>=4JDQJR zxUp1aSg6W?^bG^-n=c{@mJ=v}Srft6r`Pu&ZC)lmUS>@lVh?8l(V9&FF_4m^s%F;L zc$R^ZPO~`XUc_o%=Di993krNrmWmYN+z;U;!xhJHb{;sD=+*AxKB&-x%j$9Pw2B*g zW3Z+U-WlGNZ01nPcj6FRKPGtRf?f9UQ6@>CUTQ%nG@-ZCJ~`2am*m5p6kML_nJd4!d$JQ)~zIQu@R;9eR005?Xs>WBu_$Yw!d6Vn%q z?6dikC7evxA*Lg|h5|`M)(H4D2V!fy1j;)Y-^o!-H>L2xX!BExB z3MEx*X7eR=ucY!*QiUwCk1^ToN!-p1vK?b%wjw6JlkuL$P)asmp4qEHhl#uF1tmq^ zQtK&oN%3bJ-^pT9fB|;_eis&KLyQ9U%7)Jk;}onnEoJv_~{(3Fc+qSppHFUVKS%yr_oHaj-i<&wVr>WPXIQ#_5e~5 zz@`qp2!E^y>pe^jq~`;{ept`wk2UiN)+9PW#akKR3o>}+BNvjGZpH*xQz_&t1KAqO zvfq%A0k~WfKU5iPK2JZ>wa+CJF%&}fj@W7h&@_S0M>3ju*-QY7^O|5YXY%Mg8qOUj zUFN4hHFNNK>d7*hcfN0zZ!zdv#qv@tRL)Gk#Xfwwj3lVUU#3LOG9FXAU$>d2 z_}KEyJGq|FlWV0Z13w%xc`P3eq197K0|t2KSqxY&$*Us`*xW%RA<#}DdcZU&fO7Wu zJrcJzaLCKvx{oJ%$vM|#SD_RQs-kd;1Sm3RiH@Z--pp`PSdTAwkOeO$Yze7^-Q-kZ z-s)&LD^hLs@EV~qRzs+8(E9P-*I^C>mQhfpi#HlDd6G7wU2AQ-raN%s{T^938ia~3 ztWXzH)4z;`)Y5=sCqgZOA>mid4?7X?t!E~(JcmY-j+Y_ajWAS@XFkGmmTn!DT)8az z*~?yASiR73XxQ<=c_IS};VkKF%C&18Fb~Wb4LF4zuFnUYqH1sK(aB}hboj`Ppbc3m<1-R?w3GSZ4cyPot3vz)txjK8=#HS zYBnypwi|ziW@hB1CTKB`K?;sTa?Gwnj4#T^5fE?Q4CiaeeSQN%&L=}09g4i?!V7yP zi>cFfcxR$N-%6C?Rq4J82Ch=DXQDbdemDazqy28!`JzxEeb`OLs&RV02p>K?qo9V@ zAshD;>2ayg@o3L4Hbm`@qL;fNc;%Hu!3yrr*hYg)1(8`vl+iXtS#n8*=FMu{uSgd5d2`Bl+Ua$ zK00^^g-`FFf%r)mOhv${8kj`iESYPr05@RA>PkFwA&d8JxLaNUGbPfW`Ne)f4sGyi zBnG8E|8fXbpKfsVm>JEksd6{zzOlkn?e1U2B zzW9=6>~jn4w_s5AxjOqTSd@LP+I|ZrWuKdBzXhAJ&sExQ!KmzWA^R;@ zmEAZlvdfCr&xGjy?0*m|K2a6ew;_h!JBa7<80Pf;V7OAk2?CtR z%mcH7;c5wQkZ_HJZ;>$Gc&5W*eT6)8(2MS@4J4bmfIx)>iETE~CyA8>iQlw|JfJuj zo>Y+dd7H>NGjJ?O{G?6fy_|#L83l=RZ6en&XhlKdJ8U97?i>u)6eONx6KPJ12J>Z- z`+WU5_`OhAFN;~=%cgmbL7w)b?YR5yS^l#R{#~Uj=%TJ3pj`u9bP*>?$ep0+~ zBHS&<8z*^|LkUdrG`i%YO0=_Id^hb6hYp;&5F(-yb>04Ox%+$JelUwGy>5Say!*R) zf4I{9J#~M0qWimYKUl_9KD0kP#q|xTb>!n)=vYcEkF40QwV`B!>?+~%WP;o&;fiEJ zPs@;Jd@>;`KIX4X%G;WfXJRs;t7F7ZN{Z_yiJy`bGi zl5Nk&P%hc}d<>8jk5MQ*vigq#NH5*=Vu;l9P_|9%JO*=e*#e#3AqCI+OTbwtQr0 zfmtOl5;#;iPvHp_h&ZS)4pA?V3dhiXv4F&Rmbg|@lXC>|z%FDOZk3MM2H%E`r4FE- z)?yDI4lw>TcK@9Tp$Pq`U{+a|NlOIRXUV2s(G1vhVSvx&bXs`z3NLppNQ@*oL~@SH z1f8>M`xSls{wUN~b7=NP*f= zRbnABUM~x)+VZNz75KvH;PBHXa|Vq;_ZUv5BRn3<@DcM}Hp|bPEGzI(Em9IriuM?W zs*>ni@wYTO0e^kbQ}NdyeI5RWunLdZ?8_C9jAICWtff2nTW18 z&0U?Tpb)bzw^@ICL`cMeH~MkmD`trw@{lMI-5wO(VUz<4mfP=HsQOKugW3at;tk%rSR0PK8Kd#akf{J0kit z@QE-17aASa0Z_`53oDq@j8O**oTh7D9DpPsug9k!M>^c}`h#(-$a1CSdfXIC^m$D1Jk*Fl8 zf3K~75-9I}pT1yxdoy^P3(U-hr^)_49xBTAk#0zIKO;gxmAPso00O0WD+9cKyvM4d zP0vcM?Ei{7=UqlVlpRP(k-E%Z1&AzK!R?7n3Wv}0CT`a-c|Nh#hAR^Zdf!ZiC)Q<3 z21M)qF0?jlv3M&3L~El(>jZ>u=LlONL@Df0?~@Q0=k<{k?IRpH8D`U{9g7?ayndDFbi zoBlcw**|G;01aCNhXp-J-_7I)Q%_HP=FJ>0XIp&Ur1<1;Ji>CLEEZygZqXLH_<7L~W@J zCCt8Z;9$7?;D&CtJ&f@9gB!T(MZycAsx6_Q#*Tpo$AFKc53XaS92{`irutx+MI%O( zj#(eHq115ts4V+8OxAJRauJ9IZ@b)p0F4%*^rGZ>#D)8X*suU2pnjB#s7TQyUmZQ>=wp`oO*! zp$+e0h*nP5y$%&f2o|?Yf~_p`&P&O)I7D8oku)bmB?xc7xmnh zBd5{FiC>LO)7WF+s5>Bs!*SHhqsJ{&;n$((GgxTgAw$f{b*WV0X(-E%GQ5=8A&uhP zMwQWM=>$C9-Y4s94C|n#bkA>8D`kHU_Ea|PtIvE*iet7uUW@-+7!JjI#1G2^9de=M zHvf^t^G9Y{a47{xw@WNr0Y2!Nm-)SvhZhYxoG|+F8_L8KGH#9Sk@^wF_5f$g5|7i* zP7SxzmM0Pqn0T{_g%OJxt(jSdE2HU*UNhtOqiFog+?~>2Y=X#p@%{=_GH4+)M3srt zr8{6~D&2wQ)a{mjXDR*M%W`HO4t=S=((0RT>YEy1#&gF&~c z-r90dvTDxs;1@X|oMEYC_q|TdBm)R;HFxZ(g zv$ag_5|A?9mao5~dMcm@v$zl#KM(?=wZbDJBKfhg8l^284YczDL*?>ddY36xGZn2w ze(xN#8`j4-e1?ObP<(lbk7rjMPE2ZkiEm!!T_PTEq1fpp#Nm^AB~Fi{rEs%&lH>kmlR6X1y{#bEyvz@>BsXyAvI(2u z5hmp;&*Jh6k#4E zCD-MYRyz-OCSWVjU&AS=BJzy@KWHkP2bX2(5kv;L2F|c6McBbAP$ZX#QosybgcF<_ z{(WBY%;nUX956T8l0XJCxnBv35l0!P&YN48dA~rBCffNjE3rBOyK%6S;F)vp! zU43Sp7Lol)7=UmpP8FmR@fw)Upjw>t$@o+_#r`npd5okgqMUvT{hmU#GTv~re)~*( zx%IuJ->pI&C_IjaQ1y+a45O;nG^pnAt>n> ztLlHlW7-SYNQ*I+{|4C|fM(^=i3Ah$P=~j+4^svRxA%S-b$Xy-y}auI_0^R^uOEW# zpl;jL$?iqn@3gwwZYnfpfw${aXmk`YYMm8uC`ecx!s?oIjZe6}c`)|EPsDyTbE z4;3_BXoHq@!+mzDK9H<4;g)(|qRy9nmuP35t+0(w3v?_^wvgD$2auXdghgs3TPu>p z7Sp}ez`le=ng)u#6#OwD(;P$O2>8oApD4@TWLc#R4FM6ZzOP*Ay;gf6&tR;ZAca3w;_N!l*_JusN8bd z)ota5%X+!~HCYH`4&zNPQK$McGB`Z!P4b?)Wl4x2MW&>sF~Q%Hi4%c?^XL z80=vwUc_L!+b)O73%V0?LRn5Ei8d$2Y^2i!%VunjM3SlU`Z>RaW%z18X!y_Ms}bn? zsWKkHNC2h+6Q$8O<6-+6p-@BUACC4nlL}l5%qn ztrBfXLRW?%M_pI9l|g`@tbcS+q!iMROz~D;%JD?2ArdA>>Sjh^-q}}|X%mTtNT3rK zt8z96w}nK`ajQUzONH1VV+~wVbzS{XnRh|oyiClNCvb>N8dGqX(ZbymiijDo^^gb~ z#`ZE%NsN)jd<7_yhB+K@)SRBKFUz#AYC+ zYtZ_EFq-D7A?ccwP=MCvqfT7g&-v{!H);6x z@T3;&eYg+_J@Wu?o`Bg7hwEPO*z2YU}SHPDG zJh)MHpIl0tb6x*tIh-_f`wYH#A)B_@YBL`ayKY`r;5q;%#Y2G~fqg9So#ck^Z^Vf? zG&|s9sZIF!+#Q<))jWbO9#MOYt+~Ae0KsH^P=9uG7_vzY?HCwQeYCWf2FXn?HVCT0 z-_+j32_lyGE!DonEZ-2ll&^C5`l6U)u($M{p~^dni30`_vz5++a%Hk-G=dt3uMcBo z8Xz4S#t@d8@C2K*6HlzsyFPSaNq!(ku6_eC#%wbXYYWa~DcnrJFa`#gj4$lk*h>Pq zWkEi1*wVi|pRIHR4a<|XAT)yZmgdehI|-^m?+`61!@Dw(Cogu+R>Cx78eTh%ke^%( zTWW|sSc^y09v3|SO99W(Kb6BO2*Ga(x>nZvUEJUO09eDU_oaht@Gf%$yzjtKCMR3i zfy4TFkQGt)66jXAwDdpoU}`}hy&)J&v)m)ud&zR-7;ItSI?9JMd_0U`8sLTt&@snT z=sV0i^*r;3y9V6C=|rF^yo1o`*n!Z+nFD+{Ahj#^NG{?6eX#>N)KDj&w^-0{>97fS zSihXuz1)P2KltTb@)kJ9G@!Q-aeUO2u%a!AIavSWJ!WLylIt9-rwiEl1%F6?aMCy6 z{)?+!|KW59@EnbP4&FK1)h}QvYc0W>Go^9|3uY7DOE8%9@s;dH@QXQUOMOWq#HiXw z5;Y~q+&sbeu*G*gG|2X|@m0V-?Bd27*aNizuW{=^HbA^MA?=P~ZJV3oG!F0gU~V1z z8zQl(W^(#8@;OA7GB3H2{NY$KisO%y5rIww?_r0fCE!nt&K-DB9X4Els8HZ<58LOL zoh8HKrBNNX$?l_q%@?Q-5I8%l#u3O2J-lb%K^TI~lbml-E7(ktgqAxa24V(RtAa;| zdZi+?8NAqs9eU&vRyMv&ARX-DOVRo4+Oh0eHyhxR6bSP|)2t}3&D~%Q2iO7qs&;zh zh1N58x!hV%d3W^~r~y2!?&Wf7mM_~~K&u=`B5c7!NooEl5N$A81>?F;ICz~eoL(;n zOc0ls5@nw-%MHT8dcro$6nJH|VsOfs4N!LSRO#eV+R4)IqrLL1k?I7DN-hC|2;F1Y zKm}~8d{Go3V0e&wlk=?t_Dx|E6|m^}gHe&A!r;g{+9%hUn>7@O5r{+%LmXS}#}Bp$ zVab|RgK>l6XQVQUz3?=cU{Ic3g5h*1q=!l~?2_A@yJXM?0sM>Ps@!I6EYwr?gV+hD z7)#7(jI<$9kx`_nB0cmRMz@3PuxblX*%h1n$F@Kb{@c@IG_wEkHX7)Vk}c?Toi$z6#;Ob9e%@lR$rj`DCiL(*W&k zsr^x+20*hxx0VP6oAn-+gZ$!-@CGyo?Zk+`iS=v{E8h(`e~!10l9T%ltY;=Bm8|C` zIaS`o!yWMRrk2{95`2wkQ%g;WE3qt52fo+TvfOvG^qA&qU87oCITgpSfg$!#;~X0m1>0yIgbNjL)KiJB{iY0e1XbHANy-Bk6$T&bM< z522QZh6gC|WplZm+3Q}?5_rwrqYvT;6bD4he*X8Pxv`P)e>cZlSM8BqK{Ui!-7Y|u zA&_v9T<{sxp2+MsolA6p!h9^SL-Y7TRG{wYDKq5ADg=!FaR1-oLc z01xb`3u>$cdyqdy-jSguSPoCG*13>TPxOs~BM$>oH#6qwLpZwyZgWtdn>6nky8aQ- zL-&v7L$T4w4O==OPai09WL{ZFYwfzv)M{G23*RGZ_0a7#{c$6EgZw;SHnPXaCoVe7 z6+Y~!o_oWlk`NDQqUP38GC`8$PC&+v7=zb;yM*Iud|90*ip7(^qq+`6^hDO$o|^)M z(Q}bH8}UYsaFg=M&Ji}s#c#zyY42WCE%H0$eTv)6=B(T{!of(e`6i92%RC~;amtXt zi}W_OuayU0p6F@$yGS1f()O4~5|Ivm#=LMmxSLmR-Uue*Wt%t5)A-k$crnYM`4OV! z@E^zbH~oyzDj9=i-Jz0b1%mskCmB0ho=mNiECI~|^B36o(!h!}P61>9xkqwfq9?}@ z;<I+Rk5}C&st<&lmBGqME;YRS%nL7EdR+S zAK68eW&_)JYa5cVrrmusJdUFUq>YL#X|84`WE?o3hfzi|B3p@oX3@A z*ZZUcwLhlbLn;}bjvw;#YM|UL6?Q()yukH0$rZ?%%W`t@4i6hWZ$`GXTQK5>LY8qs zba{yfmCq$ub7il3piM|tI_~V+o<=z$tbw&wPw+0^*zKIjP41*@oyWLDAe6h$z#@vl zZRd@n9-tYPX3};|7mOW=t1ObZi&Wy?qU|EzQY}<#F5K=_Sj!dGcbD2bpNk zHJUL(6jJq9DAZFVKlHZI6QFl=KELFYP)f+LAPWWWx|tWfP!K`6|E1}-BT|6gyvZb| z5*rahD#S8%FMG|XGw7;n)WAzB6y#V2+4vkSh=Nb?Bgjwc%vA@Frj62$ryAth>Y*4C zY@_J14&;t%qps6N{aUKbHwyYXit#lNZ=0zAk62DJqDGz1^NfhC!c&PN=L}?08^ESl zmDqbVQkuntHsEdIHi?>aT_>{a&;5MR(lt|q=_APR6i?O9h|dgpR=hRRWrs$O#n9A% zEFHcO9M2uiQc)EbrJucgPT0qaURV268YQRZ`e|C$N4rx}aYkzXSYt8!&UW?>xG!HG zHDM8URBoqf0~N!g4d?U9Pd;O6b}7xy3hFU-)aOV8&M-c!D)jijx=#LQ4i7RO90o0AJSg7Zm-%T~b{1t+=3!Wu&F%q2vqwdL7I#U+_JQX4i1d-*(81Fu9?i|Xs`h%H2*`n(`y6(6)XG9Qa^4|nWOgy?W2jGNTG zj*VFFyv#R#Bq>s8Giv8QeAHzUcQFAQQrSm=Vk%rIIHVR-pxsEmUAhqp#7z&x?-zKu zE5s=tiuv*S4&EY9Ex_MZGk@(1Rdq&BA`W8S>7k87FI*RW2YcmJGG10~G}CK1HD4-+=v5M#P^zs{s`uSW}9`b6EBL4X4}0 zsljHhK~0AEvu6j>F$?k?y8jdLJPO~`wQFHg9d%5qFF?D~;k6(}Z+&K-@^Y#-!nz}E z2az9X?)>B2`QL2vqlc=mL2aJMaugAIKAumCarw%bC|hjjD zYAu0JFM1;1e2roI`#`#W@@-~1e?l5OxyuE-mKj+T>1vbZ`O-U6<|<*5hJN9Z-H zc~Fb*`-~y>9WK4q=jbiixL+<=q~g5Z5-o-D2|>Nw@WEfe2R8s8;e)1Kq#k^T? znYW{6BG(r5e>I3-gK+fP>n>e&i-3TEj8?R(L- zt1;|uNLN8ax}+gpfFzqFdr&2tqu1IX>%Wse_UHEGzAFtPPUzO>Q0b5gbeI-O`*zv( z(Q{R?e>T{!eoKv?;;me0dK%6KlGwx|W5M!pGEuf?09afu6gh;tzf|}fTaE}{C1FmR z9n0I`>UxoDZXU`3^?CYfAScC*R(vN>8WsG)8BAQykE0XUPkh$P5yd<$a_Bf3yQ7ja zkr7|^X~<=^7nr*9G+S)z@?{%d!iPf9 z@PNticSF!xf6L7@4o<99AEaO@oWgONEx8t3>Cyn^p~-M!?PymFt;iE=dCdoa(GwD) zkMLE@B~H`)i57VoUeXz&m$cKddO{|CI**>PCgU!RcCIEFsNm5PrrAeN*r`ZQiD$Ls zDj$-hjSO&y5_4s=xChwt;TPn@ee>@cg-INZAvcZ~_(iUSJzt}g63&XgFQ3BVsZ|0? zJ!CYs6P5bR`@Sbi89C#vjDi0_gzGXtka%DAzqH@u%dUg#4M{oazlD1cwpYh|(YNCZ zILtst#h*M5fp85wWAg(yU)DmXSN)vKse0wudN zgxQWhpvTaE+H6*8XSwP zwSi)y-v_Z*sF>C!TV%Ji;YrI0*fZcYu{zM6Q~aU*W{zNdD>D~iMM_<-B7L?jTO~ce znA;HXwkRf^du0vf$Eu?gj43u|eLx=b+8#L>0PC#bH_tu6mkg`KJS2SVhn>PktDk?W zQNnMlS*U^UA~=(dg2!y$dAk)4Q6-y^d$0>m7~+66FzPD_u0EHt4WQ6J<^>(r6yg<5bECSP^a$X`rYLTO;yx#CVyQ|L{?l*`u=Q9{C?a)G&SZaxnYQ^9M5>F!Kdt zd1dVSWMN*(_N&Dfrh_%mD`LTnaJ7W7Z;u5HbOuhqv8^a4zHNRd_JAuk;Kc6MSgw-%SS9VK&y;_Qr9~`js*|-_ zNVuBWVpxYjO|o`_kWx8yjk838Ox`R!rUJbsSwoQY3R4540|YiCYicC0CMj&r_0kR< z7jN4nRqE;{(>AGIY~>0>r+$0Uk&KC@Gs7!De-+6gq+&?9?=u$*x0j&XkN&vDyN!=W4}9~!RAO?1N5aye7uV|-~|?DrBfJ?F%w zhX@5%>vkvSLQH|FfO&C@0^(`lG%5d-pUmju-%zgP$jVHTgMr;8B?vo!Dx=)ZffsE7 zbh(6Om$c!nk?FQ!N55%V+$r~4)RJf+GPwb2FLTxIEF2ivUBa=~fl_U1moc}Yuy&uV zy{UigKOM66FMK`Uc0xvtdUtwv2@f4i?dI%Wn@=_2DMFyj4(y)(2&^0ufl)352w4zd zV0VdGvXO9D>*09B;gzwGEw;i2txyy@c^LwEIYg8Kd47p6^dbEJ82(>{|4Z=yov!~Q zk&#z&o)OLO4r2WbiS;fY7g=YyWxeGQLtC(iy9LAi>xIo6{Nh7vZ zz<11oIRRX69nBp?43TxTSF)W1oH70l8VC92pY8uQr-~$z}DU5H|2X-(E86IkuvrH{|u&nJdJU|m@*EeYP z?R+ORaBy2Qe@^f~yC%g2=Ds`V5_A8pw1?bx2NM^i*7GBea=33%vV2wn)afq@suEV9 zX5oQ@RmEF5V0#*_p;sy>@DKiHUU4wRM8De=&9S^c4KZUYYt$ZKIYV#UZ6)Kiuk1X&FdVxukH|~YTCvSa;r?jtR^*1bTq95DP(?hMV;Kz8_J4yp#ChUP8pS$0{;| znEK6d5Nj<$?6_kCdvpCEML6sUG9c1a6i-!h30)H8feQyOv zYTm~4VMWg-)MX-H=74}Xn{l6~l3@8YzphS~EfGQe7varFBq?=uStU%(jHOsOswxp%4Z9!;jTdTBH zKnoR+l31}tq!wDNvBh@Nq%Bn{QK|bq&zU=Sck=^L>DzwqOJMHKojG%6=FFKhGiPSb z{lI+ODRXxtup9i5+WaSJIc|L5OfNsjIR^CdFP+1!X^z00+VBXH=zL9`F)2z-SpFQ| zq~X0IgY{yM(Vsh&0bPzNcdq09y>N#xyUH1->MxJakR;VA>c!I7TpY^&jLmxuyjY6R zC=B5`)uMl89b3`NfvdhQ(Vs7n7Wy^RRuvH8SKh^z z@p&5NGEXl8_r><(aiUON$o?m%g=7I<*iNzs-jH{E5QmBUJNX3Vln2*MVV~YmFSy@Q zhzy$Z6#^!pRLzPOLP=T(_JyeGV!(mI{;+1R!8!eC2E*Ai*P8CS=k5NX{55)`1 zl}(lq>McAs<5p=8q-t=kVd4g74S%?Rsu8R;@Z`va&+0kKNQwXT6m@OWzBM2hJagB- z+| zIVo0Phb%?XgMm5PlLwD7?vK&IH15w*E93t3!3vhFZHQew>NO`oWOhHx5fXeLy8m^1 zUHD>#Zw>G#6y~P@P$l_jKv16koeVR4BV*aBPX(-&&j+BA^5FoCYaYJVb0??*C<0#0CpH+9eMRCoK^e;b_i|0Zyf^nVAc{`69`Nkad}F~Ai2 zsz<>{X6IC-<)p#BieC*>@8{z(s(ouRFYz=6r`5M&ga_-W7xYvZ3R1n9&7xp$N=gKt zg84I(b^+ZE^%SfY5}`%47sH;?4tq*_c&i?I=T?`?)-EM&ns-(%nt}=Q%$djuNHvTg zIF5o&i>l)!Htgq6tHL7DP*;zA&hHks;Np`RVq>fciSNQ8woi)<&!{#Jk7%>^hjMpd zMj(=N3#}pH%IOXm5W|t>+%@p-V-Z?|&Ki+QgPe!pg_Jybc&xK##Z>?D8e@gSzRkG? z*UVpT5*4wSBHe-Z>IE~WJL-~Jt}x?I9(fsZHut+%?zV3|0My8&*DpeaJ7B73b8|Vn z<2S95K#dH8L=ZvxD7lHXTciC6h*9?4hJYJS>E)Mp{NfgzEztd$bD5}Tt$j{hKu zDj_2ep7b>a>nSYM?Ri!0FlC4eVC6*wg{B2sgCd$*`k5i}HfUPlkP5fp4xKzQR^nF7 zHwD*3O<|?Fbejk0Sxx|#&CWSIt2MjSHe;Y*d z3aKEPDTRepBHQIPCqQ_+|1u(x5R*1(L?bxRSi4_O3)NFy1&NoG(l|dDK8~E{Hv~@M zhY1B*D8=KHq?Ck&`KBmEp9LqBV#tcQ{+;~AT`N$ENJEl_3 zK%m?GY8ctU60d={6=WDuBp@6Y01P`+6*?Ij{+r@tmJ0KHQWMOix2(<$lTKzp^SfyL z<~J0b(8@GAXb-6GDw^XXT3wlel397;a3W%pq*lWSY^!iW%W)+(z{HIx)w3~4r@a-< zB}0WZQm7g=e$e&`d7=}WEf{f4pw*HR<(JWb$;HzWYW{@P)M3i%*bG~WDC3sQfX$KV z^waKNlgnii%)(OMtIuvphMXkFBKvk0sj?%WsuJIYAh8G;aTTgqV0WQcOPNRp!Avp; z5*dG2hgqf$kFCJ%{TkwY0^dP@Gv;#(;Cdxm2lLSr;lf7g#DqK}Ov{&>tE~DfNi)}a=PcHT(ZX8$n=5=NDyGb9Fr$}wH9HdL z)q1smQ;0L_^-3DAkyyS99k2#iA789BEczOWf_PsqMPCnFQb#Nj$+WXUrl6WoYCSI# z>0p?$jWUjNRO!-c2Fz!UNDRGbS3)p3DB@4aL{l>$A#tS={3w{@AaX$z2=#)2eVZPI z;e)1SbC|n?D0IrdCS$t%E79Le&?LV@2E{>el3z$D4b_Gkbuza_ZYC%F_Ugy*KDUX5~A4E`y}R%i-CH%s@OVzWY18H(PsWsq~TEG(cjLtl!$ zp#!ej9Z6G*fZRqb5}a$Smx*|*iI1h>!kSogYV#zp^nVXu3cu|F#X8*|1xM_TWSON; zV@>g{j(9<5RmaLAK$8LiIIWa!flo|1b3M`Ya1HT}xF8q=@40dJn3WI<5;t@o?qn|H%z1F8)rql7Ajf1Ypthh71np1;icj>3Mh z;T_6@Op6CXBZiuqZLuDNl?|o1us<%9Fton4weru;o>lsz4A_OsfXvJf^LX^Hr4;e4 zP^8MBsJi(YQ1v{7BvN&*StvP^`WRp|O}E3}U78C0xMv~!LZ!&lqhtIMyWhUgc|5q! z`H#GP&Npx0=X~pyea;iT_c{OBbD#6=OZGWW^1Ki>?*^kv&rqfhdZ{255}wifIA3v* zP_w=UhUQnD3&RDk=hf$=Y3fJS`_VzDw;f5O-s-M%x{o(bSzz$hJ@+N>)fT`XM-5nj z9q?CGEGVijTToH#^?6($n!^$&5kjvfWT5ofq}Ld{nf)t9FMQQ6sB~;QxoE=;vuim- z$_fq#WycNYWztLqqC)-6P*jRmPEy#HI70P&#l5DvfQ}9b%$7trAbAZ?CE=>YiDdJ< z#taYwS9_ZOh@#+RUmCyBl1a;q`!&P}1%Xyj$y1uum&;C9g!AHxuv8VHs(leQ=nP&G zDUsHKPejG#U#_EntfH;_lUuG&0GzA=gY5uqsArarELV~K<^6F3#oelpcT`GmNo#QS zNBw0%V18`N=5-)P%SNCNpEk})<^hMS9zHxBIG=zgaW!gOS87}i;_@#a0LyTA!qT66 zgNBI;8zVp7oML|R5n=9Ji$ANb?vvU-pib_ONw}jT#Fw4S*)7FO=VSj>#0ngk0 zmz1Dz6EhSp3yPgA$sc$3n166ByOj!A{Sa$Yx0d(ybO=jRx7Jj~WB7>VNBZl=;&9TM zA4ym5tDTv3&f}|{S#{2TtakRVbH2IS>8NwQwc0tL4wepjhnOGh|+L z2i&q*hZ4-#D7GpaYS!bW6_zbk0fKc8tKxwI=5b++t0WVN4MF0yt5=pB_sL(pp9qpm47-_vQHV+d=gcFr z9iC=}^YD{BEok72kIzAL-H|E70XgE*1y{e zD+34Q%83IOmy~h576lzHG$ag0fevKX3WQT$(T{#c3*`xBO?LPA%2O@!V@^=Ja+=1nm|!5&!@rP-8tDu zX=7>6;tZYG!LxJb*fhiIK>yFp~fs}0XH`)DdP?29Q z;ceN(>Tj#EKX?HGzzfOt2a*+%+U*>(j0q5N{=dTm`qj!!colS11tBXAAv_cD#A5;%5Hq5ybK9Uw7IUIWwXZj^ zkcH{;tsj_0Skd$9Db<+9Mm=h{NV5cDB>8NX86ho#x?RR0*T& zMTUDWIhL!w{tFo)V;R{=ofKB)V@X(W&sxaV|M>YW;h$Y7knqn0^3O25nfybWB5pUU z#2zxWETKy3RIREKF`!C2(M3*QCCM+M^UGp>*T?dE)tP>@cjN20L6N#0&m%iO2>|Tk z^2fYB!3ociAM*LyP9{I{Lq>)I^ec6;nwoq@H4Im}t$FS`El2`xse>Bv(#N1%e-jO5 zF0@!K)Z*l#*f^I75bo{T5aodXqxNa3KYNeRyZw5dYj9bo{{*~&3BFpV$4cL@Ag=WL zS^6flN#ZhbtXcX{l>O%rfb=@C=|hzN^yS4m+jf5+_W|7-UJ)^!w%VCq=X`HrQrP)k zp8K#Seb4y9*NsKtuk29x`+TTZEM`5{Z>~3~Z0u%mMLN_e$$E%S4rf zXdm}d9rqIzhsBUw(aKWDvr<+J!TJyaYxnCoT?WrhNxPdedNnG4G6a5c}vD?tG<5XO^Opa!|p+7D_4<%Dz+%h%;MEA$t@E<^n zW+HqC{3VqzI8@|T{{IdXw=?}g!vro2*meyQ(k)+x z_VHImQWk+BGo$<>Bbq5ah+z%C_(A}*cp1%q!2|@+Dff$Evdld9esDoJcYA_ivJ27o z!p`lg6)qFW4lEc3fn}+9aJ#@O9xN)hAjja^RZ@Zu%M94E0~{{GCm59Y5xR$I6OlHi zaoKDQ%iY0}M4iez-jamRDvp0U^TekB#AXRAnH9=Q%gIl-ulYQ}S?ww5!Q98hgJlth z*{tBL;Lt4pQuMog3C{@TZcvcBUr$y#+0qhWJD>|r#NhVW?j~~a21I6sV7xrCe7?!) z8x($-VYRU@lN3bA^HgrnnKiEtF!`sJ7nhwuxlIq|5Nt*KB_$ZZ%cpr z`4Q%G{xR~Y30yg%G4}Kjg-ySb7U_Cwq;i1erHC&I? z+zafOjkkqt4=L>T+^u>Y?_x2c!S)c^*=YGD3$zq78Q#r8loC|KEa-*_=5V99jUvJ1 zz^glQpi)jf1{j6r2O{s#mn@qo`z@O&n;}0D5mP?NZVTtZV9f^^3D*2~w5_yHrXGJ= zIsQ74YbWC`mUvTaBM(9|Xs_QB&aCJDb+E8engZvKIn3brh_vVBRA^${4fRp&F#aBr z8#6&=0l1(0xSn?XT#2S;WttAhR8FWV)d4-Fdg3lg3VW|Of&rWnMav=?Z_?#cO!)Yx zYSmj+pfnxU>|4y^Erl;JRHa2&Q-Mx}MLv!aoX^ z@Fo-vAc0?~H2GuBFIGa`PVPxU1iHU?%@~|L;cGHtpoAB%idoUmotbK`f}WRNk=A?w znFENt2Q^c==;PiI518;>*s7wwtYwnIlLC}|O)oV^TOVL~a~g45*+N{U5VzpY02eH7{&WkRE$`$^3a+t5q7 zZMhIF-a*yV1H1@T4}VNm4_E6)e#qx*J6X~rKV)PmK!4D=Kjhqx#yOlH`J8IRSCMam z^5{ciJenUFr7*Ih{Z&OTr+jrT0-lW`HRVS(szLfy zT=yUUd#WD@BUrM|LO%c@_Dd zjY?vNa-qV=N{)-G>b*VBzL6Klv)k_g&%R%fz_afGpmr}Q4xY_LHXLac z&+Y=a=Gp!5|0j4>_<;g-N!3tMfQ+h`!kiH$)3h^xEUS$Q{v)xN3%Cq-z%TNG#Qk+okqU8$PLF zXDe8>EI5%5-q{0YiBpI?i!|0@vOa*0@y;oL^DG%xeQ5>%8Q!6c>OTKqcE6B>RGb52 zdKcg=wtIh#OoDM<8W0a~PaSjUe(pJGCTk6ru_3MbBE$falk?-;utCEw)#Jyfa}|TB zEnc;N&)D1yEU{K;+V@7qNP9QBG_3Tw z*J_@K-pUAl5Q7>B{pkexIP`K5xeW^``?k!91>7x*Br8TEoy{#Dzu-=9!5$XY_U}pS z;QNRC=E#OZ5WF|o&RkHj;1Kik(T&+vP2J_AfZ`qy*NsoYe>UkX^csdvA@n-H_0hB# zy<+D*&7DJ#N82ohR*ehSyhu=32(NOM~{-AXInSV;#>Qv@3|p+3RFqdWx@k*h)oIx6>pa26thFPmWbyGZ%` z?>KOHPy+q$tXMIH-mPi1?`%ZPmS3+TU>wN34jG0E*A>KnE9oy_|FCnNQoOt^LKg$f z(S3%4AEQ1Bjn!)0b!=XO_K;u>DIrwkM0j!^tkNPnTZivjw_8`}agB%NMCp7`C`9&w zB)JhDi_Jx<6LP@gM9c34p9E>(VeWAnk*htTOdv9;VWD`v!ATv2Dp@f1D7n@GGAT7b zR?biOmme^E*y+)ggHKQ%1s-sQ!C8$i3#f0F6dWOus7hxES%8)Y6^Z=I_i|4-P1oXE zs`cgbVS}Z$izqQI=ep5HY3#f4GW~#6J)gfUeY(w$lY!nreIFF0}m*(b$RdwFgQb zCtuS5rT5q~;io$EUe~g-bfP|SgcAC5pI_u{$MYH7A^;0Z|FtYS?Nxz|{LxL+1ag>{ zJRZNfT@ww|O?0h{UTMvLl7!eG2EkPm$szHmZxFY#c{ij<^+21nDWHfRbK%s_-qPQYII2C+jtgNZgt$<1-KZ4TP~DR6?>?&iUY3m^r|cIQ}X+-=MF zJNh~W$8h+Y;HRGaYWVlUPZk~kzje-nOmQ{`-$d5v*4yd(Z*08AN-G&Bm8NM<7%W{7 zq~Z!2%h^`dP1vTgTs^AZafVzYJ0Sh;t)N1>iDPsn!p+$W}%w)60 ziu+`&JHd}jMt&wCwvo^C28O+UcM1+xazt1ASUoZQfPO%2>4W|3LKb{h_JH}lH4e1# zRw?=~ABTWY?toBcZ9$}1A;(uVG3JjvI5u}PHr`V9z=(gS@IcVET0jqk3Xi5_)^eir z6AYet?k&0zd=sRXV_ZXL*rK}YK&ch_4_gsm7wD(DD}`k^cUOL-hkBQev{!B_{Cr_g z>%#zlQE~(I14f6!_=*nOqPm<-a>Z2;u7<^CTVe%2VU`*dj8#=S~H{?lEx)BY^{%jK!a{|Nc_=Fa$6judVWo#3bGof-Hpz59N2<*@T<>+6a9 zbmn-pFT*0K6G>Vd4yOg3kC~~mbSj+p2~SIn9fxAd6r|MQkp^jGTZ;2BrglCC=GmU_ z-cHWr9?--a;=BJmwAGzR5Z6|-08qPE7Tv9p?}5!#TT!l-0(?8#X9E0H@PE|)-=3%+ zP#)H4dDve%V@w{7XeSRp(TP0VrMu#=@o@wxF9AWOg0yY3=fr11x_MEdB`$HqtL%3GqVs9{zX6 zVadE*Q}DOKa%nBI7%ki7&@$Mx0K!Hkc01ohoa|V>B_8a(L(U>3wJ!Ic;=v~T+Y8SV zHB3ZP_h3#Ob@!Kox-B4Q9CafAuv8M)qZp*FxmG>|cad`Et_?|*UEF;<#mfA7$BZUsJNcZ)wPxbe ze@sN(DX_0Z5t~RoX&}d@0X2Q^?FYe5mh?-{3>c z&H~^Uk)*AbFDupv-n!L1-rL-&fI7w~ z#Dwv`bKd=_&Ce-7WG2UgX*^muCq1lKCyn-2?OO%wAX}JR6bk_7jS@JK1!SlgdIW_Y z5Oz%uD}HTiDzdSF0cdY$sc ztT?XWW}{^r%qqV!%+-%o5U;L5iuq>hIf-T^jfsxODMo+PJqa&3)P$bi2zXuacDF*Bst`W0bK8; zA&JZjg&CC}s;9MGT$~uGgs*_62#6{eH!9Ga*p3R>>eZN<6otB352m@Czr{vTY*|S~ zIIr)-Ho6U&bzvKwQ5<3d^eEftwR{hyMYrvHn#QlbiM2GYWqaYeHMuaik?mf`@m}tP!_P?>Eyfi#1q=DP z1Mu}q9N2gkpH;E1+6W}_f_vku*5M`blLnNCG;z3|o0R(71~GevH5AGCupI3gDx2N4 zJH5bPgDjWBEAI2^m&>p>p@~J8-~CU6e?VkQcq8?a81ibRi`$`&AS0$OgNNAifpNlM1iQ@fK-R%S7_ zme#<(5+s&-?QZIsA|(+scWW?wsRn|PzV|`bm{D-EanuJAIQKe^Xc2W3kXUmob4L7{ zg98ET6Afb1k+Q9wA#DYm<7})(F_>O~b8EO|tImmX5}yP;16~oUF*~qCMkZ2NB`w)z zfD+W;9A!CHJ``ZuFBH?>FfU&(BxJQ*PblFy zdK55Os90N&Clpyoy^ECK7+1TK&l;3~QiA?=QbK~1l#r3m6cplbUckJRV3NU+9C`X; za?F%ss&Q3HO^%E&HSXK^Q6M!(5w0X~0#_0ohBeiUh7#{1*F}%0Np{M^ z9PdpYUInj87~|o!2x|yDj3=9wJWRhd96jo_Jr6UcGai<3#ly@?7*sNi@o*dnvlb9~ zI`Xh!Ae&kk;&@onGLoL!oqTE@J`O+rgog!;JWL$s%uCIVVAUNwPFVT)5BiuXEtJf3 z*aJTXJsJWt071%VzFCTQVR$Owgf+?;qRv7E=E6^|Vk)5_J)tlY3G++pdO}H3dO`sr z5MaS1X-zptaN#HdCU6u%Ejh=cP|kfGvwkJ#9QIYUcxea>0Guj5VmuN-SVQ0hoG}N?JzJQ@fK-%_FRz<`DrSj}V6UsJWAbD@I{n!Ud8k8KnaVvlb9~Oh!>tsC@E*U?4A87~&!&EhFiv z-N~nB6joR>ihz+(h$AR8GbyKp31PJ`F}tJ^CKK#|0?a2G0{0^!DWiqSV|W*?qC#F; zdILjDu385_X~LvhCkr%>l6mfPosbhr6!)>RSF9TvcY{OeaAOlaLA_eFd z0@0&h+w(AE6c48)2s;T^Jj}d=K_%0eu!{p>)&fFLqOj`$9u^E_QwxJB>=-F&8A(s= zPChjcvwoU~1&lmQ9EwN{fq?)}bW_5v3h#+*S;`QTEoZ||vM`m9g&y?^wzT`@fK-4u zgf$7?ku`~stjS;d);_`d{_unXd=;FMVVG%!1?UOY6Q}SCJ+(WTqz2`t#G}8R#FHRX z;*m47#G}7?ys(q1?lc5+Ss_Sosw6`lDio?`y3V-0dv#-KsT)0^dZ{YcK2lZ5O$hOk zs~QTh!a2g_BHS;Mswb>=`p9aBaAwCiBprhRv5wJ%u!cY@p5zr0jD9I3J?fPmqe%Lx zTJ11~9i!dSS%Ou+U{=EPl4ne|$AK_s0ih>h>6}m27Yt;53xg@!87XNQNl)!gK6Srf z_3$SXMFC^KAdaAr%p{zW?S$2`-IPF-?c-}e3VUEHR$dK(HAqU*XbIYgcj-plE)~Ar z!4R_>ZGoReWGW#dJ?fRxJwFs+dg($0O_(nb59bT~m9&C5OgLdFdP4O~FWJ(=C9z`n z^^DAI6Tr=k>8cQ5{r$oiDt{_!n6zH9A*)I@0pgHJi(6v(D!I}V3NSZ`t&v#1O01M3 zK!k$=Oo%T(5+Fb@9WohyC|2<_mSZJI&&k7PFHeV77w@JNnBK2=qLkAA7H#T0|&Rck%i{GIRv z+g+NOp5}g>>9K#29XW#j2D(Esadr&??5i5_3dIP_uHh9-OvMOZIvqn9VTy`J2_uj( zQSl_gpcuiEsK{XS3#ZbfUfYkMj8S8#Eny6ma3w34mk0vMG&Y9DfiP7f0>ScpL^2E;XV2IiIGvOy$ zm`cb(k9w6cbOTU9n+7Nm00d7E0K~-x=dbjx{Y+oaSLt1nSAfX`J3aWw9bfs4M0%h} zL6REeBbpTW+YO(L)}4h+p@&cUn{NUwv^+V504-0_fVs=ECpa$#4-5^u&t? zzUvxGm#beY37AY0&=a44?}-V@5rWk}o+$ywQl7|LSklJH6A7&s3<>gtA)x>>&Iu43 z<%zrr2FerGC?-z`lOuUip0NHgc_MV^Ql78`7LN^*VrqHPJ@yiQ68$V%<|FYF6fsf_ z_A;5HJcHr3Q^7+xQ}7Iv@-rYNc*fzaAut6`Ft!LD`lS!hgEcsw?FA3R5(ST1T}rqT zJj_d^iews_q{M+RYXPAraREx%A{Z!JEDYu(g^`k$k@VE= zqrf=|{C`0KIbU%YgQT2i8;C);-TisoIyCL%*4Z#jVrq?%GI;A!oRGxwiKhhj&4^KAHT?+mZ_k6rSnQC5IDg6ToQD|b;jASu@Yg@2*6%dH!?%eqYjaU=e?- zkyii?2{~;GaZ>h4G%^nTWA=0B>~>Qg0Otd6WHj{V*c(Deg3C{>m>jy<7D^wJ(olQ< z$4;?Rz>-IvE#;-!ahLGTo5}cTV{jVFmR}HgAzg5XoTo5d^EagD;NzyJ?%#pD+U3Nw z9siL3%+NmqZ+ou@9Q0l~J#=?k;CJ54SzGpp-Vgoat?!3Yf;ZcOGt+}3i|)GT?me~+ zcYe+Chu$0+%{du5;=N<+4XncyU596w<=7b?JLT&cnqW)WJvKAT`?1jNw$KbaE*IGf z@*+J|1q85NEuLvfRl&ZrkZNX_`h ziK!We?{a)9A&H+$SZM4^Wl&ONIXXmMWV}>2tE(FWNMt69$&Fh(LYd*X!cU!Kd(HiEg_}yoGZ^c@|-Qt8S>1N=QMdv!82Ap z|M=rh)W$tPQv3-n0+44S4=J9oNU-YCAG+!0h?{rj_&kZ7aPm3$Vj~?D&yg zM`jGjdhPxJ8LyQO$Oyq7nmiyQu**B{_sxNW%Pu?8e?TaGKc60N>-HMA{3zOY7@JIWe003_MqN{;rA<&P@yKPe|h!yJ1XR!BCJpId0!L0vw zO1hS7LWQRqpz1J;$aB5^6?I29BxOXlpC>}j{mOUn@&olUa#y#yt`txx4Fmq^U^)Nz z{p7tB_Kp07y^Kx#Z8;D2MczdTLcKFlMHmU`yF*Hrjsx(i2!}xkDb#Pzhj5*MtLreI zNo^ol7aE*=_hCRs`>sa~wfXkTV9q0_u#IL6xB|qtvfL3IEQt1f7(gwJ{_%}SVtCUR zULM(tnnH-TOlnAFAfervzqVz#(+=X|+NHfkc!3{S$U?-rZ7(6xIDp7$LX9+)kaQDb z_Qn@TREai_=HpLER#&+B8@Wm427Em6owqOGP+ z7gEq3_$7P|PM-N-&rM3G`f>mA}ixjT)b~_4J|5ld*>PJVb<&qX$}k&swx1O^qN+i}r0p z#Wx*A4xzq$2KzEMMJ849I06alft~iGcM#pN?(iST9V+tk^7JHMYUFks z*b$9rnQ`a?Ckc(87<{ z+(_s35VSV~gU)0A<;M&R({WLe-=lMxF}~Dh79}BiQ?eP2s*h)K-*t?a`!)rU0Ahuo zc~LMw@={Yk)#_6g=52p9f2Scsb< zr^31W^B4BO=Y}p?G$Gn|9i`)W{zj03L=!S$tL4uhg(@g7IN0B2TY`Z!Fc-A;zY`5* z2E6cj?FD(@%ly0uuh3(-f`Nd(b%-d~4i%iiIJqDJfNTwLCUPUc+SYLwK*Vt#GV9vli2Q(ic5h(8OX=m{nOWcvl-dIksU58&C-6K9L?JKGKskj%y% z%PlP*1wCN1al8nzq4cNvUjUIjD}QF>eB=OP1a_$dI3sqoByUOb@03FOF#WZ!8V&id z3i(9))}d?!p#+SQ54%tUW(E^0~r=~48gjjUoQ%<4^F zn4Fg%DP?i?W?{D?r{n4W z%YXv60Z({^W0w1P21MO@Ji_5!$j5y@y!p`sNJ6+-Vds;1Vxso|Q2Fn?c_oSwUYAN#u=K~$gu*O;SS~K)EwoLCohuwR@b4YSL0jk>ct_FKodHaM zm=*aW1O^(w>iZ=o#F++^4;T;n!{iHCnxhU(3t|100qx14eOR`TpV9IB?__vVpGN02 za^9)FW_ABzSa;dCzL4*BgMelY{mxS`E76AOWZh-pPyfE8mY+kqq0fXfm+iBiXY8|G z%!~eKlwQIQws!rm-0Xk$Rlk!~Wv_dR?aE%4(BrPvJ?_hhwt8Gov&Tt)D?K~?&HJJI zTNTK*kyV<$Fa=|mEiZENWI|_Kdh+abHkp~k&C5VvGz#Z8=Z9>8btuK%&yCy_Gq}Kb zeE;|z+meg;H62@+Q=nj`{M`K<=2|gO;WP!m@esH?*qhIW)Wdj!`g#SD$dD#HVS>H+ zY)ECQF5v}pT=_RL&2!KuqLUFb@YS{s#A10<4khU)!eR_zgSLHl5;opb4At4XI<` z$ETK!jf~vXDz$0C^L(4Jt0DCmd=PBV6L4x53?JsvioUbyuRjXEnhk9lhO`TlBJ0{t zp}#}D8SU#v-P}trq?jv**FT;hhOZ}}DioBPIYj$bAr^Aai=Q)gti)#M@(uL#w`NVZ z)*hnDFh8I){o&c6#?gl1F!H|f@STHR@?M_*jghXN9^%6>VlRR?QnPq|5zF3cDT;6^?+S>K{!Ca7;RhVxdxI4B&g&2;u zOvJ`LF5kksYg6s=CQRLTc`t5;+l*o&fd}s^p0enI2GMQ zwP1WlG+PMq?#+mb8~_mbqh0qS|ARimx=o)BniMXsqrMBd5RUd8rt~Y#VNhUUT4a~X z)1+ib^db=Wma^s8M(RtzfmX;-n$Hgx9+UNZ-^1c+u+{Ta=s9x9qm zwNx~l6pdz6!IoHj>7N`|X<#9@4fk4W-_5-fpMA8A+|`nUAsB%vQ^o~h_^R+k?e%$1 zGYZ>6_ySfI2l(7mlByTDTT-QJomPB35_65cS^0xuB%f3Io8g!gY`Y0cnp5}!S5~m_ z1n(qk+ts-z{JRHAnF!Qlth259O4vBW2!l^edSId81ir3?0?Vhh(yLPu&|+(Owi}9D z#s7I7`2X;kYSg_3>U?$B-}dm0mp)JWl^viY~@f1=rG!hPxT%t+utY5y#<%~1*#tadyH zxZD3U;iulqWf~8eAB|#jNCv)>F9myZ&};q;Kube?nIc$tyakiaKuK&-Rm#piaXkO26_a+a*yYvd6HX_TV4nkwn1#nmhd(VJm8{{xu?Kd(Y~7z zI1)pV6aG1I{<)SvTo^&(Qb~Mbq%)$^W8gYbyZi)eKpp&vJK$-#m>mdhhjlyp+X;Rx zSdb&fpi~U;Cl3Z?KtEffFZY+SI?$W?+lx%iBDVcRGn$7=NWV=~-*P;NnJ!jpRQCpK zjJVlEkzpdxv$SwSw^s0&s{30fa|N)lf4Fc*f&Xtw4QwZ4=KKbTiD=(($d1a+k-P3; zU161!U)3z!m6s2KPLN3NAMrlF_WImAeMdq!jSK8raWG|1?HEcRU!#57lpfP(*|#mt z3{O5UYY=ufNB%DG{Nn!pUFo5WoHsq^hu$CbZcf!HPf!1IN&Z~}bB=iaoO8r`H{NQ- zKZ(J?@HzbBw}@v-gu6b0U7Psoy?$RRlkPR(Afq4pip+qPui;a*vBT)^{v=VEj|x9*&KiFQVFDI|LW>mnGgV;GG#g$R*`s ziHn4iLK7T7$S-fqnjSsCDEST{7{qsqDcxaiW*uCGh@q0^RL(E$tEl@z+PpM{?LCkg zQj^%y7aHX6aA6Z%8eA(>(a{4;{|2D!+j7%#UhttuwB|Hm{$ALWvL~m_gAH1yR``5R zHp`0F*~a3~Fv@t$S1z~vH^ZBvD0UUVb)J+ zyuz>v%NlrR4O-rsbAu-jAp-_Ib{O#vy07=R|1oK8!Az3k{qdjT*ru zN_e2FBBrntN-h`!rj1#_N4+@+Va$vx%`}!qDw7dC$keFS1o}wpyfO40r*9y9&STg? zKYRTyHp2bS`q2MsTeCojnEt~*emnWxi|HVU0p*LkS*-^*Zbu)6f|t6FyoOXlk%G}z z(A0ss@Ve(_V%G2q8`NjNM}kVN|T^sarE`d`l_GoyXSpkS&qN=cSRRDHt%;(>0Id4|JnctX!hoah#U zGcWoZm1TaYE&8&FDG>GjI22~mEpx`K>isr6-t+5L^*#wt%lZ8NfkcKzlbj=Wh1c{Z zW>ZD5I_T4&Xy;~>S#8{rD!%gax|O51t$aK$uT0DJx-ou@cbb4J_mb_ z0_P}jjsoW>aE=1!C~%Gf=O}QF0_P}jjspK1D1i0*xxaH1I7fkV6gWqLa}+p7fpZi% zM}cz`I7fm13l#VoFVFnn{%gQJ&HvjJI9L1j6bSA9E)ID}{^o>QkxE@1f7$rESDuk-fF{LPy-LvYQz?G|}2nNpC;@C6fd zC-T=lb-KWpO`4R)_p%wYz5K1b`Q~c=R!y2Xjlb3AZ`G7fOL+B7QzczBGLZO!TW;d7 z*QwHbr{+q&-h$hwGyFaiFa0(?@W=Y`kDK`XOEVqg=@?I^o+k78uiARmL49 zUgP%4#l~b;2~wW@zZsR4jzz^4%N+BTd0o|x`IR0ATH8@wwxFWe>+`sVnpx&mdR-OX zvf^?_{3T|wS&)LBTBEg9*#l7@E1cZzMhWqvU$kbfs$00RaQ6@(>jJY zKv7?@XPIO4V8@7I!>;S;a5yGaRxR_CEpU4s152)U3?Dmo%n(L7ZYg(FR5%KXD@uW6 zNS@2>sjjT(G{Ln)km@?e#EMdntGL=RxvYGF%hM_3XhL4=xW%{3;q;W1IHs4li_1aB z!H!!zmA)#+s1bu5Q!7e__H0+7)4b~b*xf2S2D)9vsM6K#@)$OJ#K=*juf1-}*oiky zn(XA|O8J{rR_b*-yx@ZJV$TAXFn~#2Z>6KkQ(5Awu6C3yDn=X|F0RRpsTGTh%gaj5 zShtH*)_4=+mM|BI(%~hQnxcutR}QkBBF)axnk9IcTU$8@ng&GxM-FD`L8 zv|vX*Q!A=b#j=tzNF4_n7_AR3byRyvM6YY9SCvaQw^SejSKMHL@{2qw@sxSXN+80d zN|MCTvg$rCy~AZy$B=g|U)qP8<%tWHag*{L-5c~N_Lj{9U$qlcplESbRXK{_B@rNc z2;qUiQf1N4iE%)VvTBFJA73>_JqR3+OVxxU8jD_3R#E01 zc(pWAwY$<+4%y&Br8F(uRYh=5T~JZ!VV%LA=nNJrUlsV>1&s46fe{Q?p5yRf09BpX zQ30`nEHyE$Vp^WWJ{RLU$|JKs#{{&QO3Tw?uh+Gx%FDjPYDvDa-Uoga$!<218xow5 zTI_3nQxrjc;zxPIn1nJD{Px0W(-ijkzKRm^wkkvcGjzuKR5j)SW@B?^;cyhVAd|hq z+31?CA{MM@euc)_p2kzX5U|A+s+$rBsU7nw(I=$EbZYjiB?y%CO`ZJIPqmeF>q*(QYL*Zju52!=>(6C-j|CYalmA(pdev2e0bH zXSd*E;MTlR<~?y#N*KTOViW0RVElu0meB;ms|Qlps|F&j{8aHBn9eV-W{q8>=^ETB zQ&lnAl?}^Tk6C6*uFFJDV%UIWdx#E<^I%F{y~#c`z$1{ezIZfN9uiYLpGzWZI@sA< zkZ>9=c}`V)DpuW{*ZKBJb1II)=^3h3_A(0rm*o!3+XJHlzaG1^h1 z&^hg5<%+@R^a0uCcbE>g0p9jkyMsg!9;@Rh4CC`{}Yt+yX4d zv0%3%QHX?i59Cl>Y(m@;H%909ST)a8Z7tXpQ*_zZF&JHU&F|6|%(W4rbbLbo-JolH zS}p4pV^>gdA!y_HfGmH8GE3@&{+q}L777!$S_@06Zj_gBR$cYjj%hUo9Y;2($~X;U zH?{>gR|)P0od~DtL_MI{Y97~Td}R<-m<2+A#WicYIer{0LCP^p z5j1h(ZY+)FVTPK(wOFQ@b&f&m{B_wSrW<7^oK71z^i)udfZ6^M5LU!!ae0*+YiDpz6i`NeoWmNK!Xn2%UvRSYJUUh%WUbfd1F=S_{U*)Rdp8Y%v&JHcc0a=|#Te}PgP}gOoYevxsJt2C`&hJqxVgiy-v$LlsNU85tC<1Kg;#Enn*hYv^_my@S?Ll zEx0M?%{IX#0aIa9b-*k-#UGP79itQK(2e>NgGqYSU-Kn*h0es6F&LdbVa#e5-Gwev zYe_oQMs~U;I&F%0{*KeZbb?*Wy?DKGoaz*`IF0UeB;0N)sNi(cO!JsH$3;xM{nr) zn=5bJ;(7Fj>n_=FL&GzX8#>D`ZZwi*8>Dl>x|Gb)opdtSh>@(TG_gHC;X-v@#2nGt zo2YTG^k9{&Q6K0Ido(l*PrrFVB4C+O3P|8nT#6@RbH7@ZhK+S5AJRG_}B0HUCvKG``&pE-qLW@cNhHm z;;+p5&2`(BoV0)8j$eK1iORoU{;i_dZhUrS)R<7SDHy<12eey)wl)A>O+3ODvbUzvyvvhk~`m{Cs`_Fm!=-~3lTF2eL<5beb+TDHf zAA0GE;*GBl|ICm6k?IWmyl-Lsud`j>eq*%nsehh7HTe9;KK<1rSC@USdF-;M-|3wj ze(}<~zwzpjML+!O_~kqQm3-3!doC>a;=xbMd*lxzJU@Q3$IYMH*Kg*RU-{(x@BHc7 z#arL*dF$$5Typ2vetXTr@Biic`<{9Cg4;j;%ggTh=I@7AJpQ*ER{ZS!lu7>QE}H(O zm#-|@^v99aKY8oCTOMq zU-;GKMc;buQoHV_p+W)0ZKY8xuKfYzl958C~j8gBab(^2u zd+6AS)V|rHorNx6p#IxW{ruN&{If^DPhNZT%=wEy_vPq@?CP;oKV7yg_|@+{{rr*UcY0oO&Gon5 zx$wT#U;F+uzxeH6-tG1AK{>bGb?;|GU;n{RU-(_id+GfLkDE59{Qfl$Kel84(biMF zFC8*I_wGf@!{7Mf&KF<(>%T6zZ0HTQ-&3*T^WS{@XTSXY-`=-h{;3=9D5_lfg>OCa z?5|$?JC8X1*Zw8!S;{V%i zcKJMI)mX-usWh-LDeiR966g$(1tw|pTx26|P02}y(Zfer3E;V-0vqu0lV+8$+Hu2p z$B5C_#wH9r-W9i3M;u+I9XH-Fa>TtKEUig_F)Xq*OX--YHMh0q?xLfru5y)>L9K7? zi)%QOW}O0QnE2{<3W&ODST%Q!tq2?)a*n~q=Jsr2Y+6iIdyJ$V|1{1-IBRQkkkV~S zjw(TyX%a<~2JRd`_g=b#(<(&#BDmz=9G+x|( zxj9v5?TSmhJ`5G+egZ1iZf8d2=0sIWOCiK`O1=NUO%ypH+EvO}ACIq|@M0H9oH&@Y z%yF-4*^)|}zv&!E%Z&~=6mfgzOUTO!x1h}|;)ee9l zX#%XZ$J!Ax0WNO8wIifqsB=Wka!yF6n~&o+IK#y4RK{ zJ}!?l)JTt4GODV*F10fTg-I8iW2CL_!*RMSg<<%$Lnx49+gj?R1Hy__+e1K)(cR1X z?HXSkqDr54Nag$?>iiXDqJ`ALLyvBkm~6n2z=~>U4tSu|loOrET}j(zy<&S{JoD6@ za-1HYNvAlpaw5d45(lzGI_Y}FopaL@P1)gNe*DvLvHH6)-d94HF2b2b>_K4fwzKMM zX<&*SIbw%{m&0+m|GKeI0^l-12{&j|F6tS-Pim%@2z3loX3Aw~C=efq*)fY)1RX4< z!#qJ74=!oSab}UiwL8FQ(X#Sx0+*ROXDn!rggrItrqqEsGJeO+J*3JWj{8F+)S}@uX*+I8BCX~b zZyC>t>e-O2TiWf&Sj96+Jl;|qESAeLdaNk$;id{uOyY$AwT|oA+e|XuivyZ^8?jg& z)GSh(VVTHt7fG%HSShf6!|?%}^MbnFQzol0&iJ8iv}XFC3WIoL7&m0N{TP=TpWThm zQys|em)s0I~+ZGpHJ>}lsLva29`NK2@byb=Bsmh_MU_j3=7Dng154ir^R)-mf@%a zP78}R99I``fR8}fqb=t~hFKO&@O|a7Vywj8%p%#xEdidP3FM45em8wHkdr#^hJ2jU z^VEtBnncWTs-QhzCU+{ZB~;=eS&J==fGp@x{~4q${`;y?UODWmN-9%6gs{$Wsc^Is zQzfv6khQXcL{>m@s|3smeY+apVp+-AD>isS;$j?6=1mV7G&&&p5Ohg0X~y4pr+C!t z5NsNY*{?FLO6(c3lvOk}`@>ZRU_c+WOcNGm^)N)4L8Y$wWjL@KzX)#EcIdN1X2d$} z&5*1(Bks5|yA+Z?J0|XRAJ45U^+6wUJC2kKCLMk=G!_+RV1eN?DvTk<45Q3gWVj56 zG0AY_x5T&?{+o?rgqH)xBXL(6*+wbChrneUu^eLsRrtJ}VsiqE$EbuGYV zSdqo2+tyW#9Vt1Qt|gwS-sZyE!!Z%-W050TCB{az@@jXZ46?pj{bMFKI1JR=468zT zc_|)nj5PnwQaLm_>$m5`Qe4feuD%|Uh=Dz)Lvmd2kocYx)x8RKIdd*T*3^PYSJZ@- zBu3B45W3ep#_?@QHKbvMcm729xxqAY#88Yk3J&*fW;@{JX? z*DV&WV+6IWF;|Z}3LF zcT~A5M3sxdSZ-uHD;Ae|Dk~OYFqn+Pk0rPZXWbl|e#gx-W=$+`&asF*M-h3t*H>Cr zIcLn!VRNwW?yH(Jb9#Ik3S0{&p}AeRxfCkA=lfiqWysj)axNv?8wg`r0HOjWPM$e2 zZz_6%E^s`;bN+J_Xh(s9>651)c&ILC((}K+ z@DamD&%tzTA-KAF&SDV{CD#p~15NJ85k-)=ShvsfEtsQjR1P0mI<%^EUb}40y`H0h zP~hH8Nf{s3og?8n3Y?=rA_XR)KYdu2i0RzhISLpCz62v@L=Kq0`hCK;l&!8F_`SmP zlU_Q0M;v^?23y8VxUS-7Y_?_0hKrBiAD2Gxm@VTexUS+Ee)Z#t@!R9lU;HCm#&9^o zo%=g81+=}X?+;8Bz00N6nY z%R}0S;a`K_0K)Hv`y|};aBl$r2854>KLr0)l<${-T@IXIhx-HkO~7{yc;3ak6EHjA z|2ERxf$%o?Uq|>vygTupgZMRgFGu(ffpZ_6131^ieG0A=aDPJl=i&bWaMvSEI_mo@ z{6B&JUr6_N{7!)THsCG-zTYGMO}M3a|1#1)iQnD8I|Fega1SAD5#X1=y$k<6_}z@~ zJ^1|s@V$@Ujlh2&aQqBuAA3Dw>?|0*OF!0<6{}AAP z3}v1Te=dH9;kOBKuK}hf;{FMo+kx+oNS_M-9>nzq%uf8iio7!s=Ed)=fa#C$7xBIT zzkk8|ylZx!;m68>KUrWC*5hkF3|%mLif_+5FnNIa7V^6WaknE~E&N|Y_=CXrXTbdozsCW?zp==F9NzWc z0^s7`WeEEn(hLQ>19LA?T;7-A% zU!7`P1~(QiAI=T867I`zPrx<6y$*LAF729B!vQxEZVFs6+`VvKxCh|A1h)b1hj4q~ z4#B++_ZFNnDAl+KZUEeMaI@g5;2wZm2lpu4Q*e!NzlMvzMd8v1ry5tljfR^HcNg43 zxaDxG;l2X58SYuQ!*IvpdJRc6`omofcP-o`xIDPK;VR+ohYP}e8SXo9TjBP>y$W{% zE`4aKaTVMRaMR#iaLeJ=!~F>EdAMV6@51%`RI1SrE*owb+$6Z^aHViQxB%SO;eG6H9iJ694;U3Za5Fz3b@b1 zZGzhd_afZy;9B6`gX?)6+6-&I|jEKcNlp_zOmoUgJdmodk< z+qlOlGUgiGi})q>K1#8}FdzF2ZtO)Y#7;;#_C_j<$FM(9Wqbzv7uDFS@EMDZCB{tTldaJY;;) z_>!^Cs5icBe8pIAeAW1x@pa>2;~T~|jc*wnjE%;3j3|lQdOX?!p#)i`BhdF1+Wxn*gTcX#K=^9L3DWglIZZbyb^DUw4-v3PaKK88aZh?1eGSgAyf3`NvPkz$34 z7A>|YsEC%*5|vs;u^{6hpXD*Xz0Z9mrTxBsGvE9%JvZOVz5BiQ+Iz3H&pB)TP84b~ zUKL|fxS_c*9^=_^_H2-0mBczt1HC%Ue7|Gq)i6+rG|~+cuQL%v(Jk|ytq#cn>Ao70thjgw@Khs*aGmuOEd#hW#)bvuN)DH zR0hft>k;!Rjt3}&Lp(q+JK}+wC_-vHhT5nk0u+lOmY135#{w;2X;@I>i7YG$y~2qZ zh(6qfjKi-)pXtL$FRlj*Ale4xR#&+I6%O50dOf^?KCE;H@t4qJaHAl0&zUPc!@bxp6H~>aeWaB zB#B-Y^>=hZ@AO*ufOv-oQ>T4YDUXrCVRpdBbR4u$uTU>_yYS&*Hx!a`UK%M@Txk0(Qa)kZ}zE$peY z?r6ZC4^lx9DzT6&xHmHP8wM^uio2NG~?Vzq#-7Jk_9wPiz`4Hh$}!A zh$%o8zyeL~3yf6fHZ3S?h>s|G&ZX0kJkVs}z&2yjlwL6GX+*$l#%uQWa6*q0SvCZ`WrCI3bI&$a*Hn6vjb*H< z3MceDi-D;(5$$%!s89q&21$C=0C5_1)o{fFTPh*v2tK- zd0li_dT)XdQEiC|PYCPhe$(_REdloX2TM=y=7b#^z;|L1eS=YY=vp94Mz zd=B^=_`l--HA=V!lml7{O2^~Hi7But#^bsZ^kqazp9vJ6pMilhx3}2ECwu{VVoFT; zH2dWjhQE?Wi_)i+y(xV_YWlWIQq$W(g`g3j)BO^*;3Wf7(?^2RK>IICP2U8fb-|>9 zedzD5L5ch{?0LuR{~pA#9ip~8qzj{)`FIU?gll2ib46HF(3|fVn!-= z0JIIX7PJi145|Q41LcEw&v+^3-3pq-$Npdqxb|KX}hJb}L47&|(`%E5Lz`isT)jfH3_F$_!U zXlk^6ihU?lc=#FfQ(+WCpC@y7(O<0nM^d9;8{DQ;Jd&@+OP#s7sr1!NcOqkLYSdhd zQ&O49DYt;tflSZm!eD#MyOoI9;3Jgq1AaY)|(INANn53Rox7*R8=^<~J!Yt)sSP;fgs`-1=C01?-z)_uSow z8S=8UAN7F^T92|VXsxk%dZd}bS>*yKq#1W}nS~pwuHy<4zrzu3QlD^HT~igTdhk%2 zGZCt|6R@)3%8Hu#9Bi}0;oOFXlJbUT0Oio0-PErby% zur#=qlz4j4yjUS_PoUOY5aT(nqtA_z=0e!#MUiHJiIFmSURlLt53~e1?g$i7V?Q7= zM`%7+r{exQEtT7X*W}f+!ZflzaBID1w@An9^*lNi+@t_z`EMpamBN5I3L}lwg0rl? zJi^uj=I}6Wr>LfUuD3Y2{G@h^s_D`%!1~Tjij8&=(Z8m#(-$`3Ex{CiX?znp6QRFg z+n)~;^IE*{b^@k#JgoflYMLngnO9|W=oAs9i5rqKF;do$PYuDjboQIU?r=}h+M|up z9N2X<#shDnEm8a??4M*vfhkA(nEa_l1iZ}Q!`KM_#(MZU=Hr`UFcu(G2`@*_76M-8 z@X6%ihe^LDfH?f>kFvSQQ^)Wk>ro4iaqzO70{_b}^Ty19f8~wv*c1?70UuDH1Vro4 zLmN%-ucYlZpkxi|@v!#1@*%|3!3&cjJcf{uw$gyy9`d7?JA|Irz)!Og`5NJU$-#&8 z;-of;k(+vGCh8WDLj(!%FQuPic&GMZV{K-6DF$UN`d`LI1RO!6r5u5c*-@Plxxb z2!2xDhQKe%|9bpU#LF_)k~faA=t%^n>6j?DLI^eEKW)JS(#wN4F3=F7?a*G*v>4B6 zh$4GlXk1ws+hqL3cvy%!=3$I2;C*uvM`&5fb8nWA9sHmxt!Mt;oTu}j2Lkd0`p_8f zQDT+h>XD-xpa`jS%uVQb8Cp)vUEko5ASr8Viqy>ksBCLpZGDrS(b8CNHo>I`evo6C zuN4JM9E0F6Oa^Zxc~*4DMBK3X0$UHQA$(ZRUTEhtGm_V2DcL!a7gbjjgmC! z4e2duh~cIP)I!5p$Qh&s=ZaNGj|)=L-iJP5@^OUkCXL zp<1XF8iZz{RrsE`THGV0%GL5%rBPX@>{7l|`l_|+L+Wd4n)ZF|Gwo)*OCMy+H-2jn zbDf!DMXcS{4dg-cB`LB~olHljb>q5iB>vx}78*;8)5d8tNHU2`O6`^QR{Jt%5zUjH z0&FH+n+Zi~i8@;?RV&nLwDhR)objr0i&<$dG#|3g+V9i6p%m8FM}${|$EEw^OVvA7 zQF~n5qkX7dZ@z3Ewth~2ONQBsU1K-dtL;bar|dmw=PE~XvYi%Zv9r>7(mCU#ySz)> zJa?iy*)4R7+!A-T%ke4fUP%+bm+vnO5j24a`N9&ROE@T`iG#&oi3i0m#aE@brB9?2 z(zWs!*_EfsYvrBt9{EH0klZaFk&nv99;HL9eQXcbzkwpeS^mTJqi6PyryW9nw3}^|CGJ%8$#Na~%m#IV5M)f{*h5D8`$r?o3$pCw~eX+BY@~7SFOQpO*UL$wPUGi?s#6EdHW@Dwh z-F<`JlWtgXPsTnKIf3r?HqBAI>#KY%eyD{GD>%24!M2a z82;1RKsJ#svIYBWJ7#7VdDPx(AF#O-UfaXW5oX97X=a*ZOdk7EH;I{T=9v>sv<*}< zdVlX)u}xp9FVk1(?fPncjn1V97=MVp(f)V^ewqwULr5U3TshzD~FVil`4yOa-CYY9W%=D0bqjRjvW60{{erJ&lR4- zT6tG|Qrd*|`l0ldbWXZeegORWtvp!CQwo*Y%5gQQeM=jzf1_s_vOypr@{Ea)5`{*Q zF&ZPd%iL(5Hbd5EatB#LHh>2^$?Nv#_9ABuR>WVNQSSZjF86nUNej?>lH4_X9$(0Z zu#UbX{7^V1d?=m~)1+TZN7472S)c-CTcUZO07jJ(?z4is4)6j znbs`qgiTf&xtZK!KWp!^57{3%=do&MP`(rfaIXmL;ivN3_|d|AtiBDx3*ugJ4MsOg zo++CJ|@9b-w7qIS*Ij5Z` z+@rM3h5+u$aoj5G@y~!_wp09EoGN`FeIcdGBjn@q0Hsa2U42tMjrqEtZrV0){T$|H z;UQs$v_N@L+oPY+(~LUnYg%8s$ET5eCO?Mfd6}OoR)`D4ROt$7Ec%`$zagKOXDQ!R zK2T07m#ey(rxvPbw2SnA(I@D)>2>;X{d23!`IYm5^C#zP=VEuLJIdAEe0L}I)bHI- z+;3d2!&`40Ka{@`Etvc*{0zRHZ|3jk|Bc^=aeO266R!|Qi>5e9yiKfxBseJsr6E!# zR`X=(4(S%T6cTKu{E+-hd8V>Z`LXh*a;N%p^^n$AAEW2%E&Aj7d-`XPm}89Z80|(C zIY(}@KcjlBE5P){EVTE&*eN|LZIxb;c0-OFgk%=Lt)1$t`ULwK%8Q)=rWZ^2AMg=( zk-L({?F#@ckmHt{msr|b1 zU1}^fH<(+@^X6jgvu)NmG6VZy1^F>~g{0Y++9BJutL=O3wf0fFzjK@0Fht1JKbS!)-Fn|@AqU7A)_w?D<*+@%5uH+}*4gVEhHT(U zgG}Dt%WvU#@_YD|!ba%WZsE_uw?siK6>HIhfO%6PL=yzmum>J{c#Wf7(Yn3Mi@(PqPGWu zUQ(AUb+jr%Ml9D?>7DvUod34!uj#w>w{fyLh*RdL`Z4{a zo?=`DUH=E;i1C?m!Z?Mthnl0zai(Hg<}9YLv(glKqx_;gP?@RxP+6l~p%=TEUz{aYiA~}?IO)DCW=Iy!na$Ed>1Wb@ zNyZ6nvRow3mdkKO@RGbtS*Z+BuT-zluGMTUPrFIG11He$X`PUnztK)p`R2_|!ON zoWvEwIU`8VQu~5<5=gI)(q%3k_Or2wO$M&5AhjM5hG$mgcuRY)CL|81B4+ELJVOrKrXktZ+BnPx9{cl?M%#b zfG~x5o@ayr4v0KOMU2SvQIItsHy)xBBlZ8E4mm@rax&Ke4U7?F-OzTzZ|K)}f<}<8qAhrWn)@1h z2v5*C(+zFHlL>ibTHQ7D4xXUVWrkkC6Vy7$&?9()#-TOz&$NKZi)syLf_nD-6AgCurh8LwDc_TC=mE4xUVZ)U0;C&UL%q{?3INi`@JV6(~sp-2S5)F z8Tt*Lpofq@MNi=gdU#Jmm*UCv4^5ApL!{_!JVB2x(e&71M2hfEkAWVaZsm<}VS09%q1W&PJ$I-f zywh`_EqfW-h$qwEG(F!TVtV06nqEARND<2PMbMQWXnOt~$bnX#s_EiY=qI3ykUyrg zuGe(u7SuE7su4{uEJeDYi%^zKb>xw$f0m|I?_oRz)&8LA60{ShLEtc5227?)@g7W# z`!o&hfpHSF31Oy3U)6Nc?!W}{?6F&?74$f zt1Ufc$&$1PU6jaZi5174vh;-7q9axu0i9;6Q>!6`TK`0Ibg(wut*;*+sE;;k9sKI` z8WfLo`U4}4fz`F~=CIcAg1*ee*y>uN+iiEPl*b6=*4DdY&9NjsmP}ZlYBv_2gUoiZaG& zdhN#i>Ebw>x={3AGN#5^chM&3WQH5P+T!CDE!QG0Bqf$DS#h+J&><<&f5NegoP-Vq z63re8sM8zq#2ib?4ji}qL?@<0X^GlUb6o?ypG%P6oaHPpkRGXzjWtHcJ=ug4NVZ4Y z-CA#b$CRl`*W-oKtxmTwKHhAPVH6n}YIHFSY!IqB0{Q8L*e(Gb6KZzWcbmf_rtj+4 zO;}P^HJw_gXF3JTdMqhB)Ew<0H}Yi!Q_2q?aU#Z4TN65zmaw(s%UPb39$9?y3YVS^ z1riua@P-%xJvon;C(V_WrJ?y!t9jH>%bctZ1rn|LaHBTTkX6tW+$@c?%|X8>Xa&Oz zs5ff;3+rz3aufYny?<1Ws zLh5yg`)j?nT0UTks`nRd>w67fC*h;ZZ!wG?J+Mu>6jeN4tJz1MH><7X?|9}T31WQN$vHy@0*Uv(X_8+ zCyqqXMud9lcXF!fIH%pJkB+tnbbGUZd$EnyKxaML1Qz^8MsS2A*N~L-I8G8nRSWB& zMyu0XU+ZAj)d^>?J)LfQ0Lu<%x_(Cd}l4+XGtP>jJU?794^pa7bKqASaN<@Xy5~lrI5d;I7 zi4IoJdaL8%39hff)w=;(ibmaR!Z4lqEGNrsx9WBwDdAS#ED^4{ndesBE+o_FuMeyq z?zSgv4JtX07f27A2~&x2K*qauISYjAa?7(TI__~HFG#QLR=273vr^3y$WLdqv8FMq zt1C>wMCI$Y8m(GH-;0i=(Hm)-{t~_bmLw`JUmMK_O>TI7b_QH*ehO=wV}tFrwf<($ zwD0gGgg}r^cc4}uz>>?Xkd>;(lhT9D-iTdcv7`-4DZRxQ@=|o1KyqED?zhv12}>z# zLPmX58%{|jt3Q4>y>$uOv)Ry$G$y*u@m_PlE3u5I0AX}u-0Wo)fDTF-w<}_ia93n` zVSiyc%L~%0w_0X5uatE#kbxbmHoG>bHjkI33tU5D1DA-%(1QlntbvYYN_n?K<5vlH zXv}lFCl``wxIGNEE7%1E^G0*LoTu7#&_ed5r+%YLFjOU{0I+hWn1orsaddF2S z3u;a%sVtz}fJAdJmeGVCXnD&CHL3cY-rq$fky1Zl+sr163^~2ks`(H~+~a3xc}w?{ zW)PRB?UwJ^DaiOB6}MM(mEdg>!|}%G)CiTO7raUuFhjsg2hDe&WruPb@Zx)QoD8WE z(c7EhT?4MuNDi1d7fHa2SBEgl9HPrp=h84T<-Gl=C!9Ki@Z*xLW{R1OpmLOYA2!5w z#lBG|7o@I&VY)+ZU8j`{Bb4)sRm-LJyoQ}LKtG&H4N|rK224f`v(r=6pvqhwwTZa2 zw%s&a47qF8T%_oilnRC^B^zh066~B4rs<7-*rlXf9X9T@IT}weoSfEfdV-SUBeM zR(+k8&x~;CC(-JhEkn)YJ1s6Eg*MuRoz^P>!Ibj#!NG7v<*}TsdLwLtYje#=DHu*} zypBVu313ihoMe)KUBC*4lXLo3P;#6kC*ULdVJD@ueKEmsa>?t=o$b|`QUt@vaj9$j zk3Lz;GHB$)Z-@WtA=ZEOO?Z86K85JD(}@0gI?-DziI$u}^fGAHnc7os&$EbjUIlL_ z&`1qlT4xh&1ud+@Lk?b0dk(;33-l+@>w`pd8t`BoB6<(hKTPy%&_Z}^Z2|4ugf|>$ zI=tRCf&K~Vt|od1v}}~<70^K~c*23EjUgQn*0c0B==cueK{L;V2O)^vK{tTj2c0uc z^e$)xJgZ&>9XJ8+K+w)>;7tnpBWUSbrb9BA(=;kgC+-Bm=3HX;qsK378*wBlO42WZ-L z@D2t26}0kt=z|vAK=cx5&W+Fk&AJI5exUs~Cbw_1}W}038kwkQQkA3Bg6OxP zdZ&4CVm4rzh*+M>Nz|AuGhd7>Y^fI55; z?+W?=W&93!r=o4HLY=&S5j<4SLfIkDBPjc&ki8VVm(U((^&{V_i2hJRnOp*$LFl6H zK0qDbhjzKg5T2V*H^|5C(0Kwf{TonUXa`&I?gt`n7qpFcuR(dQg9kC5AB>^Q@w^S; zcTq35?f|cE+L4~7o#{ig3w@Y&rGKMmX*c=^eV2Bp@6ku;-|1uYB7KLZ(Z^{I`UJg1 zpQKOG59t-!lRiy*(PwBneU|p7&(S{gd743Apnd6!v>$zm_NN1ACjFAWOta`KbRd0| z4x+Eo!8DuZ&|I2F^Qn)%P7CM|I+Xr{4x?YtujuFWpL96=guX#PrG<0^9Z5&gB08Fm zp&!!=DE4RQSo%J_O2^S+dYO)=AJ7T3gifTTbP_G2Cus|Pla|xTw1Q5dH)t!pPN&jo z^cwvaolf7Pm2?K3NoUb2s?ph0r+ylsL2A$ty-C9~LQOh{R?{f8XpGv_p>xqOpQCZ= z(FCobwX}}b(*`<^&Zi6LLb`}9rc3Bjx{NNTE9gqPiZ;^KbPZigo9IV$9bHd1(2aBx zZKj*)7Wx_8O1IJNbO+r@chTK+58X@m(f#xQJxCAH!}JI}N>9=A^cX!(PyBz4{GY3l zoiN93mnW+?HEwgqlk3mwrq^xzsQR)nxMW!b?A|BzKlN07FVqZI(u_@&r>wUQYU85U z|Na6Yy?uzsW^POT9Ylt@A1(DuIFz~!*?p3?8S+7GbULpxCU_I$tLne2pQ>8E`;3T} zsC(7C4G=Hi^ue{0WnOqV%{;r+&>I;kZ{x)Ngq618IVw{L51=`LB2J(|D&^ff!vx$Z z_BMPprJ~+iDQ7boVGbX&5(^IzInUV#h8zCN@&pRW ziCSn!!O1 z%jUcKN!@&RzCbSSttW-^J@TZS+P?B;GlR{W!7R2gC2>ykP5&x(+m3m@$sjG%Z3GNn&{a=@CJuYqer((0TPFdw!%@y95Vh9i7!)&Xr`ZsSL)c;zE<==g)7j!=0-0+N z)(F=iiU&^#>qjS(>CbbMlVaKH5>6VPm)Vy{f&@IVGLCHdsg&_X%TJ}CJDE&iTdrbK zI@=K}$NU#G6D*~ayO>N-FR;QURn+H8rWLNpxK6WIWGbeR&sKoIo?F%zM@EGUJcbAt zYKoVvts>r3`kYDv6n3YQYK5Jnq*}N@<5!QmJO%0n{h0!-EWafwq6RxYqR(LK^;^a{ zzaAmonj}YGEi0T)LWY!c^+~;ei;8&x$+r%di(JV0zCD3%LI0gVYa32Efpignn=F;! zs45Uqo^NTMJ*bf}`Q9{v+_oKMq=Hz%daf}MDKYJGWkpV&g2u#)w6M)+OF_DsSqnm0 zuNCjji};~9@ohPoc#_WdWZT{&*=jM5kWeG;@exXgWvt6lEsqO0ZKPAveiNB|v3k=u z!SYQrgY{d&L`&k+=NtL42ije*HAl4?~f-vX#DTiJKit#!~>N;z9# zM2%cMSL3aeec!YT8f3MtHco+-*dbu;wLLnN~eU z^@>|t@|da3b-_(<-}!+zsP4iEhxAgJl{sYB!r4v-rrEHdyK$mIXsf}UZf%pZ>H4eQ zgohPKa2eaPz$H@NayNA~gt7f)v%DEQ&`vHu+tfTun`H?bn`P>?oFB5&s^vMicYcWx z&z6=*Bs_W5*tx^ArrPA?TpTtwGn=4)tgcj(wVceiwUAjof8T9+&Lf>ua^B}EB=6>C z+_kl-q;JqAG2U8A+@j60cv&T9>+(2WqjQeR{F=@wS%ne@WED!BjaA6mv24Q5XO;!D z?J9{&{8~9Ku~*q>?SGMSTkt(M@~)Y>HJ~UHHCg)>sRSy+7A4|5E0pDXUS|CIiDfDO zlBl&g*%Y#@O*SsEBc+l{V#4Hbn^D~|4KIymSd|z>4WrUy4Wo;7$qU=EwH~piu?{76 zBai3#5(!(85^1z}G38&;^zB0|l3^M0*wQAXB7`-_aPse8stF?TNmU`wt5k;*?@<%9 zj-E--P8p7YRRTjR2LA9uYF&`TA!It45*4-_EyU#`ZZrz}4a+zSP1=vhIyG@BZt~%f zn|wIrxkjlZnPr^d%=@vFn|V~ov&UE^Wr?u?HxIFRI1edaY=#L1irorKz`dlcl_e_< zlYZp3pRlYX>fUuc%d^%L8`iTOukaI2=GD4<*D7l@vHI3tBEy)zGA_28+ zKcgyMaH%c4re-nK{WWU^u}n7|b5d@KRiR{_bT$vGm*thq-%<+hK^W_YyfBt&+pr0{ z36@{MO|UAIOt311CY-vqCGUuY_pK~Q=4C1ysXDV?`HJCLDTJV!gY-uZQaZtAQp7vM zgKK5}9PfRbhcoNO8V)&U)!5h2pRBNB;wQlQ6tn&|^ zW4_6H_HIjd*om(F$>T>)gLmGpa5lux4hIc3`X`3>J6Q+erHMb_;3s|-(zGKFYVuxp zzd1JIllbE;(7T4Q6P^p{;8%@YpJBtxk7!5WSvlq}q#3X7i03Ea6UaXw6`7hzpP2Sx za5+W(;Ws_t^*v7H51Wj)hk7$+F8}h3C5xAypkl*cyMw`+oC16j)nC)_`$Ot40YnRV zzlaw;;Pvz9U;na*tiwP2hC7nY_d+;CGH1kcR1O(wC(D_~GGI8F`HsWXij7Q^XIMN24ByPpGg?w2BWD_wF6{F2js?RP+km0YB+&9_CxEt311|Ks(wd6v&| zzqJALoa_=VQmUT^cBDa;F4w-+Hk8CS6K>i9) zF{o+eJo{)x?0JV|=bGCrwGic7bTNN*-WWN9`ZpR*;T_;pT z?6VVLP?xiS#=v{?FrNu=J;S<$ z6`>-zjiBU%tb-PjElt%5dAG{CR)J!0LCm$8|nQFMP z7R75SKeu{aY0eiUZ29ppXO!TP_`4C@REA3<&(A68eSnHdLFd>zj*%G^p(3p*(qli8 zpk;g#SO9HDkB#8+%2w5@Ju=E~#^p;_Uv|TAA!pcqfr+a_5;wCciHsL1;lAv#X+NOh zLQ@uEsu7jNjP=%!hM19VQxrAG1j6j8FoJ zP=VTutxb5hrE=s>AVu=!b2UF_=AHqh?@Kguz$pPms7UT|X0W}1^>K^G2P(>fEmD`` zdPS@~d@N-juZA^0(&v8YV_8$XI{K}M8CmD?u2QuWE=!9!E{m{yYnd0Ry-)av>hxgh za>x7KBzO4qo;eklfTc(3SnfXMBdWs=2_`}X+UES6(S&D(Jwq&G!WS5_DvKaSditjY zqIDRkh!@ErkC{pR4LEm%YKVPb&z=ju1~i@zJj84lU3R6dr$7RWP?4IA zj02yQxYkocK$IT`5;In?rr{kXkK{>7J4cYJh&l887lEcMO>7qCvCj81sfZaH4|r{y z727iR6ykOp-g#!KWf(&P>Joa~@+e z5S9B-HPl#{a!XB6)yZi!tk{Z!SNaai|L+JDF(bY3OKD8)SS2A#kE*fV>6-#mf7nIB ziBOS#7-=`$c3i0@r`?k=f=71XY{_z{`u|FZTuo|kWa~lbX_ND$R= z{?uWyJu<;k&H_`1#dd6m#jXg|uwpjW0|i#vldvLkPV3~h^3@cwe@nL-Zp;#QkiZSR zASG<+5hqsCyp~LA)px)!*NP>y2o)K9B5U-61+u-aED&T1D}Wd4m$L)Bs_i$1#Yf*s zsVZ-ksmm81nmR1@g_$}mK0b6<>}fM~SbU`Eu-K2M8dhwL&j<7lD{=dkfTjCgtc85t zM^rvP5=?|Dw)_PGi@)hBQkS8MSceEK_K2>A6+3Hu!^g7z))KCCoyG8eox;P12c{5j zYZ@;+3@V?$$a?TlfhV2OWi~~qK#Pf;F0x-s()T=fLUwf*I5JcOHF84oS_;*3q?fRz z%Q!aQ9+tv&-gT3Z<4EoPJcaCT0muxCP=RueS@{3cN7Z)>MDpcrH8HEy;XYdG3WEd| zp#r&#t=_(oiEC~&2%zoAZ_XNu*ZvD7ZtB8>gchL!IgXX|5k7Kqhr{0P5J;2SZ;#Bx zo%)hKO5#p(Nzc!*^s)`&rxrPV@kJJM>2WGH*Wm+^dQ|rB)l|frmy=7j=|1i7^tGLe zSTQThQx;2OOolxm=d_Hi98Hv?ElCwTsKED0z=MM^Y+cZ`R}4*2@Amq3`*^87)9=UpX}aOKN0r`Pe= za;(Km-&CuL8d-b26rhTWa8+?5wRv2E>)*4JfFe|&_4MVORk5{fv4@v=i%)=+Um3*q zm&aRd<@v)G8zh(r70737JUu~R=}QtKeTiKFEw-XuBGLGQqXaA6Ltpqr3OF1%?&Rq--pNiJAylN%p{z=9B#aiW3fycL7B$x;lX(u`R9X_)?Nnr8S8IigS z6~W3G(fG7>S%?)H7t7aL&WeIh!oDfc{Cl_6au~CaEq9na5!ze560m$OBWsKQwut_v z;i`C%+2L0LFWa0X;0v^wm^a!l(|EY?ED&U<0A8%`ot)sI{-)R)ZH13D8Qy3)vn-#r z|H8*|cfn;rmT#F6#2*X9>GF-O z5c++zZ z>$_1Ev12WF+{d0`Kh~a)HN}3c69TKcA8X9Mx<+7`4|Y|ov)GDpZHTA72POeUs7Rm4 znSt4Re4WG_ZS-(aKXU*tiyG?{>jkRkE32&7_#Tx2D{nuD)#wHvd$RB%C462A&wYta zW>bU;)N5=eIX{K!IcB8_xHNKPS8zc#vU8HEj6Ody#$PDVy>HZsES7IkvDNxTIhdIX z%+j+eA=`U6aknI@La!yFt^Wi6HO!+~~irBG{<{E*`-`kX6B2=VoBNoVOLoD+FSb-t& z3n0dFx5-DG;(G(v39Rb(24Y^0*N0f{JEyWROZWa*Y2F}EtKU|L**kCav2s4rDzhp= z1=>x_%l@WZ^s2LdZ0vbmpz>Gg%?D;h)+TrC*_^_3i%0dn){5A%{nyPtw*D$m_4R7b zTzLSnZb{?iZ4XNKo7g$yt!do!w|y&?bIe=#wglgNI=CWM%+_>!f)#$5Sb~aBf!-R+ z-yIfnlD=mc+tJ>cV7dR2B&V$M{WDgccV*z|uQrPkl&?^rJY(a~-C3Avr^wQMBsQbn zlZA=i*{$qB7&|q%SE5cv9wT<&`y`tFV79Er@?{#qyI%lad_?WoBD&IdM`FtouPPw@X>;n0W&61C&(Nb=%lZm$_18=S@KN%{JzgQo9 fSmLGKTuZmn7}_HeE$!%98ZCBi{%8s4j)h5vg*BB%YZlgmLoF(USfT?6xFu*?%ZJQ1lRIh~C^Rt6 zrnHt9p2e#xXhey{TTKUv?Hbb#OQ z)Zw;I+Q;uVOghGYz4~th|1G%ho(jSpY>C4zN%NwjCG}|S{9sy-WSBHMDo&E(4U+V% zNVSc_wFTEH_@yhl#$~h=CCRv?U;fvFL@=-73L~t{ z{uD`CI(6l}cPn>Gl6gH~fK&3|*Mi@Ozbr}0nkvAg=VOquO~>`r2)Nd%D=Syt0}$TU zR^$`>Gb7-#rmp-Q>GGJCvhz`S;J zMbadLC13l+b&^!yDnGUB+`cOhcplG%WS8#VzaQ|fzWC?R<(9O+sP;i-xA^QQRLA@| zKKnpI+=Mvbklnuph0SJsv7&g_nOJ%KFLCXSH@HrlSH<#-)Lq5idE-tPi_9gg-!))b zIl=pDY8ErtqMR4GzBIYoOs-uf*Ev&VU;Rnte!0mYH)W*yoHx48MXg#aH_eKYn;wor zLW=90VbvW-0KmfrB*?CF##J+rV3eEY8dKZa2Ci7*>WC_1d4p+hYkMVw#Qs{k+cgj+ zyGjFrfU6@Qa$eSRaJMAw?X=c1?KgVL{_r2#U&u-=D3o^a)Hf_IzL+`DgtaSd9jnGw zWP)|YS|?cN+GAc)mezV#>2CSux0o*7R&pEqQ4qZlAcz@RR(HM{HQgdP2QMG;zm}C1!xvp8e z(_mrmryd~u4e^En zfCi&=JgZrOd+(F!{|p2QRQuMzdyqK)sKB_VQVbT?9uw=ws7c}A%cNrMo)`l}GCp)) zDDF`QYfpQ-O#APD3R-D=52pw6&ZQg(XVo87ZYyCn2;D8(q*x4B_ZpB{!I{8{5>FkRv{9r~Y=VdtXdhj}B_MK8gP+uh`hZ;bMKn5) zIpgb3%5^=sW^O8cmE8i=g)d53kn*}3q_|E8P;E{+YFE6;ZzDxY?J^!U9%b1^6B3s= zO0?)Kl%JoDcKfnN^J(0ln|3s#Y}(pO3M&Xzafwz7v7GJNW3iP@tNI-H(vI48E6MCJ z>M@7yEyY|C5*odW)UtH7Y#Q6l=_<0E+9jn(k}{R$%tN)ol90ZUC0*s_uY5W4Kx(*I zFOrF*+|ArQNWBmO<~|On3zJw|ZVtQ|2&h{Ksk(&Fn0%_F5G0Q;wxe@Ayv0fp^&g{O_A#~B)F;* z14=b>AI3H8ggW|VrHPPIQ|E;m!x}ksc9;2rkedn8XF7s!(7w5PkQcF8W&t0@BY*Ubx}v7OFwzrHBb1fzRu=V!WV|YxI$GUitTN zD3sNu5hlV_Z=Gtx z?yY9h2UV!(Li*rMUrrS;1cxVa!-BCho#j}*N9j{(2Yoq!m!xvFI5AXvmRz?HX|5I$ zL9mu;AiZZ=J4?488!3mGp1x2WY%>A+Ouxc624b11Y7cW$(gh2aT6`Rk3X+hlgAGZ8 zA*S}zkKTaYb7<0*W@Oz}wgeLa^nb*Bwk%K)ScmztSUY|irS@1{EsM}i5@wsm#khcM zC5tIFA7q$|N6evaf}%g4n-|0t=HlSQhu(&{fO%fn4j=wwsg_G{7*)S`;}| z1?OL$uf)K%RdYuGpuDRuIXpuLjRV!Gsinv3PdYCmt5?)trq?ew%{G>J^G+;_%6Ii# z;mtd(ZN40~OUw0W3#2=3FPd;U+IvZZrS71D={C7?be1PkZm`U(JLv3hH_4b2lPgEH z*NvefDKml4ko$B?JX(M19BcC?K6(7d1`DuU?K(ZNG6l1DQbSzbUgaVda18+2EKhuF zLmU~YKo%>}f+M+d3@g&w>kJ&DcSV%^no*EQ^qri@DP!*d=QXZ#6Ducyyh}NG7pJxp zG4Vv-LUR;R_!Uv8=Jip!%(2D^I*|raP1}<|D3%L<_u2b#CG8+v(CZv%w+~2cU;SQZ zbVg}^b!x!g-~2W@;nc@%pBufVCycGB9Sv$LS~lM^hVAnfo!CL0Z~J=nerE3jWm8-O z6DzGSe3EN!la%qP{oc8-r;{ra8scNn;;fp?7|Ho1wOF{l) zJrijE|4U!Y_FMnIp>M(W<{y}SB>_*|p2*h*g3F0!Pa<*ItaF*HX&+X7ux{`9S|57N zDJT%J$m5Ht$ou}G`7}QHdi-WAogv6mUEBFUUwbvHr3~>=LjV^qWZv^F|O)lsmfe` zbd9P0PFqyxKoClP**T!vPcVD3{BqujRC|)~Yqh$s zEnr~>+Rj)6hT6}lsPPm#s}>Eg4>%%`#y*l?t{#wI?gXq_+AqM{&RS|e|0uQyn_ldW3PK$O%Soq}|*wX^G^o|Ai`ocDJ}Cm}`L&iwge%>XFX2yIn% z6rQH@V|wS*c`!{His>S)8BpqMlRsH3DgA%!?&QnsC1unm-)s{}8FMBvdm@^V&Z?7x zEmA(ffSG&Lp7<^G&p%)N&ke2r2`!!1Z}!LfW}B(1k_r;mVsB-<_6FRRn15-o+=t;7 z#jBsp>?y`-tGCi(91yS$ZBrO93xF)oDsu9@m5JKwaOPE%nT7=}*`n|H}b6hs_Ve7MX z$d4VRoYLglvjT8G2TUQrHe3pfhiv=g$Noe)PHXKs0r-2mEt*_^Q1(29OM$W7c0hhi zr5w8@wQX6fBlT>FSFsWYCTqEHu5qS2B5Z#eClpiim{!70)+ri2KY4X(jd6< z9ylAHnr*c#i$zW{vrkU7rvT34D8c>p+E=hJIAY}wtlFAdoxCizgyYfvCzRs_x8qai zSuJd#HHno@&MzQ{6z#u*5OUpnP@5Txt%-7@4_By@@HmKk%^QZANj*K!ngTr5WwH4M zM6dQhIDe9m1WqsDk{tPhl-t7~6@(t-+rE(-7t{4ZYhr=+A^-|`dwz>6Hjr9ny}nrc z1+G&EsC5Ck@diOxBIJOT>H?O}zR|uM9TMkw9UnTNfJ>FbTWQkX4g>gU(9N?Z>YCe< zpBffFv-W%#a2ElB>2P}pQHIRNYpyWBa|Eyu0QRI%RTk|hVSpM@l|`>A2~{NqB|TBg z2m&g1K{4}maJw=|O9^GnVtFYd19c~Bv7wA9I!ck7T9jOZah9U}4Vyz?6%C#&UAmT( z374Kwqhd0}H|Edc5?5ae8{AI1!Rs_TzIj30jPiQJt$cXC8-EtZRcbtrh8XC*{tRh#uZsg%h0 zJIDvkyuRAAje)=wtHxBM@T~Vm795AJvr)>muCoT%PiIZaMAuoflH@vTQ7*18w-sV+9=@mAx1_#gD>$$+bP-g7RV{|$LjuY%=&Um{3Wio|8bq3A+P^WWXery z>vfVPVD&zapY1d|`X_C#qn`=eX^HK>n9Hg^e!Cg6vVmR>H5^@T{vOT zb!Ot~d*!All2ZxMlY>CCHPcxzy3KFjYH{8UuYd{H8CSOg!RR*Zw)lUr)uNdBy{lua zYi|~^CjjgUJ;~sY2ZFJ#4wK*L>d4JOOCF_(5KG5+R%B75+BBnjldC5R!{F~zB+CFk z0eoUma{@kz_-w>SiitAB7)`;ynDAe8`0~70(Hm!={3H0>iBCB`b@tqrAzfP9-mcdA)`!R6`Zh{d$98vicXoZb`&8$48rN`hUC|w#4#R3| zlw#^?{czuV1IIe*Ti5k>cS8D%AD-Ub-4$WZi~YK3q4oMe*OwUo-S+sx&i7RNf#MSO z_Z<*A>7$Q;npIJx0Rke%-6icnINT%V03Z{D$d z7*sF?1LL;BHP5P#b$8w$$ZHG0>W^nWwfdN5Mc;N89Up>Fi3cINf#{s%ofFmFsSTph zL#l8Z=lI*f1pD!0)$zd8rFFgsYB>*1?wR?>mEB!kd%YzF*O{o*smyl@suEDD{jh59 zRI7XZ*LUqZc4ki3J}L#fRO#>TLcSmSdpeB0$8Q$sy7n@A&xdpySr}h?o^8ocWHoxSyaCT8G*dc-p%-Roi{s&j0Y#+fpk1S4qcIdwrCHf5vR zW2WZZv7kL>+U+^@2iIxndelU@3E^C%XkDLk`7urN#N-6*JtS#uz-!!vIkEcU$PpAR zvsu{x^Oj)bxXu_?U$bD1Jf~#Yv|_CiI3S$HQ|&R_9L^iS*7rLf3#SA&uT$IFW9-Jx z9JREwKJakd9T@a%_BL0NGBBb9Ck6^|!hMlS3`*2Kq><{Lg>Z(1B-l&n+ zzmA`@lRId_Q%n0GDBP1AZXerqf9pwOhj->QPxj6IIWSV3qri!1)!D~BL^}^U4`K1T z#C0xuRYJqOo4=axk>}uM^*64w(W~dR$4;fY%A_6G*^^Q~EL=9NMEgP$y>OP5_SwE! zc`f{N4GXE{_&K(3Do?b>3O-O+!c9G*Z`xz0&4C|@XOSamf}YNs@6i4UqcWoP+}?x| z4J~JdBBDjP3v~}$lt(`@Zpczri7D+}4ltS#I(z?w1!Bk_0QZhkLDr>`PYxgD4zc<_ zk{5r(X$enPnKZPvQQEHnMfir|4KfY*gN}?IxG&J4Fn-7R@DF9#&%v?`0t3-O`#ebO zWDtAA8G%pwe)xL-HWZ&XH-P@EJ^fE`Y4wj)`@m8A01SedW6>HYK6bMO^`OpU3Df}X zIg~z@KxrfdA)ibglDn$UVcLOr=v;z?)gCZ)Juq;zbfAGQ&Iz7_AEEl-rdoaH$okAf z>bsHGM`=UqOZ<-d%3@OaZ8#T5JE>;=>Q>9OnDE>b8wZ6& z{Q@;3`lY)R(`lmUla-C|d>6@G)njtd zWn=U%qtJ$~2l|he_JfQ4f`8_P;V4!jo8=03WRk~f1E_Gs+jqdY($OR!dydopfI$x71;x`^&Z&789azC zXjM(GU~#Z=XWB`0aOnWseP3%7**CAje$(*n(rO^U7%e2d%T&7=LnCsu2hN|V)I^g#0t8J5NNT1b6HMDgj z&$4}8ITbS542q;f8p}JuK0M^7jvBb?9E;yx&Z@PXay9eEwy#%y!qBAZV1~@c+Pg}=yEmwPB7U zaO~UUK2eu@EI5TgJdKf}i$B(4c5`hT$-kOjds;~U29W968%R5v`Yr^+JN*i8;*GUu zxVBo#c8}B_LSMz}J@9u->F3c`hiRtII{}qN`U)L!K9%J+H0+-3iK#uyrN3Tpby};( z6q|J`Py0uh6GEnmAJt}aiTv2(Ae*_XI49O#$=sG|P>?ng(+GvM%qX6>9=v8?e z>vYs50yXxBPr7Fz&7h<-G(Lrk2KUqWp3%0-(9qG~#wHD2$2D~LV;UNNjXQ6Cpyte& z)iK*F*R}Z#H?^|)O6|vz3GN1SW^|=#TeLqW)4a;C%`7(!2x`<81?9-115x2t|6^cS zt2Y3ugqnR84j@>L{vQy$Xs@F{8^_xc;!=s%O$DHTujlNu=v-3fvqs`jzBZj#U~-gr zH*Z2hL9u24WROE}EE9)h0Tkj8&~6lH|A*ISp&j(0f9OvUaaoNxDrF4I$%b6VmWZA5 zV&>Bxfprm4q=cOY+|@Q8wr~$(3zxQqFJ6#(015G)_?U)yhA4es7>2UGAJS(oPCGca z1nR#ZS`fQ7`WBdHtSt}0tw$k9h1lsHWh)w#y|ix1h4V>X@5NQXTA!RLAtZK?%s|XV zx^7`k^O^Yg+cTe>RYit7$mw4i4MdU`q2u0W4Vu zWAD2@ksBVR%(M|(hn7QpyQ~j76ohDpO zqn53|mK-okSR3CSV1eJ+B+IYy*^AFEe2Vb_|Dlzr3({J_*o>NttDK1a2c3UPq4_pF z(X5P3$J!YlxmJT~K(6}2AC<+5bHV+1W1FKma1a9oP91jhvnd8k36d%-n1=%Ivs<4> zf~z&l5%>TCSP{=tgZGH04cc2n;t%*VMNxuZ=X;Be7kKjqwG50d?|d4&uG6ur)7t(P z?X9}4hesJ)17W#5-K%x#zxHAika;QCxr zvR$9wsF-hePWR4=qDi)`C)&8%yCTJPdR=7_c$8>sM^vrFvnhdMTW4k=eWk`YMt`iQ zj;GF1XxECq zf>0L47dW)1paO$kPWmRTHSJ_!gnzYZ(@p7+c<-HWVwIS&+TuEM=h|r3nY*iEJc;Hk ze=0lDZZhB1cGl$jRBrh7VT?%6VmOm9JfGk<3(bc1Y_qY{)k^X0RWIFz;dpzw&t#sF zf-#eJvLW#{#KEKkS;NBHqHuYo2LlS%23%i`YlExZ=xQ~(&i$zB5UP?eG_v$xAkeQw z3%I;44695hbfxwhRB^F4?1yjXTCuwy}gBp7JUicbum*r|m6Pi*`cR$9bKtsr@{* zCk|?Wg#AZV{a*W4M@f5jLaU^yn2UnqK=na>Pz=EimMpk&DM~7f+_++@LVhvAp`Fpq zeW*vsuA^cA*Waz-fD}TzEXtu_t0`gvqxyI}$XGTr3)RMvh~{(Sd6^U#mkX5{qKz&> z^j!qX$dR5q5BqGYBU{bQB?^Q2BK~XM`Q}%??3bZfQJtA(nXj^2hP038!!V@$XqFWp z&J^_zEnh=1bzuEI`hw)f9VDCFS|f~ z@&)oIoHrlA2gIMTC$r2o%IKOkYoeUs)rui)iEQur;gxTNzYN_A-I;iDCh(7`c^LT3 zcud4LQ&FJL!`&L>_e=plgTqe;B#8R~o2#gKe8GfeY-hBDMSXYyCGI~w-BoJtvYShH zcYUeL5AUBjqJ3GseKT0@3J{aVvJ{}bz7_)}ux_>WR{k@wIA7l{cAB-{e8H_tid%|? z$d70qAJ61=x=i3tJe6f8!=6~UoU`!Wp=E;Y`&Rgh?+-6g7yS$PIsAF>A8$p|MB^Q3 z=)9oAX%YB)>}Cgjhx|0hFr^Q3)1Aks)vizcBYj%K+t2%B43{@Edc~GY@~}5wyH{xX zuwanz;V)QzlHm6QUOthR9|L)HXsN-1X|0and=Y`=yUQyM%@0+MDTaE%p?w&<5tZxp zBmRhdjHSW2AP?sg=T?YMufiI*FrT&rZ3gmaR&0aTb!fN$g9w1R${k*ySLoBLMT0L7 z3fMRM%?QcnI7)HZ^c*fFXKzw3(sB#)&q6#Lv?dHrrmK`$9xG4KM!b?(!h0E3-vT@MU?RE@>VfEo)=3~KrzGaNMxDN;sdJ`9yv z@?k_F1H(-mcMErQca~v|Bix@M`47)06VI#9gZZx3lpzWwDE}#%^P4I4_y=u zvW?__!QK+{Y~(4&*+z1gsd*anJjGM`*v4mgNXaEqsi3`j>a9WsXz=vUcUOc zek(eDGq9pd^!CEBanybcWWYF}uEAZ8xTDU&-Enb8-Ge(#+))SNu20-i7vZj7+)*dt z?u59bZo=JwxTB65b0lxDJBc@rj}_5Qx(x2og!+qksP|VrE~&qibwcjVY-0_Q)Ul$E za7%qex70(p<)VyR>L1*4fyOQM4sN+vjs!RXn(%tmNoga>k{Idr7b}GV!8}4>0fO1gX~7CRlNBXF``s*>g8;O zN&TVRv?58pNp5mnN-|`<3w(^h-2}QLsi2$7=!OJ{Zj#lpa#QYQ1OrD^KCY7saC0eL zB^59SRvq~T+H;+x29rY3c1zB~o^XHsNH8cpIAPx)`eQOCKJ>>VA=?v5*qVFM87nG? z-mK-E_mHnJ?<4p@a?X*;bu@wqF|>+OCFWKq1=lMNQgFR;9|hJc_b_J)Bw#Tjd{JYO zX#4y^_SCZ|tzN;JpC^Q+iK>k?Z{?Rss!eWcewAM*^J{wQkc8zW`n`$OY{TzeoJv#; zDo5~u=;iU@@G8+`tjYuY309^2RE}B70=cDfllvI3(D;aAn|p9s5E%Ci)}{H_hOV%} zi>H+!sGe4#$UlyJc=sYfrV+?=4w9rsA+wnfi(qb|N1v&=xQ6@V4naqDkPfu;Tj+rD zga&P-n)3x^5HwhX-4l34;l7C&e@cev?whDrK#ej*Zu0PEVo4pxJUu{$p2uYk;YIJ$ zC<9=`PzjE&wAKu}8RM5P*fRM7>=vxd(T8zZhpC3<8i5Q6aI8KA`ze7^%EWLOjYAC9 zsBt_AgEu(-rU?43gnlyPnK7z4qZaZ@!DeVLk{((GXLe` zKF&MS5dt8-$M~p?)PcAeCBHWJ5;e}%0WU{L|0*N&;Z77l18Z9G8{!U!7yh78(71Pp z$QHtiZ_qFDF;_W8W)I1yff|82C_ka{6w>=$`4rUqUHMO4Ape=pdyE=+Px!@mdxHc#w{(wPP4jRP35AFBQp+N&Sn z@g>V7hnDmg9@MjhwUg#JDSjjSo9aV#HX*RnMRmiT=L~OpUlQDYP0+VrC!o6UOcWe1 z7mM){kJAtIvZAL+zPNwzD)GEnGOJyKt}39`2{&Qs?hv2A@gTmj0$-edngU;;QzMWs z=yyhQBG3pr-Guq@(1b<8`6cL;f4NC>j#HEPi6_IvAuRvo&?0}Ohfa|o{k4(e1ym2U zCZZ6vH}w1}KLaBoQ_zp+S@g+DJiw$Mxj?asP)#&Xt?z^Q8Q1sVTYU_!6-ix>5G7n6 zz_+5X_5JvD4aBZ4#(v($66}0wR!Z4p^3TV4D(`Adxbx4(#jT@pF@yFU?-?fmen2qP2NmPZ1694jO?{2TMz_p#)X>{hW z$B*Fxx-c`NmP+FZg?X5i^R-4i1D8=tXpmILlO915+vTgJ67=V*B_wpit04Tmb%n)p z(`&g%-+?A0AkMbC(m+uq=0fkhn3VhyZ5GmTEB%&$3bC#(cEG^ae*GG^${@ef=MxCH{UYXF0Xum7Ee!-oLXmuT-jU%!Aj)XWu_JH@g5Q9L>$1xzK0dFxNgm+h^}{ z%v)&p*$@BZjybq{>7LwzJfD5%zs<~>>9g;tm|FWr|$n}?jcsvwO&9A&fTOBJF+FUJmz9!V-GLyI7fdbf| z@nMggdFe)Oda{83v_VZ09*h8mtjAV8Q!>wg8+QJDpo=tsA;ZKP_oJKI1Q?>&sy z+WEX+nVYg~_7hH-fLD<}Wu9F|%5z4r&eBZL{||M`?!#=8)~$4s?AlJrZOq zed#<19XdkOCV2!@Zb;(jY#0ao00MFMGXVS& z4YidX2R_b3uOrll?*owJ=JwwL%*Vlw0c^OOy$rBo486+V0qj{0cG!8X-rPGv)p}^7 zmP;~F#=Zd9)f{$Ds3l?PSe+2rP_kj1Kno zivXh#I$P-`fQjaY`SKaIx2d`J{}Ev1)Uf@gN-%mjW8Tmq|NdWq#0QY1c|%o)Df|V8 zd|&$j%jjN`BHM2k6J+uTJ#Zf&wVrrL;yt$CklGHxl!Q9OPB0q~h3)^5t+Xx#FefAd zRsx{Mb+E7*-aIprqHRg!qrbL%dEgxS17R#YjQ)RK30cPc$^I=gdBgpz+{#*La)(u% zX8Wkp#LoH+>?79Lfi$vQ9(*Mbn8Jal@VR9QhlYBIY9SEDvjiHlsD`6Cpre^Q0u4cP zGz8*mA#x<=HA2IhDo1HexW|axy-d>1x;Us9?F2{ZL*{ec-mZd0OGopSgxYi?+GJp7 zMSDsR=W!37p@Nw_v@!9iABpC8P2|^;S`Z)ALYYhM3fWii zfDklnsVi{W5-wTeetg^7FiF$)$e9LmB+YM|pH63x3RK3wn_z*ioas8rYup6RyEh=Xy z+e~nGsa%lM&BU5eyq)E|##o7NcFFZd0Eexcr@@<$x<2z?LbPFZz|W57F)=f-yneZ< z=xezt!l=pn<~uB!KYVari^j`s1F~!0K%Xo#74kVc{-iO5KSZhK^`Fn4u?6j!n{<2T zG`D2l4WG#P0ZwE*Q3$&8`i&n^5N*Hnh_GQsm@AXT)T=g51`F60`i6`uArW5&8J&t@ zd;Q6r6)E8{BG@Hz6cYo0}s|3?dy} zF~ED*e;B=cm|rdp6{|?(cot9sRl{*ryvm_oM}e^ZM4&hvr(^@NMzWMV?i5@jDF;6u z_m$#iHouvKZ^1n8<|Lj%oX<3usBvU(nYq2y<{u@$+@{-EErNN;0F#?!=9X|VrzERb zE5e9kjVDkc+e|PbYi2$)NXvhdLP~V4RU~Cpv9{w5E=V;kKLQv`#3q=CCvy}7j!?su z&W%a{?rP?MI9iXmUdW%rvb`m*PXid9eST({WJwEb6a^&bL}3HYq>$%M%(>`OZ5trx zxB}*?BLd2>1ID=IoR$VFnQ$7MS2K4jE?{tu6PuCD8KrKw1A!xE^c9s)Uk#6q0&SqDmPRe(%U50J7MGr9P;}6aNWBZUqND`&;%}< zSrmRgPH(~&fEdyQx&8)TDEK^|-V(V!3CR(y;p8kcgz2GUIDpAi_4Zv$%66v(^!Udh zCnk!1n^l0ypMr0Q_(z@_UgStxU|4<5YrdB5?45 zw#*df{x`_y{L|_EZzGTI)j1!@t6rF4L~ffXVX8VBs+A@h&>p8Z7V*KMEb7XL`USsC zVSZH(tA7Z;Oz12w=bT>^Isqgloa7PwLVKUPKz&52Xs`d_kbp%t)1cRK1c*4G-pm+h z%7}Kvgxdl07&}5`&^)@NUm_$uUksRnnfbc7KMFv>ofzjkA?P>taS;>lnI8|wI8h&? z--37w;E9017v+-Wm4A~g*H%cD5AZ3uPqO?4pRo4g{v21I61E@s%$(L*xC88wqPEZ= zd)Q)x1q=-T^i5uo!_QZ$kDYJUoo2iEwn2YVTJ|Pv99Ac$^VGs#Z6v z)jQSFR@J^iwQp4IPpQ?o(&yEpJ!(;hTC`uS#&hP!Y>lLzAWEoSS5!fq!RWf$nNKjtE64Z~ zGoziB44zwQKG*7rEEl`Ve6C|?N@a=M)FF;mHSRU;P0dc|VO0rR(++yG(*vhYksf88 z>K0P`&g;dAh^Y$`HUMUiH+u#haeYeV^A3fokfVsE+uQL=Gci4$`p65xiCFIxzW!Hk z!=Vr}@IXHdGQUQ)6>aFWo6^A!y25;xy8T+(pqf;&Jo)TS5g&4gUh1SITm$JqB;jrALbHAu`d?<4yYw2 zb%|NK^#DYwQydYAR-l4-bcGm_WmV7Zte@H^DhN_yb<6vnUiBGDmcGWz;7}Y zf@gyf$4B(%WjN04U+7PI3}$!5Mvgyg|9Sh<)khD5_T%(TaPWdXIy0h2-~HW)9>rmx zTS%JZdKV_taF^bTo*UYwe|n2|slOjTn@K7uxN2AW1SL8vJ;{kxBXy`ZbF9s`a%zFP zg&+h+af)&R*MUJ!g*dKPkiIC&`8ERaQ#*|N)cIAc5$*x_8rKL<6Kf>*bLuXfQ_)Bk zDV|!zks+u{$|$Rn>uRaioHY*ZlX;{eOwdK>P^=o&J51_qi#j_|ot>mUV%Glp7Ks2T6G|l+kMWI^ogsRq5WO5hfSv~}9MmQU z_m0#i=g}u`!N>bA=o9R0K%YF%^+~_)|A0P;oFUe28KF-?GejEXG^|d>eK}m6+yi1T zLp;-mpYRMZ5S}57Zmv)q|Fj*!6d|{acI`G`>Y#_DOHU{Xy1gi7liAqWz=@E691W1* z9AoRe@Z16&Fk)uuXa`N0tPn+7bOL%wjb#{W>H?EmLemW972g~fi&!R&%TB>VD|vVh zr37L;$D+LrpMJ!A6P`BCKdtb|q?vclA@F1PWPIA=R=kQ^7a&+t*o+*Bo`d!DzEFzb^m zLXENH=0t4W2mft0+(6C=Aoun#xj`z|0|3KqS(KO4<|yzdgsw5E!z#M@9a5ZF1qxy= zpy#Rwe4J_!j24o&bcwK*FvUrcX3B?qhK~r^kM(d%ey?(=+_aJG%mTKN?BW8DSm2?;HfhwW*Qi;el$$*-;!^M7<)m@W~#` z9sf>kHIZ_BTf6<&P?NB$L~RlA2Fem_`XlxgAvgGL^ma~Xv zK3~p4O2Yx1ISW@jE?Hb_9g;GxVu1GQd^rwKBWZisSArgml{}MdrmI#n1kZuNc%n zCn7`r^K^W(C+Qm}W!7B>)XW=BYtEX5BdKdCVu&Sd#GqCm-9*>*VGy6*{UN~r{~YaMTfTHY3edl3w0O_lo<8T#6aeyZ}?E>iROwjzDLOdky6kC z4_%2oM0MJ_sYtk)H0o=~0LyrtzC&0ACn5lSHRO4pHdeCeHPk+X`_>}da|+ar&*C0* z+$r*1t!uRZnu$JX#Ul+dtFJ?-NX^eBOGW%o3>N<+0aKBJ8;5^_AgE$G?(+Td6}k8o z1Q%$3+(o@fO$4Q^p0~ACc~EbHpz?8|9Q;nPeE?0tLt+YS?SdW2vIi^ zJ;7Veo+ROPXpKiWhv}F}F&uaNQVhpn5ze=bRGmmsA1CujCq~HJMq;=6IGKJB&ui4R zi}X>LvDSfO5&0lg*E+O=ZM;cp3k^UWzy4gcU9T1XmGXxri-J$S{<}#3ZNx7PK${08ioIq^%@X#(CZOS8wCt~eL>(g=gb+B{VL;uG0&MP^ddDgO5D)GI9z2mF1 zZUE&xsw3N)$iq77tS?a#g?8XZ~LbJj5g0x{$|s z)LDrkBF-b*y7<8yAhGf=4;&%O<2PJR1Z01>;cpIJLa2%_pFdv(q?gxk! z=H7nTwzf^Yxz1bo(oU}PLJQEd2le=MbtEAsg3sayD##O^fb(QfuuxMfXfqVW8GrEr z&TkmcTIeWpZ#+&S&p3-C$ggnmBgkzFt;x>&>3~-Udkb6T*FA`m3QE$sxpseenizamp=T zDMdV4Xw7ueLA(|qeAJD40}y+pRyi*wUgUFvo>q|YsmPdz3{C=3n(`1b_EE+r-p$Ah zwPGRUz4yOFp~aEd9%0CMQe;?z*mk3SgBKZ9B4c?F6=giV5gGT0jO!y&wW`RtU1Usm zjunKpYY(qPa+*la4k99Y4?K*F2_j>mfG-68`>K#^6v_7n@l(Z1*CFF`gb{!v3Nm=Z zDdP{nK*oENv5AXdWF==GN8X=B9?2x?0Vj*uA?@x*k@IVjLn0cIw|4FQCxyJ#h+G;V z$VGjH+2y%H#mjaloj`H?%0$XM=SoD8Vu;ZNJv`#85*-pY@?{^!?-;v2~Q?9IM44u7F|_ z-!CieU3()WZz;5QvGxtfLoz9C%DERgWMPEMC-d@VZQoX&Q?Zp7+lgW*6WT8({nj@x z(zxK8*hIs2GP+9MRbuG@n&=#2y#V(r>3(2`{Gy`#k=6ol5j-1y6TT<}~kMS(xZQ7&3` z(E|`D{?0Plj~5~h;*K4t`6RaHj7fO_=}lWr{@*u~wOhwCo#qVwzNktEGM`?S=2ydo zj5TKrN;=YOw;FoyhixTli-JDkwHYceBX8zXKy+~xD}B|q$1-K}Wb_*MCq04i zZ1f2nNy;h|tEau*4DRWX>xl9x!!|2@|K`TRH~%}&>L9f-e1N4cr4 zOmR-ASi~juY6y~e{S$;vY5erlm0)yeJhMxV8=TwxPAMC5kV-D_IVi> z8NI&$i>%v+7K433>sFZQ&apWB{vFNt6Kb-#*Nw4g6V`gje0>~gWWLhNAx4<5^Z(4X zNTK#;4A|amfUw3z_^#i(_A=dkO;o)LXPmVelsT@?qvtwL!aB8(Z7tWsD8iiN97VC= zDUo`L2dBz)6M;zUdsVNYkZSk@0wOovZo*)GjT`8bzY765al*>cgL&(50ldjhxrCdt@7#k*9}tO|cx5PseKtITw8bK=DhT+(ebj!DI4_tu ztsIH;>Id)?I!X$rS5zZ?yZ~MtOoW1vdJQ7cN{M7RUj8T&zd%tCwLF-(9h13;u*3o= zSp4`}B<>cF)18Q(Zr7f}YNnUwH5ASc!VUfmiLeAIaiLQ#SJ7C6BGDs#X^%$lgC~TMs7P)R6tkoe#<#LZuthx!i0D+G|MXLW|yw~;} zgXBb-eB@%ovoFOsGP9n$PlPXtyJUoKz}7C;#en&EDAx9&Tz3X!GZ)2Ml&~G-saLt9 z0AgogHzLl^%;Hq;v|vw?LxGI$Pf-MfL%+_#Tj-=L1Zx#)WsIcPQViugUM$hQUV7jv zpWY~oQ`m<37RZO7KRL%87DI92Wo!QeF7h@BT!r7Sa^j09utZpsW!gFSNE4ph)7g0b zX8>qp@d}eiHi9fVQ6`Q~iTg&oANR~fV#jVKuL-8GB*sF!9fe}2EIRN$P0Ow-@bX zMY-p{U%8K{p9ljU2tX;z1vud1wViV9*Z}mBvRs@j%oN=5Y5UM;X(usbPh~CwV5V*8 zwB(T;k2fgmzBHUVTXj%CUkKE-V*D3rwd`yD<$X)fqE;~VEn_0L{Sbmu=#Xa!(^5<9d~gKmNQxSCfWRCRy>*I zSn~_GkK31%3`(K9_J5Bmn2R>uFGL9Y1r1*ACFh4nvv0iBJHL5>-7$|7H0qRyTdVWvT!03I}qf{s=_uY&9$ zI|RrNnxo@D2AyF??|P;Y4WIpOer_Gqt}|iz@*@OuKf|rfAO0~ApiuQwyQLcRTWsxo z%w>}4=>0inSC2&*O&Beb z!BxKE&6B%R6ab2o!z%X6;@| zROhbKExrR`yG(L^b_twrz>2>Ob+oBW}UNCEo-BwF}JDsi>`yx_TNsJkLIX&5xWFR|if70twXDc>dRadF}ia61I!| z<0>-mB~Mr{XaqZJ%U1-@e$Ye5;jXr!{5C3&uK$?au;_M(4!RxeAQV{5;EF#FNI~AU z`$)pnVxA3DFs+ciF%u{z;gg0>K0Y=0Jc-ZU_^iU`8GIs5tk8H}O9PC*G^+wsI<(n> zN?MNQD%gptUAiKGDTdzUxDK?{pm}uSMzMdO@GPQ=^6BF^bQ1{-GBxn|Li z+%)8!2Fg`hJ6Sq;*c*+FjFHESx(PhE+`oxGL z374aHQyd_$&gN}sRBxi*D6~f`jPaThcrfFrOYl~(fq*jM)};@h3n&-62F@w5w{FYC z9{t75FF6d7Kc2+Rg7ce}-etrJ^VSt(@ruI@A3@x2?fHdCk{>&aONUnb8%QsCbWQZy znf0^=K-{?Yq-3crS4c|yH|Q5T=uL(GWc`k?r|4FO|6;DoYlO`~Ljp49YFPs^Y3q@n zIj(N0!Y$0xxp*etO@gMnxs<7HE@2#qaFZyxN!D17((Wd4gI5bt2q*Zk`}%nd${OHR za}**Wi#u8ovDm}24e~zV$yr)YSc|9RUsa$ z0hd83)8jWB!6|RwDCqh5N|p=f)1b7)X@%Z9-9mJe#R{!}C(Q$E$FN4a^_a|AHec1( z7@3KPduqHDZW=n@My~5dE*PR8EHEs#vtsQ6_`eu0D>o(Mkx?A7Th5Y~7~9Hi$t9IZ4U3}iuvU_Q z@GOjq(of+-D9ub;N7Y|wRe_c`&3Fd_>ZpF6xBy{PmeMPz2H|9G+)bSayCKgUjE859 zM4#N0m|;6qbq#~pbzxK>*LJA-B;dT6Gs{_GECO)K)v*l=V-2i&(35X)+0910m1q#p z7PR)R0Lrwzh#IOtx>kX;!FYp#Fb)V8Z4Ba{M_Avg?uW|o#?O*pON=shl&g3-TvNWm zQ-tI7#-j?ksl)*Mcvvc~oL7qTkOw^_2DX`ZSG+~PFpZt*@)=R5?X9ZEc;y*+7P;}S zU?bxlZERER`{gFdwp-q?i&FFA<)(+DyoodEU=W8vE$YNi6d>@@ExaYkhtTP#Dc-Cz z?M&(!qDgKVmAdQcv|XvYj7UD5+NNLYy@mY@pq218!L=pyR>9pSeZH5Q3NhszMp@QD z==P=VLsFEEOK!T@h~$nS>JHnxSOmghd0Mp}!*7;rw-NqJn?13riRJBYC_07?_25XG z!I{)rG;+gbP_jY^BPaljtDm5HwcA0*5 zNg3*@ph9#|%2(^SFCEjc&)&Zjt*7(hy|Zzs!XW2GtK67C}oUMcteqoV-D?*Vho{t>SYol+-9BA1u39+HDa5L19HMcRz3Uej3=`JGhE!lQ%?#vPsp``{@QV z@M7l;x9Ro7*HY9P?Yz*S&b(92!;7K81`~5rAL4yt&;kbAA=!HzY(qvgAMYaRJtWck z0O>(7iFnsnc;~#sxT~B&Ggul*40n(^Q%lWib%)1caNbVGFj>~l z7Ak?YP?ZhIh8fASa}+B*+>m^QC)vPSNO6FSSnL_t4mqKnI9%dbdQ-a1ZmDWz)p#I* z5{1A4b^>W%D(of+6eUQX0R?iBcn&X63Md>Q#^p2~XKZ%D7P57&oy10g72r+%SD31h zV1b5)5DnVEy~bTg!-GWj0cL7OCr@T(ytE`djM3@A(CARx$MNQ8FpedZ zp?#QZVXk12EJljD#S9vF-g$=%9-smDLI{KJl(7d9@~ta}cIXj~Q-4<;y@I%i=mR9$r(ye&|bwG+#~H(Csv;H9=ttf zhpR81))@C71yTzGHiPu)o_O(^)zErqG_8loMY43on-Oc8;rY^e^Uq(FC=Hdr1ZN`? z*btvbE)IYn(H`_OdWF+NZj%x81dVMUWC5L!t6Y_q_<)or{>tx#B6i9tA)x+&O}@h zpyZ76xhX0AvW7^Hi0DtfGs$y?$RUX@m+^wTEUX8^N2R~A8q2|j)-0eGi$}4sszj44 zTz;CLK`Zf^+Ip-Nu{5p1o%S%UL!BDx{{$#AzT}3Pk-Iq5?ec4$ThJqTM`ha4v_LsV z<`3~^vxDWfzvDUnZR8qnh`*%fbU?Ax?RCa-&$U0AKg_6?oMn5j>KJtP<+V%sqEz=| zz^Q?#_ffSU)8i}T!*D34c5xTpO8lbdm1Q`=k`|lZ__;<8%@uOfjpgdLVt(~d6fS8I ziqj?y<*J9C%0W4t%cR^yzj*ffI{CF`BAs5Ovvy)=J+qN$_D+wh*%!F(l9`@MZ0}b2 zv7sLn^M;KifG2mEoYtWPm%BJN352f>lUcp zeM$V_nJhF?=pPrI*E(H1Qb#Jbgu5%=416RW-~14bVvVGA$((!>cL<=(Jc^Gx&zg>* zb7Y=1>)6dh$KK7#h~a}kOcIPCLr89T8A;lBK=YR-iuWb1r_JR_SgqzLh@~@0N>W|x zn#4(K;aEJk?w@d9q_vi-ZjvqWez0)S)p5Fy1;D&CV3bn*rD<~gqrmHb*rECO)+0`b zqE`8z6j-2B6CK)1!7SoL?`lj1>K3{bPMBUg=)b#@lw%6A@4_8CEK^^UvQW>p@@sAq zo^l&^&p5~9g2sh&45%g9q0>6dQc%aTc4w?M5pGL=v=&1KBDK~)!n*-v*0suN9e!UV z*>+azeso2VUu&c~kUfUV7$8nDFT7W?wS~w6< zc*eIB#(^$G;)udYdRc}Rp1-JN4qhq+$J~bT7zY@5>+sY2muSMp_nsWue>Kuni0B8U zMy@MFPKd=5u|k3@Pbc1TS0$85W~RYeqzgD)D4eK7ypOhpcrUn~n2z5J$S`rg!DR7d zTW4S$$U)<={7bZ;Gp3_0>G-`Fu($MH%QIVZF4Qcdp3HFFh1wuW zf}UH$br)(H(oi??ruQZwU@cXszjqWa8@NVj;6u5AQ%n2;pKb>9Eop&_Dr=_P2z87> zI*r=bW&pEk1lZ2V-peW7Ed)B93vN78AlVlQ$wr0cYW}%iD^k%H>1>PWnVDFNnMj^? z?I7)xdIVlf>vY^7DL3wZy#`6;@cX@XfbDA2a5Qk+0DAHOR{a7ET#n~Nt-u+Jrvd^& zyd!Yl{4d~ymrlq%;f(rLl(&3;lwlm` zlN6XSS*JtvxCn?@1S4t-X>Wu@Imc)_00wTWFqHlA+C(?WTPq4>l_PE+wzEkuq-%MU zkx7dcXpi!OtvEygWe_pL1rpjn72R^m1E=GY#c3f%RUH zf**Y*S<3IYWTGSuG5nAs?p=M&CWROEEpsQ0cNg-mU$)lK@uvV=JgsRIYt+b2VrR;g96~o|$Jin}D~y@BO@=*N<$TXP%ieXU?2C zbLPyMGc2$Bh4$0Dz?Y8-sx6xyQy44Tk&fAm&0gI>tG!zGs5mNl`!Gz>0r1zr*)i-&Wdf;wPYILC|73?blds$D!9cOFIRkA>k1x<0JXdKZ|#x4&&F9OYB{IE6Z zl2c5MP|>*9gm|)lgjVPMLo!@^sJ}1Ez1r1Yl*QK6@^I0ZlQaGG%ls3}2Sg_d7k$Ni zKzc4*v~0QgfQ%~g{G<868lI|t>j@W4nz}eEF#gm`*4x~=tKi6s3w#nUh4NBAXI!ev zc89!tb=;>^ROr84a8C8RrVkB_4n8k7ARN;Kr2wVJIi&z;enTatOO$)RGqgC1vM!xZ zqYjkcrc8JGhdq<(AKG3tfmlbO#S>I@sMo`D&(cucJaQ6f)#=b*>w&H6Z)^>WveQ_; z+oVzDJ&q;*F_D?RsYO|T~{s5*jBY2A5^Ox~HXsn{D7H~7b+BXYCy=;)?rD6&9%?nf(A zys->^S2*G&Z<-_}-KgtTwR(AS4a<`&BPtNu^r7^XE0AfbNM@zcC$fN*f57_b4_TX* zzy$Q}5`9EOpD*B`fkkj(fye@+5U5v6ruJsJ8z5zd!%@ik!FNtIb&Jv|+@`w3nM@6* z9gZA1>#jeKV%nEFgq=7eq1GB4M9@LMqT2-%6@Of`F;RtGBxocG7g)z2ACg8bLUI5w zjdjiFIBf!XdI{wUTxm-i|2P{i7hnru35#|E=Zm`c?oz1H}a@Q(>jGZm0lP4HHw&pi?YcY(hhl!Jobk@j=%!7^TnK^)fpB0kh;b zc>L0V-K)bTWJF4QjjjHnp=Nc0sN^pFawRxMR8YZ_zmgB3X4%ft;$*ZEC+d8SKEs1i zk*LkmLAF#;CwoXu7~8bHqf!p2MCPW~pLQF;^K`k$$ zf(ga1Oe&rt#nW{0ltNYbm^5}4cfzOcPTh^7$Is^1Z*QNK?hefz9d!hkJ_ZfUQ3P8(1_sLS@Ordft~0sWJe2pg(XuWjytK=HOl9Yu z%?(1OE$#lDlkBle$lx?u7N_UEO*Un({oo_!zGzgr#h6wV2JBC3KqYxvG0?Hq32=aOsOyUfn#yUBd;%nNdI z^5EI}ce{rjluj4dLfzvfSH4jZTGkghkpS|z4FnSBze!MrY76K3Z<;$LFxsq=$h=3o z4t$Fc>DDSa!=&rI>taQw<{vP3o;qc;41LZ)(^!HKXMcXma%bDDU^^=^04+agp*x!U zumXf?&WB1A*v{JlszNwlVuRhrU0(0-?;2>Zn14_5&*4gOxm>CIlmDE_!{g=p_356# zTydS`cwl$Ij@4IH87(Zw7Nz7J4#w*5db5ueT-(_!=U%uoG_s^%$EvrNL`nzp*Vy(_ z*sEeVLCBPmF{uUxe~MY*a&`**Hg%c$7+{qYw5{s-+koKDN>k#0orsjV>rW3gntn!q z)UQeB=3!UhCTF|ZDdrqmW||-4uOk+eh_^4a7(I8@OCD&_#A&uhZeKBzNj~7xkHQ3gep(7w@(#r zsp5HEMg3`4;I25Txw=CCBJ*SLi!3@Hv{Jzm(IX|gl99sC>EpOQOckm<1MpGpIUlM7 z9jQ|_>rWbj=}C|(P#&-QGH1IGDI%2H-S@e&J^O9Ncd$AklJQ)Lbb0aSiZ;G>IV zp6)T4BwT28`n^%tz0^2WYMi8NG+N600H9V@6+F=g73YH=r9x7T!Ji}X46*B|_G+pn ziV%r8d}7-S$r%=2php2AWSe}GS$1-{eortw^bA#4p_0$_0C11)O{*grPiuz>OLt2r!c4mB;Bq**H9yK!G?Cn-`t8MI+%ax}d~BN)GHd-lX54 zvXBwkb8Db&ORA%En7h;+DNR55?O~zP;nUqqB;fOKrLnb#OPLjn&F!|9CU5-{gwj8_ zB$3e{$cW5$*NSgs@5wfHkA8{*aT0rE@#sVltnC^21)CQ&1U&o}am-XPYE;PYanuqvqIb^8sz^tfPmgrx}~; zx`XA!U~KusXqht9*c|907go>|V{) z_|qdpLuvSN_LTIMzhyM7#(aDHDk+G{~ z%qbK$zirl0`vGHfHI5~yf900*4d>yum=U_XL@M(S#cy>?Ng>q)HXlC)I>F~3)-;)^ zUN-8NFY!lw*{J=HJT84p{85o+D^u7cbuSDwH7 zXJ|KnBN%eTlB{RQ`hnY=PS(s?-O64J$p=4DNv={z-sRk9wCp@+2}oD7vDLLm`XNe; zE4rZV1H;(51D-Qlx(|M6Mx?ov7vh;2zoz~oJVnhwj|t7(q02+_Q&7TGF9mw!=)5~L zlJ=$O^l(5z=BXY#ib?nQGlF@i&`kJ?(0wtd>W&-4A(4>-q27mdjMDEom$$vgBOJ5X zWo$he4!lJo)H`6O2iu_B$>jyrZv}=dFZdIubcDk;S6jyBQ^wZ1w}k1Or=ky!Ni^z! z`G%mJ74l+fQ7HRSz(<9|GM!>4wt;Mq(ew@3C|G)wQCD9w?0lqT*vW6D*DrT}8Y*G< z%IMYWt({B4B`!Rkv@?*gc_*WI3FA6B)$Gt;?fD!>Z@EWr34SYOHF8T@K1V$s-{tUZ zhlL$#!zz}$-NkdXrZP5uJC+EZQevL%qWeD2KS#_ZP7inzoLo0LTAIqtBvY;%rg!d{ zALw4jkr#BmdB9x6zcu{(NBgfl%fGw%XX8V>I=r5Rdp60?3s-lWo21L};3Zh9O0mpM z!iS=TAT-Pk!fQBuarh)$-eq#d<`Q??2b}QTE_@q&mmsEii}eK04mBP;I8u%Q{Mhjt zYYyS41?jg2<voFOY7u{PPsj`*I)2me0M<%OXyeB~S1X?S(c(CPwx|b{^pVIAT#? zFW*81ft=^mYH!cB_3K%R^qPCF+!;!XC?o!X_l6w`O>8<4a4TS?u@qK)?!Yze2E$&jQ%&47d)X@%Ng-^^0Ps(ykJvuZk5ZjbM^V}6v%H5*SG_G&kOdVbuX(G7Oi{Z-R6mGS_(gh zJQ3wS5W|y~GZW>#2V>N3W;}_gtyKHkAy24GB$m+U|Mp{ZFLi*;?`-g|8!c-9|9Tv| z(QHa+_&kU$UQ4(+YzU~)z<8|xZaO^oJ{_QlVl)!`Kyg4eps8?UM0QAoI^rP{_%aCg z@$yS~xz1?G;#nMN0u!h~_H~rnuXenYqOCTPW7#sd&g+J1U#jOrs;Zw!Mx`qvivv@@2G=D zi})DCE4~L@lRilw$~T3_SHLhe`J+>RREW(Wj!dnPMV2%+fv9K0Vo5_7+LS`JZCIkR zu_dZE-@VQlI$||0_=h8VgdfVzo7ut;bM>q%I_shoq`v;@9`F&>dJ&71ln7@zyr~Cc z16aw+bb%>tsFF6R327q~xfTO0ot}KYLFk{%UwxXtRDbv{&U=b1i=^h{f{;ZRQ<0^B zRw}XxL-dnnlOhXT(NC65iY(qFvVi#J3Ec7ZOFXiT-eKQJ<|`zox72PfZ|YCC@t8**gZz= zfernPE;dW^H2NwFrD0m`ggh~EBv_r#*n%H5X7~lUyc}BaVZhftnf5QDKo; zcT~|jlp4CVFStWy4WnsRf+M7TOPLRK<36K7pMi2kyrHX$**+FLf2WY_H8#I$w0yTO zKG0b-k6+H|k*$Q!x)61Z-K~A0)HrtcB(O^e-8pD`HopqtG{05}6U+2uG?wuwP5Ebb z84BqoEe|7Qsd%>rauEm!lFVtMZHq}mo=~|(q)tQ3AMd53@qoP?$)e;kfVY5BIqgxz#XLx*@$?64q1rFb9Y~8Iyk8>~FraFgnEAaU4 zNX9tYq3kz^GzCdHFNnM4{|p4h%aDbDkh12cJ2gVD<8Io|^Sk>!y#$NM9>$tl$VD2YL?i?dZT}|-HI+CbcBKs=8DfG3;inc=xC$8Sg`R5+*9gL_p)aH$ved&)fQf%nn1LEpo(W`~86$J?UiGlTP1& zc|{1YC^h7^Kc)=)NY5>Dh00RZtm90~I>)~*4MQXrLUKJB0!B-HVMZnNrQ2<(kF2*R zLo{4_GISl!0|-{ZUZjb6=6N+HUsuPoJO@7zI|jqS%=`iJjK`F+1$6Nvq>1In)VN~${6M&}AGmUj`CkEtL;{^A zdtC~;vmd&!{NIH-i~Kn12u1WngrY*dObp4vR(Bs0P}7J3L!cDkG6Z7jac@j|;$r-; z8^`+pU4QLk;HYlG(a8wz;LQ{>NJ4<33TG*y@`Q*dWDAYXd!3ms`uI52VSA;+|h{{ycnINj!cm3}jp5B8F&x@VQu{@^YjyFH>rfu~#JEYu=3iQ%*as7NvicHYVL+147jjhuw%vVuKLYNro zHMSgNWUq1REM=(!@|2|}GBMQG46!r0k~5J5%4w{8cfGW~9`=v$NsdRzSDLQimNzlO`Rcz9Th4 zetIrW{*7DypL}%Zi?lX`r5PSc}9m$v$ay#2^)tmcR!RpU?0(Y3( z#KvbnDiQ{3h<6aIDNU$LTu5}odA2``jF!E~9XWrF*o4#0$%=H)niEcwO8#t9$ybKg zkk`uin)14}6ZL*3!pmL1-t9EUa^#rm*%$e>yQ=1sA>ikw_O0_rrwDgD!hv(q*+c1NeR}y4E&2(pW5LcxSR`K!TcWlc7ji21H8$Bp<^kxM|31wJpBfI0e;@<0uy92Krf0dWud(LmZ$yp7CNe>&& zuoAVsz)b0A`zSTza^q2Q z)jMOg!S_;dK>?gyHMLMN)qq4ByV~z)E_9y3HR_~)5|v_1#W@SfTK`_k$v4NpnPA3> zSPDB{y{L_WH>J~-_Rt05xYAxa+)c;HGGZJZqk14v-0+@M8(m9<3sB2M=Ns?43N?Ab~*OI^`< zp1$bpnLzVTxA(6j)qPVd`vMtL#|7NWI|`{YHdOwKllv$-U2Wa4kuDw!?A=yym8LLK ze>D>QLEHr7m=;4x0#C>yn|*81g}xpsbFo_(DI6LqAC4Cectq!o0*T+KCW#3JnoV7N zK9Cuy9 z>p~(at81muM=fX+g5ddS$V=^&MBQKmz4C0xt2fXw3w8&-rwKTeesZO@rnagrYsB&@ z?XoO8*0w-T-nLH2_+))ncAEqLP`}RYikIWhu zdu+}Ftw&wq8drNsx`&N6_Q92WU~<5{R6y05XUs8Nxrt%4NlxEHO57Zh`VIl4{|VLU zfd6LV6mqJBeL|(hUM*&jwxdHD-j|2r?atP=Gfrn~@ZE{ScSKxS*yY-srQ(ygmv9wS z5h+Pm`+MyrOqeCZfYE9^5EdAglhZo4v#Y0-&*?Z?HIgpY#9p9DNL`ygJ^2~>C`~lc9B}Kk;<3sDIT|r#FI6}5BSSwBbIVU*?EW7D3&Q<&M>}D z%BB;V2E!W>!zdkC&Kq`C%KDdZm#KNCO3BxiP*qlB%v+0G?DY;m!FwP3<-^4u;cR=? zJ^Y~a6^Sc{J|W>P3FqW*|M*-!l?RoNpyc$^z>z+#qhd#r{1dox#q&xQm9W5B*!%?X&7j_P9;T zKPM$_h}nUW)y^dS6M0ZC4?U(S^fv z7S#3;cf(y1Y|W|iwyW}TS(_F8yr^GUWSz_$wmOFmxnTRbnkuigT75wta*XQP+a*@w zJGBHY*`*%;#N)EyStrplEAEz)1ZuxX-Q`+qJ;%p5x%K$W?DvmFb>(ISWL8JB;CY3@ z(`d}6K`Y$R@*Z(-Mr-cD%=A~IrT8TMjsdEr`jkAdX~-L~CfHSOIIVhVxay)BYc`cK z8&=guw@(FDIIW}kdj86PYD#`4$3I%dLUh2s4QJ#xFg$jPT#W$T0$LFOD{ZamOqu( zMo5Qn@zcoem(9*4$e$cl)Gl;mrCg{%)*7hmqZGOAOAD2cGmiem#gtx}p}Hz7mT9+j z2}eBbUh}6Cc&KEdrc#5(=I{zvwESt?NnX}LPYABXPs39`!-^W({O)1ILbUuD>t@!P+(sbu zhbxutB_74x!?y#2q;!@Pa@0HgdHsdbDP-;^%&JEhQw6v(%-Ud=@d@}E>tD&I$IpQN z$;jVbRU0mrt_jzy;ieL9liNLQ{@TDq`i{9Xix@KZy5%kt40*!~J4)6vP*C~YX0s4q z-`g5)7Re#^mgq}zt=Im@C)Kfe+e4C#)3tIJ1_#hm0{KLw_#&N3FJ5iR6@tPPm*wp! z=;c1>4h}^KV6SserS(+?GL%TEds=3`JE@qvTS0;E4l9RIB;ZEVAK2X$oqqH=+l@Sa z_sE3c*|P+hJo~9XZCe*~h-GZ+ls`kZJtb5zdxh@pjCSb$>Ov@4&Yh|mT$Y{Ry2P4i zLraJspmT`%>l7X*9SmTc%c7YR%L?|b8tuzfuqJC*$3LO*LXH@JqppeJ zrY?#WdTXqY{z+99Zt5jLG|xxLVQ!F`YAd}~=8e$i5&0H%jnxQLc}-P2Xjtz^5QM0F zcD{-XZ+DF&K473gXN0|qfNm<#W>ji4ACb1wxZAn2$#0&;#Pp)^BS#4p^t_O7IIV@ zW-7*zFiPWByP(RNa)SrUE1zlW#l>sD$eY4oMnl|0Ky z?rc#Gai2SCmfT(YOp45AsvV;%X-8eg2ogF~LaHQmrpP^3B0r5r8O|$4M9aHuX=2N# z=kR@T5U(n_wCiG1N`Wn$0ymm!1~N}$Dt887?PFfi6Uyt{m0tY^IvT&ixAQQwS%Ejg zDlfN>+|9)%$SV8~i~oyh??W~1@$!+H`qUc(bI{~h>Xkwg2CEunsrcizzqp-vnO1)y z554NGL4?41B4mq3Q)6AKN)(?Y6VvR{9)es^@DyiO_|qF|zJ<2)WQCgVhUz>W3pGE) z6Gjy)HN4@NkYKyTZ%Cam4sDuA0sqx}^pBOF^!DZwQc_~$^n)wr(GNs=&=1at%5gFl zYAz!OhFhN%`sZE~u)lG|P{|UH>&l=!gW!)vPf08k>{# z#Q24Z#KdTe1SJo$nOFK*L>tpT7XBb^<&TdMV&s_=j+SjXIZ-a2P zR(r1uf(%*FC@J>Z)w)`aiw^gB)b(n=rJTO&DcG3`Q=v`=(tMNn7JIItPbM|v!C%wx zZU6p@U;N_KU-o|xbuBPo&)a7-{fng5R99D@`p7)f_R&P=nea;%NOd%I^9wb^zPI5o z{Ear9Cnem}!*6`YM)U4GV61RPqrH3?#J<$*2uHi5$dBdo#hAD>&crugoQVyt4cTjL z+yn6yB*n+-De#)9kkt&$P^AW=Md1;7p&XIiqcLHBCUu14(B09!u1cFG|Z}Ru#EH_t&e3hr=)6`K_WV=sw z$y0O*f{6Hia)NdFwEM>x&C|%|+o(P_@LBN^Iqn~$`ROd@=akN+`RUK|$nBNf^@K2P zd>aXT{5U`T^9_e|U?k+swJ^<9_JuieX}7-bae_vn)@nQ{xZuidUuDt=WLthUba_B8 zi9b0^rkE3>%i-`#GWjU}>{3|IrJ&+Z_gyluUo0o|y>*R(-p`*?>}J59BYin4;}6Iv zQn`-n38(p{@;&w+EC>8)KCe9g+!lzU)1qFfDQ6H)nYR>v{r*M{l)0`zw!dcSxgs3d~t0Ezyx@oj18VWCK$;UF4uAk_; zTQ&2SkcVa_M(XFT)E!E@=bkEcOOyRGXLJ%)X)Qsmf9r6po3bLs-1i(#74fO zYhP2iuOu&BJI>dwUf-E3T|2i&8kC`83##sPuaJJ<#YftS3Wy>y@noSpm2x@i)6Z48 z(Mjd(aZ{^~82Sn4v0a39!P`dD?`SqXZ#>w-gWc^<@mL!zKPO$zJ>EQ7EjeMLfvG384)l4|U1V232O0DzhWGj7{B}=P*8}s#gCN;#FA_6ozz#bdo*3 zh~L%FCEFT$h{=7oD|xFj-!Nz0ErukS25!ssg#EdbRBtQ zyLkbAv!{ZG6ddlp{QbnlbTHBvQrUCKF2n64!>zeb%e}3#s&C(OIZ&922o8}EU7Ne8(Uf&Ac<=&&(d~Mvv};*kJ&u_r#$xZ z@Rm-S-5XZGRocJDpWAKpp5_M4A@S_A=VIIX^Y z1w1kv+5|54Li1NNR;?8d9oVXLgNy7a>`>bq0va2;WHLp##q>} zlj#GA^CvBFZp&S3orcjM{)$xdb(LsYBnaM;=+sGn)Ja*A!ch>O4CVUokZY9*9x~zx<@BvlJuPCo5W!JD+wa>5-k31wr27A7i53jVKk{5 z(xC^uG({-I->E_k0+~z~8t`5SZly=YvtqgA1(ZX2GsImxs5>DKo-eE|+x!W0;se8788GU_X*P?JNIbp^S#Jz$W2rOwVK^#6o@wT)V8tk_Ijzj{r*-bOv>|6RhP{rc5w z<1}t+Lhe!-^T{Xz|4r`knWgoNG@t8k^XJ_G+L1ojh==6gH$V8 z6j!ZYlFt`YtuD~l4=a(sH*Uo=)UA9+x6=_?t2&#vSF3AiRX-k}RmEaT`iSVC02df7 zs?uPeYwbkeR8X$57DGo(W4-u!Jxe!U6manzL;+9n-(*%zYB;0xDtE&frC42y#UM$o zxNYX&z;TG@98crKGLR}!G|Sn z&HJQ%aYosPq)jq|Vvw1!<;$d9HlzM#(lX89qh$KDZ&)ODiEfAyAp}* z&3DkLDS=V_ae3`%z8Flcg)?b_HeD$-@t?o%1!NJimTBIAl)>_N9k^X=nP?0Hj} zi_k0MVb-zLTo`6OIxEFnW8L-@y0I6o23B~xm~2Flf1bZdS18{*MyZeW$E8ZtM}M9+ zdadXT;gF`X zso@}~%X%GqPp8UpcDform-&vV*Sl4LKfNz-69xVU<6)lcOIQHP=~CA;{CNm z(((_KVw!toM~Db7ZFwEeozcukWDA!ac7n77dfB|a1_t>fTN%F0Zw>6+$qJT7xDAYF zJoeaQFDC=RuOkZwsYdGds zYi|+bOfeKz_P-^rI5gDH4B~LJkP&~u%>y>U6E_do@AjA)e^c_9QuB*!arE1pWC?6f zE^6OE4Gy2`g+EVIgCp11s9q}yL>YSSJ$rCyb)b{kO8Oht`y8Q)xJA+TxXOKn%54tJ z{UbZKHkDR2?lzi4XASnH`iJ?RrQGot$k|%bFZr?}Rm<5yS`q^aqkKe-8 zkWKMtruOxT`@`~JA8sMnzzI>`-+$*n`B4snN&jI?NhY>DILe~;q1c{@(`Q$!6)Gy z);$8_!5{F!KRqDxvv%fM zfo$J8fK%7$;9pXMuckQr3f^XvJgSPH1=%X=>$-THLVmlvJq|8|tXSlfvxKt9^;o$h z)D-f0RgNhnuq)Cmdol#@{1%s)M9OBEtT+VhaXS4Eh-?OUTAoVH% zs|k{7*J!k~MO}r?=E=ZPJ~?Fw*y;~NO<9f?2G1YHeEF^Fnilz>PNn|!89Zu=d)kXF zhdL`5xD+03BWCgPaPf!yqge3=v3xrb&W6d0fmtjZF8N4;!;57XOxQbKl$$}Tk7?1# z*KX^J*T^un_kWjJ^D}gp*u(CIFU8k;SxAR|`8H_3r|VO=L+1ZOn*LK1vkdd~@Ou1f zG#f@3=F3>go7|xz3p!RPg@~s~l2#;y(SffUw8a+*nl4TUOrkwAyllfTy$2g^(_S?gFe;j;95I>|Db2S3U*~B zb>@K0kvdED^Iht0kT%^>dsM;EqQ54@S?vAH?TuH_g%BhWqPx@Wl*srjD zeWN{kGBvRcPDqPHvxm>eoF0tp+kb=JyA*-jD4^(lRK4B^`KzqQ-&8^~LGNFxmU>ivL?CbJ3P1ABv0e}|5qg6|9?N5iepw7nNGyiFtv69L+&C1q5DI0F)w#^JsagIZg;TQv zXPu{`Wf|c*tKjs#^L!601fGBfHa7d4IwrI0g8x!2g{TZFvOeYJj|1uM9u*7b68l$%a^h==Nmk! zFH*+&Mx-n~;vE)j9Udw_AF9TEtD8f~Y4vAP1G%wp)Spg~XYTKaEm1zX@|+Q?5bfdy zBAfY(eb1=&{_2bI_R=pm%n|ByUv~czLiGcOqgG}5UQ-3?q(E^uKIHUM{Zx!A{-JtF zX|(LHgVYjDgw!dY$ zRT`eYkv=liez2@!CzlqSzUQRfWw9^Bn*c^|!;1d91#9f9{%R?`e`Y~-&)Q$3v@^EO zduapz2z{v*#|v0_Re4!(SuaguaM`P^T%i587A?K7>Td`6xw^DhOaBBHSNASR@QKZn zwglaB{eYp`udjLrj@N7LmP!Et5~97E+fBGKQbr}!rmjs1GxFBRY%0BhpIjXx=|d7_`biaVkZ zI9lDapsJ&|7ijUDU9GQ;SNO<0EPEyR`WAE;!61*E(c?nCUdG27v%06@-4MkZ&M?o& z%;H$hZ1Q!6PZYl)QJH}&9z_o8k~l#BP1EXn17EtZ>>X0}I#|irUfmbX;NC%Z<*cd& zAioJVVgWnSFKXZQVR{G3FDygx)`Z-yp z`M)6MStyK4(laW3cb-hN`L8MZBqrLT6g_RgQbU8C_=DaZJevkVS_R=fw(J$p#1(1w zN+L<;WG_^^xb^(M*JxJ#Oy;qE7dMWBCN!GngMzHuUuLopjpj^5V%e0R4i$gQ+o_O5 zY^d%D6@Qdi9*4@Ab<0nN%0J|fERI=jbcu&=IuN!AMVdJtgbv$V*^<4KE<5Rf|#_fyn_f29#G^(su4=A*?JuAt&INtY`>WN$Ep(^X= zDp!Wi6`zwGe(Ay|CaE!QcZePfe@hD0YQy?Yc3sR~xXZSx_c5zxE1^d}`IqZwK3!ZH&u!puYdp|k1>u&);!_NUBZ z8Nv~Q5d$y!&89g?7q!~g8JoShSodCdZRv(gyJGW zt#2~KBS_hQE6SP@@XHTI0HVb>!+%I ziSYL^AnWCf+Gte@)91}7!-JV{p8`Cax}{-Dl2yBd1DUX%{Rx;b{HkQtOsI&BKz)R@ zB*puw83&~1?{?Sl0h>LxN)la|b-v)ts)fEDg+d!`i}#-J&2KK`nf|<-WnvQd60Ok)+76=`y%53nY!YCHYD!Pl}wQyH?eAYrqMl=Gth;UzR6Ms2Mmapuo}N=+bq@X{xLucYa)Pb6rxxw4mQNYh zf@{&cYna%_0WSeOLjlj}r;{-7w}pXkQ<%JU6_45(azBsp^~c5e^~pa7rY=S50sPvi zV0olf!mszLd;|IQ8I|RqsN;XkuM+$sS}Xjz;bv+O=kuhc$Swu=VaR*|zm_ndla?a; zPAh&r{IX;n$glr7!!F)WD9!jbzZ&-To_QE~Nt}el{-ll9NYVMN^lIs7hF62$`#O;i=As$@^zsv zQyom2MxP~*!%-KE!+xUK!~C!8#;!&B^w*gs@{ifLGT5IiBtqVvlk`lO-xrIY6&iN|af zq#%_yx?SMPp)y8wQ|o=heZ30J+ZgA8GP`Y2bzCnno(ZSNnP^(PMK>tP3wPC4a!Fe? z57A};>P3+JC&E(d+o16I8%I@S@!8QVIpsg=u}&H!R%(~t$@sUwYGT-8G;(<|kH8<1 z6b=Ixa~QD5J`6Z5QY1+?lJo^T>6%DUDoGPby39@*9Vv2>ltGf4q)VoMb@fQNOPvmBB6W#^%s5aF30!AA)UZq!ygu zc*9ya&1=0jf$gI@w;V?Z-12u8H|t&0Qd!8I&(rYDQHEjR3ho=0>dh1LtBgk3GMcab z?}8tunp>oZf38_C=zu~Ax3`$5e_LO$!)VTi!m{vN>h^P3_grnw0_&Y~3T{f>Ip?W* zj+(iCTOUi^7b9*#;85IPq*_*Ts?d*j4&&flJ&^q#b^naIq@Ket-LX+DKV5tvOfdtJ zV+SJVWXJX2zz6dVlx-?L=f9FGM~HT2Jtukd_Shk8i4I}zIdJsKi4tcPyF?(3!X<>T zbyjz8qr78U@i}!Ex}N8lbAR2r>x#Pqzl7;8ABXrd@vzrak`?Ol2hrTGD8RsajboOhHs*>aP_n z2hmgVfu#!Ie3tMW{|hV!2w=tk-v0GA^_n5!u_Cz|JGwE8$6BLhTOoh9aX0`5I}|Q{ zOLIr@QO-$i6RL-+pJkS1PPW@-H15XFSWdyW@z-4Y(jk*Aum!_0oDkwLT(`wMQxRUe z&1e*XQeiay9PnIvVKjapU}oL6whx>Y+#x~$z0K#1&3|?tcAoAimMvrvZiO|`;vSA< zyNG3C7H?tPG_|g~EL{9D=jBBOt*o_R?jDb@4ABTyE=+@$uQ_B?vzyUmthl|3N%7~I}b!N zE>U5m^Y%yQ%H>cJFG>Xu$U8wvU8GY3*r)%zD2XEdQRDh-dtq^FgqV&82<)^a*9aBA z&c%(>!{sj%vQEe6E`D8)#aHaHXugsdh=I<)P&2TLKq=0^J|WZr2vbnqiMvDfuDgYm8U(|mY4ICPLe`rT>s~(xE z=b(d(##nxo`%>O2r&cOdzFx4HLXnxzR$f@NO;gd;?bfDkSEHF;Zk0yS zQeEz41_2|f6HzPa(%5RMAJEtoT6(jzbg1rM9ohYr=apbM6FEe4-@9_`Fv6J^1d^Kj zvNZRgN%N$K2ekNQOoyt))tyWpH2QnT--c0jXnw{7!$D5cqw_Tm$A(ZTJa}{9#)7pBS7)}b>R})+;Z(m+_B-N2pG;@C7RNP4O zT>|u*d(qNAjARaVj4CNAIJN4p{U5nhL-zP)4%e{qddZ9NneiSOv+o1RUl#alIM6G% ze)<2M28q(&8yjLmJj%J4$1^W??szP3$NpYNih};W4V_543P~pP)6TpTCii~yvJ}9$ zl0~qijm)EwVGd&^fk%3Yl@j=f)vbginnmA2mApfFo%m?6q9N>4Y`E0dr6K`guA9!b z2o-0GHMT2UcP#I;+3{Go{3sWTpp02A>JY)Eq z&%f{UkN#=ss)w8UMZA*TRnH5vp=zgWLPc;qCxcAg!Wu4aycn+A6)x`#*S#FB-WRTWExhy)w|H=37Y%@W5W;nh;kr<`ZezIo;c(rf;p)f3 zOP>laeLB4KnQ-~D;qq+-&0T;p9{4?#*KZfse+L>4zot6YYHmQPI-EPawUy!RQmJ(r zwrN?W8F7ABIOg}AZ6pN3QTGYtEgbQpxpu^%=nMA%uaGs0J(m%w=muCOpljBva;1 zADqY3vi3R!6rJ3rP;~y9N^9gJLOvJkCjVNt2bxTZPE+v=jHU%}umFXM-qO8HM; zc6V_8%AByuVBsvrji9f2X+c8L~UV@1i_FI;$1@}+Pv^D1_QBUPV-i#u)36$Qj> z7aoN{%N2uG9}3sKC3p8MJtl*ckcceL*R8c?*WrVvInX~x7=$}l6=UdVL7E+icCta3 zCA>kgZHr_YyA#amvW)5KCmmX3SGa?0!VBYyE_m9w+cvg=9Ksq7Hm~O($ z{N_5p`8r6|lWj&nMrqq}1cy9u7?r;pEQ}}H<^!z2RL(ON|fz)Pl}+sf3GBhw@pc1>flf_}XD|)gkM+{c@PT zGg_I(n>j&QrS<%@)^kI__Gh8YJ(XtjTK*yoFb>2`?QsYHA$F^ebZ*ehoF_2DNT z;!}9jM)}?Tu>3YZD!&^Z=NBWH9sNn;f2=pyl^diLghezOaU3EJWCjz@v*aY>wJxn$@`^W=nOPzLe@Yu4h(HCUFt~Nh~A9`<%ElaUyRrC-QE~ zoy>{6sehFQ$#%IiDCFEL27rSjknQsTz)3ESZ)M5htt>gsl_jUS)az7voeE8eK3(p{ zyT$qyx~zS!i)Ds%jmW!Wt--G8M~cg8-x^WKNj*6NH>A5M)pH~}*UCl%JF+mB!-?)A zLvj-5_=Xs!u_fwwL9sJ^}?TNoW zB(EPNUhC!c&BW_Ud3`zYdWXEelz3ezufIyXmdWdryk0~;$#__Mq}Y40@sJ@6T9{jQ zA;l-Mz8pYt4+)H_i*#ED$_qfe7XsNkn3cuIe(^!|fCjSYLLhP-_W(?M3dqF<)eH^f zjthZYH5f>y0&=lI)r%5Bb9@&9k>kGuFlkk+e6d0GTMcC8g+T5f4CHPFF2}EZiNC*1zbdHD2rc^3<5y2tcpZs9$6P^IG@v;)x*N_<-d=e1vU}6RWs}edQgDmi1x5?3C2qBLh)>9R z{!$$S2hfjw}GRV>#A#@e zQ#Kl};nM(j*q)S1c3DEPc^Lym3iwIrWbu>PLf>d5#%TNr&&JjgISF7ihIr9;`Vg&e z-3kIR*3?=*;WkE}D9*K38M{g-G~oy3-VhwcF7ZuTBLN}38V9*ekjn;JmlxDzt`_=L zCEXuk{!j`nH?xbDhqGrITWc~43wEqMzQk0(P>TwK8@5ru1gsN4zFt~UYyEYoYM!JF z6p*w>&L@dUqJ?6z)hliLInR;m>_~Z5sCHbWIv1@gR69OWJtm&AVSQYq(I`qeq5 z|A;=CquGz%M|sO^D07Q$8!o$(7KOdOP}$u!A%x$$2!p3da5b6479~57B2ZBMYQ1`U zH&~bLjIQCP#ct!l*Z7owa#|o~-9nU9GxOJYEQELxu^$#dCbWyQ{wRXz37-Ht#(u&x(la7jTRXYFR(x+G*ujdkTj)n(z}QxF0! zxyrW@E~&9TH$-!)?HPg*=Wfy$SpUop9Icf=cX{s#_oKLGMar|y03j?g!asN#Fmzo_ zIQR@tAycdcp&xKC%b}5{acJhXUhC(V+ZF$kZ&aLx(D7}f4)jgEfobnD*VcHg)_19@ zE(esO(_eB?0L*;~KxQ~7BLo1K`rcBQuN+u<1v2e^iszpMKOv?U8HbG>AleGGqKW{Wj9Chnk@PwqIlsn8omK1u8N3xrTga}qf`CC~9$$P4NQX+|yTkf71$b|qq=?56~*4})mB>esBFu&Ast_eQHN>ro!%(tu(M58c-kmR}MqWzRfY@0qW*i+;Ae ztf%+FWh<4u^oPpU^vg?dSMy&pIcSS4;_JXPv*E0C_r0|%96mA8Fz0PPEOQ=ebFGy- z4g|m{V+nj0eo&6TS&e_Dnd*_%aJa;?Jp81brfg6Xn1En9BX-=fOkz%Ri^jTfPT$KA zqBbzZ`YC}`tQ=Seu2x^;EF|<6`9Ds}|4T&vV~>~}nd3t3;3~$lfiqw{Kf+Q(^N2{f zMKAxF;L^k}MN4b~6XncXE_;e(4 zvC2B11yv700}h3ZL3;a+K_9P`hIcB7*!ejXB2z+@l?8OOI-5KU`wl7AD?V6#feCOU z65vjfe4g(Lo9%|S*n#cR+1Nf{A?tM{4W-d$Jc#{2z7C6(XGf|twYtH$$ZnXg!d!&6 zcYhx?{09Da{$qng#Ff4aD@ zf~+DP+4$iSKQ%wEm&an<$c#q6JkFhLR!wnAl;v)&z}g@?spkDt+0R)PEpkUQg^aj2 zu|s$O_taTatQ}(&_k?FnMNp1mB!5*W+`ddq2RZ^bj?dA|Kd6%XRY|7DSKd^UT)xVk z8T%5qR7Ep1bhUecL*T3_9kV7&DQjs`CH|l4iAW?Qh_llzS-^k8zf&Q>bAuh38_ijh z6S$hQrbef1G)ucx8zoOgmjv#5NN#ltaw<7GUlP>}VBmal?$v~N>O3{ZX(3ByPS?`BiCU*%m^>@ zgy(1U6;7t5Vzvw~%Lvc+==V`FG2HTU+*pi>disVvMRpZ|s7m-g;Do&#BOGBDL+TkqD ztZh5$@>W?Nj@E*W+t3I`hT{36Lgy5X*YZ$VrZz|+bCYOVTw5c;?Tk#?&5{7WfK9e( zChYcA%0*ttYrCN5w}w?#hR!rtVgs@tndAxX%n<#xMPU>;XU^(rd*9`Cp3>Sie5F;{ zxu7TmW~fLVmZ-i%pt!(Vs8KxLD8T08R_wLDE=W0Xf}%6|A)` zqo6qyh@gF?`Mo&WBWo4f9YcZVh~1Dt-cHCdhnrRBq8VZ5ZW(@OL>+L3OEMyJnHDla zGHB14bzISrQ5f9mp{0uXS&=Y_XQphDHj22k1pFm$)2e8pJ{3Mau3D&G!U}iIm<^f(`&}XP9H5pda9Zsp^~YoQYbXr+WbV=&^wzm=BQE$%0m@ zcBmwv5sq&g?T=>u%L3!4%IHhBuH|wb;#TR9xJSY+zlJ%0nOnO zeMJxnZxZMlOHCo6kJ_(Nnq+lGIJ8jmZS?Xh1d7woU!diZpD^W?Y8k@2)qe@={E_HP zg*BDdzrG@@;L&luoBD3|LoT1g_{V&-WMAdR}!rYVN49rhams=!Ic* zD}ml?>u3%ETK==|B1kj={1rbMdirxS>7CktMVUL^#AJHnPVWhaHY$2PoJ3DWZ>%E_ z`%ybN&aPU26j`UgKYo$#vUx|J!IovTqn>VRxC8E6-xu#M1)t@BA1h=6AJ20hnlm*t z3t1F!rkD9O#)|k)-v64aB7YRum6Pd-++UrYsbTPYoZ0uLrX{qr_1irGPvcbvzC%ZfgtdOwOu8f9T zX{Q4kCOU_Q1U{M!se_s~_`CZvzf1q*EZrHYbaPvKCMpx`y3Fj0cupP&c?#zQPVVGj zc3@upecX4Ir9a;?XaDgcogvtoIw#PhvRp?NPv9z@C3{ZW@zla1&W85^M=tVK@Q8ag zC-8wZr2e~Po`_S|Fk|yDs${i(BI4%G_>f0k?aAGe-OG|%9H~sNKjU6~6X2blHT7pW zNWQ(bCe;%gBWKHbuH|`{pgLxI>!MUoLEGvPR2s>=kyaG6t@LLI(xbN zteavwd#Yr2agP+)v(){w>h`o0?nCB2Ea*hZ4=CxWzn_cZW^o5slSBf`>u8_lc7$gU zQJwSbM$?o1c;I@GzyrWe08cPlz(cNNQr9e3a`hQk*#e!9tKI{8R%||a1#U~i$sH{n zO3@oHQWQX3IK>^cmE5h&Wwez;Lf#?4HbgfiR=one$zVGaY@GpccBkfbC`_SWRpcw~ zlRI$)mRmf{VUY#tbc#DrSbsJ(FhO*X$0Yqk#KX1ZA+B;KoESImb}w7PEuBLH>*?|P z2Y%)LTJ`meC-7AP@}% z%B_p%=W1HXPaBf|ON=MxpA2jd%7mR65)<}aGVbZSV0r3<>xn%)&)1LmO2YR|12?_i|u|%c#Kvv4(`pys@;7Lhs7*6r@fjN$zmS z2Y%d5SucOL@FBQnp~HWvuNRLoZ%5%mTIaAbK2-WvGW_^_D#DYtsQnFDai1!=TV{Tv zNv$f>`8^DNlFCfrzaqF@lpu#c%ja4qv+8eX8X8_lvr6WR(NfATNX2Euvm0M!PW19V zu95`2HfmiWCp`p&VVz1CoD`1qm$Ie)tErOWk`w1BkN$L{<@W2XyQYDQ9U?T_{9Y%Z z%^!;Oq|*G}F8QQI{WDLtjSS2m76$vxbc zLj%lN=ghgi-bxMZtJg@?9$mF)?+;3?!JV1WjE&K%?t=ZRA`SCZ7bWfRz%SgVrwx!( zu`I@y6L~z>RMlD;tj~p1v)pc@@k4sq*g7lIoa-SN@+oWm6sb`@dgQhOrZ3T)>+c`u z4CLq?x2iF#$C&retKZZ2xy-b}(89DnW9!^81#N4IrZsn*vGx8j7^0$8-UVjWJS*oG z0p~K$12D&biR6gR`ihr|N{ZAM(hKncL+`9yYiwPTxqwf5XZ=6KeG7P0)wTajW|EnN zfiq}?s8OR}1qL-5S`#K}0?Z@=lLuiEEGF@`Hl|!^F_{U`l8|unn3L@w-U`}Qxwc;) zw)I}PtpX}y9+n9KH4v&nP=iuEVWz z_kdJ^n>r3rHCwQPE%k7S-W4VAnp(rC@Lb_9NT=Ssmd`s%S?lna-X`Jgt=Js{E#yx$%BS_7J6d88CHFS$ncn=o#XJ3!laI60G|sYC zkdle)2ZcCxiY-Qb0q0i6Pa%3(&s!18JNcNxSN2M49tPOjo{W(1@-fTk{sfJuu)sVB z?qqbx5mux_d>r5MDfX*is{RkW3A4iGza`RpE&jRbdFub{>-Y3(3lq{{SC8UIj z3GcQs#LR4;q6vNmO z;MpM8pl?3c-+b;<=vxwH^5Y>6@g8ksUOmTMuOEci<(?1^a2n75%W%Yo9G{;NK+gQi zax6j040*8F!C5xXI^6D~JfC?MUp^GIJhLw!iW)Sa{OA^)FEb`Q0i(VjzG0y&>M-#~ zHiO~+kF`YFh^EhI`v+K8F1qA$P3steAOdgLFvnAvT#|IyoIp(DcSRsyll}Ddx`Ltr#|!w&FjV; zfF4rK8>75LC<}Llqp$u&ywfGoas*Z*4hQqmGtqgdNom+`3Rj`-VW2DZn^7X|75aCi z)kbO$o%*3xShV#7l>w|ta7RyM9R5Z2w`p&KBAY~*ZN>LA2t=QG`)oZCK2N;?TTbW; zg0O0*_i|qbkk~~YLEa3ddWoi!jw+#P)r&n7g$}AzFIFG>SZF$&zUsB(!ZgER<0qib zY!i)Y>`DANVqYr+?#VU=(}^}4!u};S-Hpe{!}`mq=%`NS=UT`Qj9uxyMw~OzQ6K@K z%Qj3V`t4M|w*X80@Bx_*QIC!&NDZ(#LVe)J5agj4srgU14^3^%UaCj7P?~>DQUiGx z;H-%O>O=qkg0R{P?|69!sSVMR{J1D_75cu_Y%Zz@LW8oaTh zuA#CBZ+}Z~7gIg{$*Bf}w7MJ5pP=XIBenG5T2YnP<839qr4-Zx9=+Fshb8oo_Dx!v z$Q;wMf$SOLRDiGPdMbR>w>AmCZ0!Jm_BGMDXdK#Hn}A>62IQ^+I$A3(Oq0hp81XJ| zPQfCjiO%q-y|44p8$R-3*NzUwRNh9I_1JK9h;fJgj6DAaYF)i7hiVw*9drjf48Yw4 zssxMWT93{Xt^NT5>l9y17(G|l?N|=NWq2=RYw5$8{wCf=$(7J*wd-Hx5yrOREn3Ae zxI)^pHUoD8`v}HHLI^hMbF#y1%-|+_tF&ehcsuOfGQ{QkvJWxbLigUQw^rcqN&NjU z{`TPS2>znJjq8a2z@I`L@GK7ZeVm-58KjUzl==pJ=8gieY7y;!6kAeoTt~&@s;lYV zfMvr?xXZ$5lsk-e{;EO^xy;@k0Ct|ZrtuI~KZunzcK1#VbNba9r$Z$X-TB!E=*~{n z16^>0;orpf1j9oTj$wEtBqN5mlteH*nKsy4CB^;L`C;xdMR0pv`1SF7hyXN7rkc`? zp8w=^4&mW81D-YTH(qlZKekip;%|3Qm9)Y3ysO&lrGKWk4ze6^4B1BF3sfR@CV+Sf1loZ zKmJzZ?@9dq0e`#jcLaZ776v~-Rzmkil3Yv5KB(zWx6hx_tvo?a$6&q)exviwg1*`@ zLs`L-B7bf5vM6<474In~x$Dxn@!OjsGXEkZBF#YRcfsU9MX*O4N~6gaod5TO@PJ8P zMfQU)a2Y^Q>TjRtci>pfuXGQ*EU)`@hpMKeCq!rP4^0)NXa(Vj4u|kH0=Mb#wo`6 z%R=R$)p$~%e)1B{YF7DG(vIOzz+_sz0Jg8(C=JNGI5i3%p~+&}7Ru8iXiuSc&YPh5 z1Rp?g>i0p73j$1 zse+nc(dlWIDlvBvdVevN7>7Cm>xgHI=p97y?n{ zA=An^knt~kS8pv(=R{gPnJ;m!=k%n{!(NE{SN*tlfz(9WyzL`oBJqAi3ZBaGeR+MNfgW4jRk7=upw>2rUt=G}khLb2a2aC-_ z-WFBkZ5c#cb<`Gj!H9(GdEQo6FGrSuYc<;9N2{ri-Ee_any4CY3x^m9bRG7Q1Y#kf z%DZ_RG2|W=O8<`D>cC$P{)+H-KmKls_@fcYni4?lf|P?rV(66xn&R<5kJQ_qYsKkF zWg`{ILrmfDcBM8FdBB>;a*1D3E(y<34)NTGvy_c=PwmBO;SZN~@S$A_>pQl4ijc?- zu4V*=T8ywCj^F3IOsq{N-MUPuh8OYtR-OK#DvqC9jlJ} z)31g!oyD4Hb#-2JtWj^B3wB(0{#op}QiuMT`b}DW>L`cq8{zZsYy-6^PA4dqIcx(J zDZ>?k`;l+s6}XjmkUY?Ns|47~;vhpVj6sR1@Phbd6YyQ7iE97DReRvugoEu=bptiP zk2aSnQ8>^}&$?kOV4`KpC=~p>v>iX-aFvo*kc0$UljnA)xIA7J#Pz5~d?E z3EF9}5dR?cJdUl z&t^@6OzGLdZ@+KsVms*eK+UkU)iK=LHC|@{S38D!I}ZF{=wR^>o(`2M#$2|8Xno)Z z!w1?9&FVt&-VUk|EC}C8^;a_ z*=iWsAL4@0T>ArftH|k0w^~D}$StG9k03NYJ2;ocv$l`S$SI1&!Zzilq4>e0ZD+=_ z_BQo8Lwk6D80WKehWHy40VG=YT$BDMg9!3S_ywltXWCuXRU62vlvW?YOWi8_NZD^% z5EpE4P%s)Xbecc?@BCYjFJZZZp9*fYok4IQWG9CcbSitqsI_v}m$d?>f5do+cB)av ze94B4D0HcYP{wk}hGJ0YQVpSu^^y&l**)+Re{&Q?hcy&+?d>-p4gpYb+j^?K$tgw*Ga};Fd#Dt*P8vL!0_?$XqkA zd>*b5Z*?!14S3|eyu6w}S|c949*gF1kRBoV-oRDlStWuH@M-PeAlgUlwenx`1~Roa zb5_7-s8y>w(jRih;0`W2bh#UEMVBw~9$h~4RqxT|zR34td(CqX;6nD`i2e?T`&*>` zO4|q=rvB~+xJBxJiAOuAzxBB*@UL0f+KZntht5X(d*k{2%@+-DzcC%UydQPXN7pF5 zh5rwU>JeIN_#EX2?ulc?F^2m`%8YzpYOtX$!9X5}WLScYcH_seUeX~C^QrbEj}eBB zqyior9~aT|+X)}env2@lM8FdH6nt08)+7+&D?pVCDBJ6hJEC@&OJGHx}r zdL{7WO8~MdOTVc_$Cn)aLPkj;|Nq{zWt1^ zdaUem6_pVt!pP4l&^fgC{=!YN8YM_G%Ewm+ooEPwGZLBeey9gmXtsexer{UR61q?! zG+PACt8fM5s&v~?)8IbD#7saNh+>wdj(a~8TFP6)P6+~_kiIP%$x#3MP$&e`gVA#> zY+ckJEVlW3ZXL^nFFt?;u{K*9oF31tRBrO~&O~8u+1tcn(adt(1aNvCIezHL@k0;S zmt5}vnm3oC7s7TY%o_f+MB6;|If9Wq0yyQ)2ktT;kiWtnau{xI`O8pE(O4`vJ^J&X zm!hwDj=kbB{p_ENq%NAk0)Nu@t6LpwmKsUbu3JqmImoI*X5s9DLaBjvtg=0eWEE-! z8F1NkDf_S&cAWDd?apn+L*&1dKb3ku9f#0nUW;#%lfO;b7c|KI#*78t4{5s>jy(-B z3i~GYV+B0g5IGHF0sfy#G2%}p$R8VeJ|5Q-ZiilqcA^kb%Itk#J{{x9@J$M)vpaC= zpzW19s(s3Hv&cVz;|EdW-pi2B=xdF8&jjOqS7!1ODF@;2Qh$aDd!l?-wm2-ltk_dO zj4SbFA*|j~GRs={nNJgrlES4#+GNr~>+oA4-MRdfkIfrn{2-65`EVWGLy6lO?!}lW zC_2>^<$9#($B%> z)}yhu(+E)YDrlfXYBHlzi~vE0XqP+(dtUtQs%H-|#0gsX?6J9c+cKXVwuGU)rNqD% z87X$=IP$rR+37gw4qgVIDsL<!hDIVE&D5L7>0ReIEs5n7g~I=O}Z%VRP&;PqMv@ z_jX6;>Vs%E!>Ks-+a0YHKO2GS7;LWu6^CUz0@;OO`8h6xKenS=z!O98h;<7Rm;v=j z3E3uXZAJ7Ztq)-c2}kz!+6?wKf!8Xa+@tNE0N8P5thkePmi2rLaEtL9WUf7BvBmps z0b3VB9|FYHy{z~R=Gu?Ik1g)~ZT)87gbZJyUfvl+5g;Agr8N&gR>S+8a9g6@sC7fk z=lSqiEP&S;aufap-QXUI-(nM4CvEh7f+y??Y0DCQi`54XS`y{E7jfQ}7<~6eVJ8)i zi13@s@qVCXJGc$CAaQ9#i}j^ev-t14Dm8$b)PNBU;3wL5FF1BdjPG8s<`R?d-e_Mw z65_c3?#svcF~f;2$NQ>ioSYKB&7qqjpz|zbU$h9oeEB3Fp^xWy{~8I3XF6IX(9Z*a z?*-FGMtbnBsD_b0Ie@? zm|utZOO-qky;;-}+&M2Je0tK5u8dqDsTc2P-Lmb=kS_`*d$W^7&q{%gg4)`?BQu< z!_N8M6D9nBZMxO_2-S_nHXez~poMTyhC5941*)2v@f5MgDowC-b+f0r#_bp2L=T(M#IxXgnqpecqqW!8jsNBY9rdFGdno#bI@}Q zR{B@MdjfilJ0d3b^*9x<_J;-jpytv|s>Xk?u}$2jt}IBEs0=z%Cr8xTRLsE1v$bfi9 zILF>CND+Bn_Ct|h@5tSN%{3tM>kWi6x(cY~pzV>6pRqqh!BOHIYafdP^j};5*n}&e zht@%K?oFe}BX99C*gUc)HoZs<>yrGJB9Z#n*4@;WwqM>U0|R$ z;MiuYjj{%KdBQ$4wZ>oImj=YnY|or*IMF7cM3LIr2J2~aAH92=R&MMmT1LT>lcs8T za?&h`=wJSnQv^TXBP`v?zv`4AuF*sAEMPIy+3q zd9G2mQa3Q3WPWbn$Q^@np2j1PE~WLAnJDbf&hUG;tKTN*+}mExKn2x>8~N-R&s6#B zIZpzACZ8Slm|kfhh^~I+0s4u5#X~>QuPmlkyxT?9%TU$t+773+UK|@Oe-iJC)HiWC zGIlk2RDX=j>Z2%!xIV?PXjERqIWVl=J_RV$v;V#q3j1%UCueCKe1MCBLV4(n=Q?@l zoab`H&-0je>?c?*-|+_hSa$58pXeRi@v{s_SZUsi~7Z zN&eRm4k5&L+J@!R*Hw;dN$@3_GBQ)G-T}rzVa@CCP2ZE_shGVTaVZa>VbpK;B&J$D z3I3PT@xnGRQaeV}Mh$xL@&HO}ndRSA_u~8HsK@oUb{v=D!zghz;ps-gI~;21U8(vj z?IjQf{;WSnTL+`~N@*=nGR;b+Mai@(i1EQKm5QH|5hFIQdn%V@B<=j!;3%xqR%jXUI^$@a;ime zQ*m|(E^W2d>Pavm-hoVwX8|qaxsk=rs?_MDCkrfWu37ODg^~XCv8`y8{RmMUjmlh$ zp%nt+KMin=yu?|iSnVtmcI$ad}0Z^w}eaCWCk4 zQ~&U>Dg6#^#Gi{9gir!;fXqv@5AdZYuf~U=eU0E`1!g!dE5;`TN(DaI0{FldSo4^% zB~P6TD>A?j%|(hd`UKlRilT^usBCD!wOqRj4(N0os7B83LXDct1X(TZCirTc4pOahwyg3D4w2sJvU`j~GEf;V1%b z)shV+kJ&GObNk4Cc{?sgDX=~Abn`?FPnhaZhU0318CX$_E#Vz@LIe<)$L3n|nPpwR zI+?@Aam6`Qpfi#&`w^ij1lM+{@%uE$1xA6|Ek3k`HAkuac%{+ymZ1%!j?2eepaIgD zj1*WHfB7|jUNR&9iGF`M-FGe9z#nZ6*#=88r_#I&~UzqDyBVxD~CRXoGS!5Zoa z@``5w1n%g~mLS-JCyr%U85ZXggRz3>(w56u`&0?Rk{T%q9qXz;Jb+*M^a`o@BV4o{ zHTvh9_|8U8pM7ZM6&gSAjLH?Jz3P1XP}LW0h&$h9X67kqv_sg7DlocL%&M?P7{DTD}Cq#gX7^B9FQjjw$j2q(hG_ zu6WoV`t1lubUuj^qCFosyt0lqHNodN zLcdm@<1h4U_BlRbZTz`PzgFJ{G6MS?{XX|G9K&X9K35PiW~ik5vt{FvnbYSuO5nQw zidbEUOtO)Nt*`h~q-ylJ2Gm0*Ac~xMkn)JX&Cg7ulIsW=SPQp}M^W6UE7t*a{@6B~P2#W>} z{7wmJ=8AZ+^FI{4OjF0lZzXmkw*WJ9u0XQQ%To4Zwn*YiL8=ymjbal~^z{v+~Li9ta^lU9AOMM4_n zEnMs%Y2YMvdz4xMTug5YFhxw)Q(>I9%4<3Q6H*TT$4 zeJJo-R`VRNg=NZ)S*V~k9VeTmZ)Mb;nfwW5c1jEA5|)>(I0BD-wk6~MubG|uE9Ophkq;mkVb+EzSb8&v#Te@2%HgrLi9qO zNdg?8Zh?k6hJC({07F|>MG7!<3fbI#qKx64Reu=i3ZH<_?+-w)T$DA3Prhf3t0t6t zI0pU%3}7JnibX&40-?Fs6pQGG-tRggh6E82H|l4;e_KEH`o{F*#s3ri;P6MrlY>!< z+l+8z?mYy8L!uKEefs{~xp~wlN?uUYhvXrYY@?=Eby-MDH)8vP7Rbv0H$!s6R<9}L zVE;$xgnZUe`ylp?V1k5MGB2v_Q}ejfxG~Vh8GcujRsIae(a(We;E43w>!~3Zj<`t; zljxE!0HCl*4Z~}aS*2Drpyy+}mopLbOh&s|-p)*J&x5pmOTZ09`4 z0oc6ru;uySU#T!c?|CGI)?0)uCF<0Z^aw}Qe#YM!!QQt*c;dhqxs=gb2f1{+N%n@j zY1LpGRYt?PE>1NG1Q0`VdQOed2T6Obt2UYor1fn`p@mGbZfr{(2{_bB%nN>tpA5>1 z>yWhRI5Y2b9Mh?f#GyGDa;=`U#SPM`K-7PeYzg7U&FFs z?i3!sI5r#VE@C^`ZuOQXuD7D>jm&#Q-f7eddcLzvUr43+0s?Anv?z!SGc41>9;OgQ zeq*71K$71Ec&J$Sh|%o50~r<0@zm4KVV?uSY!U=NZMH!^AX=_b7@5mw+M!V3H;n$!ef z^QbBDFFw~NgxZ;?NdoZ5B76-wcrdqNF*AcT6T{GAW)hx*VZ!{<*C4nel3(~TGoZb= zsQiMsrwr_sbME0Y->LQ}kMoaam~K2VE!_X0Mc)8m>Ohs*9V=J0ItkJY0RRtr6htdPYGRkKh0NGpX<*Wm%M{? zUua94#d_%}48usM#BJ#B`5f4*v}$z^X?5S%>VDvJe2AcBTHQXa?qN~a@i7AK`dlAr zb&qIu|03!-KE)cv=l(>itMa;J%|~{*B%iw z&ym3$<0(8xC5bue_n(fLqmm&0#2l3b7Ql@7bNn4vpF|`k^zNTmqUz4bFKH*Fx=8TSd?MsU}4}IeWKJ|!q zztP@d_G#=uCpG14YlfMp_v!fv0kRXzeZ1md0U}Kfd?I>CtGFx*Y6|OI1QHbbT*rKl zzpCHE$0KI?s1fBCW0xzx#`=F77C)^UgT=1j0z?Y^@*zGYZH24rUZ~-?FiKl9Vxa5# zT%Uu9j+({xpSBbO&-jWz!-^5|(mN$?cU+g}n(|KG=hMIAebz?fBih%N#R%Q(M{w^6 z_f%@ACZQEG(p#EqNY$TI_fPd!YM3U3;K(9V1LEXrt;=SaX6+(C$VmdysJ+@dF7Cwq zcme->XF(P}3{62WxetuAbuIBv8JtvNwI!8zD)v;%5Je)fJehyxI3YGn`wHzVEjpy7 zCGfD|QGa-36c^A_^?vs;+Qcj5vmW7L!s-z`2qpNWm zny@&c$C>YV?HH=>{|#1iv;+OGQ+)~VtwHowL%6JcEll-Ba&*%)@-L-&Qte1@zrI<4 z1n`$oeYi$+`QiigX%6ECsWBqNoLI}3-&4RRX8VEK#PVL=#qWdEBYb#tmB2}nKmO`PLW1{W ztDhFah_q0f3RPIzYJ7yYE&q!C(x$x|y1QrjMY_9U)o=*MEUoslt8f@KV)yfsi*Y(; z#@ABe#dyk_fIxL=z-jV5`BxW}@Ab#XPi>3}i$qH7I6I>>((aA&8lu189Q^?Pg*?#( zO!O};8=^p{LM=XKufn&0NQVugIkujv`WHmufOrBn1%WWdgoVmP#@j4UY(UVT{x?yw z?k*i0@_ajNzlcdsLeA#eDr5T3D~vuS2qANXsPb5 zByZf#7+uZ+TzO8hJLthw@uBj^P;!yFe6-{^^6zr;qNiJ8n3S>)`qs?!B=6NYDj(<5 zXY%PQc-aDhI&@VRjK<@XeJxJC6ON$!<<~e)*-M10o$#NWP`(*oK|Brd73}PmF&INU zcSG~Ek1VA;H;JW6`5|8Tz%M!QIQHJ5NelO*f+@nDU?cpM&mR$A(J*O7<$QG^RVM2MN~XMtIJ;`6R_x;At$@8( zgk|qBVF2nNB^;riGew5#9)Gti&exoM`?Mzprz)Erv9{AAXOW(H9rRt!hvgnSDwnP zN-IMchg1XY_=;7hH;r&Gg+?tQ zPD`CJx^O4^r3Phqv2$Xj0F%h`dmyjwZk@m)f;Zw3nV=E6VqOxqncWsF$^EWg^?Jxf zHsqgY4=>(Z4~0T=;Wcs$2eMv-Yb}1B#kLuC0gxES=O)w5^_+g544UN6v(?O5$w}gO z_b!5!M4gMdzfgS*&2Zk+M#2IOP7R&6JO}Q4m(?6&Z>tqxF?`_?R)9FIfiXnj%esLo zfdawT;eR_Q|A>SG_tY=1g-%TN6gK>!a#>s+|?VwD)+&&EAyrDLH7z!C2hYSwYzc@8oo5`+&Uo+NZS@sjK zC%F1>;_h1e*{Z8R6P(5?(Z*9Bji;BqoEUs}N$-JY?0}wP{1~tt^%WmSeIg_(O{Zy( zPf~^3#4JCcKBCoi9YJY)!wO&B;N=>{R&9ir39MpRQgyK!l|Z>+EFAAdj_aGlZS|s1 zG&N+#vX;_~`s>H+Pk zCJz!u`48hU3XJwcr?Zj-D-5I=oN0auyn<$oO2J`HDY>VF=^rp=Gf`?fIe?Ogm~MjwJ&Yq(_le;JYew;~pH0;EiQ5fmD75$}XgGt6--=4LJ=`x{WQ z|6v+OPdv*}f`PUl;^E^{=#IM+qYZJtAz}82al=plt#325VVK0hnOJcj@*AH;56NZz zPDuN-Q5T8uan~`?c`rC~`BS(lLN*{UqJy?6VEKTtu$Q-Zuy)P@rMQ)RnTKq>!k^k` z4<`d~x2Eh$bN9l|CqN@3I86p%Fq~>4pT?w@VFM+rsK0msb9UhhB%d|#T^#)D zofLFxgnsC!!=bQiBLX#Z75Sp>jnR|wHP<2G-gqeN-Ux4TZb_`^#!Rox^1q63fNNwxSxlc@He*%^h{-c8}c_i^Y_qg~b zbln+?)cgfT7h)Srl%rDDl8sO{*GbLq)5FtvxSuYnjgzJ3F8(?OJ`Q!K)1~HDaVu?w zGZbuAe?>J|u3EBpwrHy3tUg;S7S`7gEI``wcot-kw56G>;YbcG zpEj?W(AIB|Ha$)fnY9Ha)=XD$A`{Le1?(C+{a@%`p~p~7X3gXlScvg%7JC9gktG`I z-AO#q<47>}BK7y{xmRH`Eoye+JW_KeF07t;teN~%GSJxLBR+;A2gFx2R-!dV4z?7u zf;ZOZc?7weDmU?7i$_UHGb!;%@BBD@B@;VK9eA%aTksUP*{O>X1v60ODJn7t`6`~{ zMIvHP@aF4KM8KL?q}K2vWIy1o80%gq_Z_7F@HkIpA*uQ|#DPTi6rm5vxPevdrDG#q zdHfijC{NKYK0KeBY15u@bSusL&Exz{0(*+T;pkVM;%}Pi%`&}u8*$g;FH*&)HsfDX zjCqt?g$Kzk<$ir!K6pmu86s8Sd>QwN)$_nkTn*)C6(~8pt5tFRQbc?zdfkXdNn^n7 zYcZBhv_@5+th=9A+%G6Ko0Xau6~{Kkv0W*COetQc)I6yaKdm^PQHq~a+;1pu90A*- z)O6F%EnjlkMHcxrzXFC*Hxiy;LBYSu#&h@(oq&uV=Aqq!4?$}c;o{b%92C#ASWYIf zLC2$&5lYDy);4c^A6qs4`ILSBd8r{fsZJ=fEgt_EyKg)+2W*#8dioQ}4nmyBY>)Zx zS76tlV+mbg7O}ZZmDOx5aS5UbG{EzP+#|%e*dfM60CxE4+(ANQwjXd77UZjsR1oHo z)KOb;9r(T&hir=&F$3~WQ`=_-UeLkw6P#JO|^p~I+#Fids*u_p5cI7Cp7o`R=V&`C65vkN7{mf`^Z?n5MSNuU9#);Sr=vnBRFRuSvbftmP%0Xd6JH-AwAdzI`clGjmz5hw@%)64W)0D#kgVPxpXd>+WyE|9_7D&7vL zg8Cc{gl+OLVnKeBns#poDr~r-sf~+ZkZgpvrjJWikl~jB3~wS{xw-TW>$6$*gVIP(92 zXLAF2W2LmhFuu!klP2J#EemJsaZI)TbRAxFnHdl9+q0L@1RMA)WYCJw4<*k&q z4z;OqH@1fEMraU-Ro0#6I$3)QlN0csr(sQGGR5q%3x0hRJyNQ1#pE)Zd$2$n69*KaE5aB9Yw{6H4&M(knG0m_L*5hY z$J7MSbIK7)g4c}^t-6k-v}&D%>yP5vFEvVFKjuCuZ9U!AA6I{vcli{$(YUYn=5T+L zqY&#_P7?iHLH$LKM*7=tcG|yK)x&;FQC_62i;S!tx(oVsCp9KDJ%h(MbxS?&--zqy zty05wfTjTgptRKu;PKW7KvMPzPyk4p`(*7bEnbp_f2%$Mp1cd;nPYbo{=)!8jRB|% z2Q4`;!3ol)ccC4$^~D)TZh}Gr?J2wbkLok93J2zA0rL=?%-hTHFKyZDGmC@hHAdDI zGzk{!G91t1XQ)j7EJdz*;PNkjO`pO>iNaIUO|d;61j} zhC#b`|4KwB>CVhREi_WGJIs_nVl|-BJ8hrE)qkQfrW;Gk+B-()?=Zd0gr6U4^qSAW zoCDG(H*qEoino0R{(Kwsk_El6XWS-j+8L%-m1zg(O$&Gy3=8D=XPNEZW0e-hI749y zaShbffTtRN0jnmHNv&hx)xKYFQWD2P?m9Q(Tw{1`Ka z{8H0R5&SqE*XMD81F?*bFvff3Jv1ki@-1tJ&8sr}wR+o`mZ%xV$(g=PB!p?5b0>)s z5OE-A;xXH7@DEcBJ2AZMj{PeUVznD45*z~`s_4WEt*cUFJq>aq=s<*^@j}pmqTdXk zcOIc9AAckA2K@y|NBT?hhUlq@n|q8zPXr_q+NGQeNiw-oz(DMO=Rt3C+c=^$*d5IbR+2uku5@Ek&KwZVDJ<2ISL7ML=-H@ z=R9c>2`mU_&KZyly&}94L={f2j1g7YoHe?+sG84N9F zC=R$1Na}7eN_)?sH6u=9v}Rt|81Y;CD8FeYxuJ?JVaZX25?{t^BQjpEqcQb$c`Rlu zkC|TP9A=H+Fi1g{YIku4<5YEN3|1#KUPBBf(?X7X0*enZcVFh*42We63LQiEj9zvE z2j3GQtss|MCeN6Zfus6P&SJ;mnM%n9-TO&EzAMQx>ew8;w&S(~wlj(sI~#|HnQQig z9~|8Xi2d*GhkRd=8HE&>eGtL`y`!yT0>m|`}Y49zhlHo zH!D8E*76>^4}nqU&dCgS_bfa{v3SD*DVZI>of-z-z-G{;G2q?<47fWv2Hdbe z_O|F}VEnfFj5zMqiZfHaVZQ7P&xs`NNUedC>0Sw|<9=Ws5j}>aH4lPWC~VE^Lfd)> z1;@xip>5H4ZWiNNPvf~c%$s~RBVixbw0ha&Leshj={O=q-&e6^EPIMm3zL5F03ECD zz;bK>uvoW)bWmN@tr#-241%9oZGxtM@OX_ai}fL2ygtJoSoIkbPc8>1(7NQj^L^Ni zJI*%JnIj4eteCX?cXR2Wr8iza8>))KBVZ#mHyEvytV%h!OsATz|aEw2#A z3&X*KzwtKTm&1Pj*0hpUD-jiwbY$?)Wg@PUvVrau9;66;dJz8fAs!=`H7&;rwswUm zKHlD05sP@+zv0aR{EjiFD}N}DtY#m;C8_Mt*Wok8lRv`rSKMy_b~II<{~*4`AQ_`? z)b#CBZ3YT_Gclzbktk3W2bofg>s!ASWz9r9pMoNJI7wPF4%lYHZJ$T8PzsMUfrI8S z`PF|+HAFoYzrJ-gjz-5n+j(z9|3vcS)z!i=3l-7=InErSOuR>VH?qVwwF=Xyw&RH13SIMRcw6BRqjh&q`@bmbZ7?%?AA#-Be%2e~pF6y?v_mOP zNGpZAQ6MWR?{9jmQaUZIbSg3{XH8v!TYQP-CKZd%bA41dwi$cBkj?<#4k{nHGO><5|9_*Z{nq#iwOjevTmBMMZ zA6c1mntiBZ8XZ9|oRw$mgx}W#B|wUE8gFZ6X~3CG5T&&8$j~-aMONZKRkTub4k1^0 zHA7)?p6zYaoIy2d!^dJfjhrWQEi7kNku8vyuUhF%A#bxbxl}2fskMji=yQ_OoXJ3; z_z)|cY45I#HtaeZj(i}JQ9N3!P9!guDqPapVyR&{U8U;0adNd$ z2i2Qy?;huk37AN@vTO^3hk{BcoHKBAtu&P)V>`N;sgSKq$2tr_TohNIriIEw*GkQ= zATkb4{wD23%DdHO!pVO#zSdK2M&a@-O$PDRQSu+;o0DEL`o7Xqn^5t zB&1@*lm^#)_fQ}sAsd|Czh@#fJhd%oWV_|V5{5ToRDp43E4g7dfyrl=QWTF}tmCR)2I*NDSFQYkoXVsrXsX%7J1N4yx=_77)U`|3ZZc)A8 zjVBSf`!#OA40lSYweGChBcVyOS556rM)AQ8T_3hYkm%NozC1~fb@Z7mI#nLW(I6kz zE9OC<3>ZcX#HC3=Ns`x;B z(4Z_qT0!xpTk$1vN&xzlm3G)%bc_>| zJriuBX&#yo{?SPyJ&80S$FK_-FpUEo{oBwA2?9;L8@>z%k^#Fh_WG>#hjkc@hE6^Z z5kc-oev5b|I4hE1=nx+ea)$h6bW7v{1 z^as#wdXTj+;TA;7%32(Y7lEw21gL<4tR*y31E$Nh!avmtn`j(UZ3Pd6EPewt2$-(H zbF@aU9->zSzwLNWkWgw1nzZ$dV8!2{z(t|ga67p7M)F;UvmVq)P2%?wr6-^wO_UiV zyTQ)@kgIZ8GzPijFvcr15qleCNgIR;{Q0$O@&0B4jgNdRnJJCk58c#_lX}MxM%Z-t zL6Y&3#K-ikjQ(GNZ1V7g3*i40&o2u91j4?2_`0@WbbT9b%CZh6_kP^rY2S62Z!@5d zWA2qdn^3>{eu{#uWIdqd-X}GGLTDxJgWNm^Z_ox?n&W4Yz_-1{mQiTP=Ggay9y zWk3)MWR=5i=Xe^FBzR0^%EGJ_p{#PWg&j!H2rX9paT^ggEvvk8$_RZ}5h_~TR54{= znX)*SYN1HQC;n#A&;7Z}6}^(R(Ero`rp`tFti^fx0Ub%4WtaQ2R^(yzeebP+nNXMj zV+4v0 z#(H?L_492_$4UEJRd)-Ha-*eDil7$hV}{<*x)7TeslKv}T0>wID^jIt?IP?@@(4ae z>w_fyFI4rwH`10p_Tv=?@B@_7a78ZoQ(eq=c}# zhrBudOas1let&NIvhNwR?_vKGts{b|0qufgwqaQr3eNRsn$X%!0x2JX>Z3@B0NOOB zk=1hRINpe98)EZ>Y;6XZ_py6^1dtMMLws_g+dEg5$u%c+I5`aO%CNjZfspHDnKF+v zBE9z>8)cF;@6&Sk?rWrmvl#bf^6Qjk34v1t$E_faJH!P7X_BdQ`zGCT4RSHv(r)lY z8JiW|ukkhsMesRTTd&s6#2^jxH8O;A#X2+LX=8ItmNH8!%xpLmEd+#Y6Qq1LS>D@jZY~CRA+NVrhd7 zT-^03i239`m#^d*^AxObR;H`+O}wKl&q6Do(o|aPxK&1rAh`Zufut>c9OtCQ9T?bw z=J4{me-my;$DMcqFmyD2K&*w#=nIb(5O#D7?nS)_hWPqpkWNg$f)6}DAT|C0zr1zY zT7~a|3wGB|1M&Bv@L+Zw0VF*t#5jg7!h2{i!MzQ3=mA3o|ZoK$}p>wohv54c%OIuwZpz&OEw|=x)#}WI^mA}KM-Uk!Ycvl`L zyoK?h=Xd-$%IC|U7{7#2#uh3=Mg$%oxta(SiD41ddYdxHt)-%Em3&$KSf~z=0XY=3V4bHJpUAZ z(ePK%S3{LHH;ke0D7{poR|QR2o!~v1Q2Ic$c}f=O2G3@VZW*APrd<9SWk(S>Vmr7v z!RCbt7BD5CF}Y>{YUBg-HCLYvF=eynLB&~Y!$!eLd)CaV1o?HcnbA_2ub_2*1aN$PrIqf@-U}0&bKOAZKhCU3i3%g*~A$ z>J%cl+Ztm0hzZP*QR?WcXK{n(|)V;}AAoWu@>_n25)6#xz))%vq>Df;p> z0q0O#ax-}O0hHIuOrl^F`pkHJRw7PPVbIK$ zS0jA_cCvVn68LiP8tj^>E!f%(VsoXBK|JOr*t*qTSW+OH(SWu@Kut!cQucx5kcVdirI( zvzI1%@&FsnXlPt0-poY0W0MoXQiM5kDUV7mrV2h!3@9{1DA~v^Y{dLff@xwY_od_o z1%R}S)Lh?!CS1^@|0PYxtEcJ2OoOm;cVAUAlMv`K+cT|L0pqgRtY#t>3J`x;fVN}c zVk+#QWY(j-B1g9k0ZFiRSYp+~EL#$Mxyd+HC@p`4-1kee>obnBFyncge0C3FRLC!uIH5+Y0dbI*oR*;^v6ID$FW;Exj8 zuD34Sp|^g5zx!X;Ti?N-yA|=t+Vs|K`1?+~-ugNI7Ix^ZmD*q08+z+=`1>{fqW%OU zBmRE4Q*W)^rMEWVZ|!cqHHbgwn|kYy@mKm5%HS{WZN2q4{?6dZkk_DCv?|3IG4Y6%XqK9rX^hrb5a+7~SN;V<@@bRQ{4lQh zQKB^DRBrw*FOy)Dn(w8nvt}H5L)4F6n1-1%si^!7OhC)@Fon}0Ql25^MwG)sPN_{) zaxrRQa8Kq5A;_mL9&T~kRHfwR`3piy(JZVMS~}ai_b3ItF(S$n$(W~p zNlm#El;)@DVyE(W1HPd=<-@-_v!;8|l>Lky7Y1LCbMM`zNQf*eM69O4CiKdJ;X{>C1g7Rp* z{q34)q;i;_P{=A0*js}KD5l!Wa@)hoe8gs!hodllXxrw|Y3j2#qUsl_6H0OkGI@)A z8L@LA06<73MB1y4XM5==ef(Xl+RU?;>sQ3Hym+5wHZDrTn=hzR$Of1*k>yyalKpg5 z6vCm0Jl~}7t2ve;Y$&|$z!#l~`dW*=+N!UOpI(ctjKt~qLRBJIN3M-W26I+uRtl}u zF6|$G&Zk&9xNNV^aF6GnFQuFWVf?H;OLRWXwMglA_Qez7hb{g*_gd;aL zlD9OjU}7LE;g_JmwzCkC9QELZ0_85~Jxb0rd1!{z_;Xa_?!{>(2~wkhsFsxs zOryre1bkF z9!8$`YVkH%9}VP{fhCAw{QTD*4yZSte&?+wrouVtml z&?JehhBiJs$6_JYq1r#>eaDH!+wd7e7}UgbsP37`auQiS#&Hr{)&z;UWYs(4_0A-G zA2E00({hp^^(*}0Pfek3w^b3-z;bW^-^)toUo#Q6Uy zCJA3;C5db)cs6ldrh>a1voFyca#DQ%=Yr9EvI;W@PE*I@3s<4cNb_;LFX}kaJ}Sj2 zB}pLNQUUlkIqB5{0x5B#qQ_#fU66XJQ=V7vfugzNd20AD292jI{jj1LN^ zAM`E`qjVm|klY?+FSJydzztIb5dQ2adyZx0EiG7ZU?^Iw_%|#K0Aow(ZN5Y+#+xQ9 zHC866j*}t*^?jI-NHO%@5O7k|o6u5irxcRZ9;xJRubfbs(@KZ|Z~fiE@u7h#{L9)|=$YYuZB^4>3ml@eP9!CPTf$3vGn9}ic; z22Br>Q_^ z!GL-d?Sm5Rwb6sUP)Ny3A%3a!q}cK2J#G93RPUu4g*5_$cpjQ?@kUIzLcgFRjAS~( zNF$8WSf@bna%hHUnjCTL^q?nR4n6FV>O({Uk4b3q9V`PI;GXgD zlgNYqCp<a48; z2BfX)p2n@R;W2*Wdxmb-()@!r8*#(uNN7t+?Q*5|KBd;9)Rrr?*-GIm#aXR5?;q9R z`1umJsw`(&t5|L--0`+jJBs%tTRGFe@eIge=t3@BmQ`)CBsD%mH&@NRQfj2J+461uY-Hl%49^qUM$vhxmV5P?v%jtPI>bekH(gv9 zyeZ$2vJ_Jp&I$L(WU*a+WjG*6V*#A|xxt2#;A&!kno^eoJaT@;}U` zaZY?Oy>`X)+U2xkRePV`k|%A=9G3f|?12iSEkJt1{4z!F?Poa|>|MX*kuP~|_z+)U zcX7>^CtqiU9z!9hZZs68Vn$|gh#j&Y0Q3j2IM20VbJNJO5?Mw94)J*>Fl=@wW43&j z_NAf3L?KtZG^!HCVc~wmyTAeMx+XKJ06s&f(%{#19l+L?V)^f3B_0IBt+<92E~hW% zEP?$)ac1}QA&a0srEQ9HG4ATm5_7@fevdjTTGh)4 zR;P!gR2rJs6MgT4=L0$%pp2K`F{9pNws%Ww>TzT1Rti0eb9v*gY7;9=HS7f`_u1O= zAOIj#8>dm1m$SPRv;i_Kfxnv-5@v)#-=r)MS(XCqaQd-+L>YalMZd(VFO8pGiZ_YV zQDrq>F|Fn+rd+de-s>UiNVRvR!%8aOgY2`fIN;GK!Oc0xMI{UhrWE)C_UM3J6(jSnw?Qg z2`uMw#d#l#0dmy;Mi_QB0TWK9)jN^Ou5X3UE~Ic2jYwXZ9{A_!^x+{2`f~CXY4&zd z@J`NyH>jChzx4nf@dSB7pkHcJJ54Z{?kj%4oY`Pz5Si7^!tO&(Do)T%jN%NBU)*_WYcnJs4p+wdHiwZ(Zq+d*aqY3nW|pGSmsddfDC!C|Js zXGGApRvsB$&tD*2g?UDlwM@T#!_!9aWdr}IZzHDOM)tHa9LBYvEon==c^V9ylO5BY9+u-F@z_)cHd}cgf=X5tWdnMW z-}+kg5F-O3|4eC9{Am;3jj*dq5H}_H6_pMsbcPBnA)V-0$5^ zZ4{gP6|_#H412P|AZCoX=TrrmefapO3G-D^qEF4Z&MX8(%}wD{tfskj77@ zQ;su(Hv!dbh=Fs4Jg%y+jJrP=%?mMSHQq~WUc!(`1M@e(fD4+~3q5QjF_?dq_3ve< zU1lqMpv75TX4@-m?GpTkVOqd8jvb~*OVi5Nm3sbSWSBnlPY%;(B8O=Qq7!Muv|4(y zjrG{N^@Sd}b(mB_S2)0dzJ$i7{oR#!X+$Zxh*bOPG0J-o%BlAL5slHZ3m6GF%V}(4 zh=TfxhE?N&Y%r z^9AP?t7AqK-G1Y(GD4avfg5PzB! z#G2xQE?#7keuZ}1A|~lG{r`xZ;qs*jM@O~%wlqJJ_Evd=`g8L1!(>xz7Eiczp;Jzz zf=$7%HX-mK%H0m2ZQ<2#h}@VoaPVz@$Ui5gO1#-j=1xB#abc! z);oXXDr4m8TO(I9N3M`(M6~Wr7`ehpMeUgpivJ6cleYF~>KP_VtRmu+97q`s8cq6w zDJyfte6k($H_fVDK{t&-nlq6NkI$Ag7{2s_q)gC631x!MmtoyN6FQJMG*Q+<-<2Bf zAXWMNDJo)gG+)D6=4(xqkKc^4|JX!H&QAZpM0pyE`A7y%qloZdccKjQFE>I->R%~Q z5bRM>!%^Zw;5jE%&{iYBD7HyAIUn277Lid?h#=@D9M@uehY`;e6|`*Is|lipFBP=c ziJpBeJl{kPP5&64&5%7|JQrhhdcL@T=ogU}E!aknM0XbjRR6l@ru`tS*O1Z_hqQ1e z3PB^$+7~j?#eWm2>J6Rsr;p=FMNEA^{Tfc!hv-*YL-L~jbGl}MQn>z>jBDeo5yTaV zD@A}badJ^UYpqO2N5&!bhM~)8IK9C8x3Mj5d$`V2H~4AWQ3(gV`i!s!k7=&{>}L4+ zNNWy)`r9`B_Mwu&kK2xpQ{3mm@~u8d1-31PAmIL>{6k3lp*Ng1bm2Ej`!#64M(sCR z`;F0lP1>(n`;FCpxt7lu!BMR|NqziU}HPnB@c&^2nnVTg#0=^9LpTA z@POasW9h_kE;GwaWE1Cum~2TZd)Vk-Jn1ZZ*uw6ylHqHw&27msyyJiDwh)2uN+9ecZ{&z}ni+0jQmeK@-mfJytvlpcm8s1)l$+R_DI zHY6nKMyTv`qR**zt2g~rdxq5bdyELyrF|P`M(0oIF?7RqlNr~Az2QdcdOMvc(SHxB z;8*@gQXCe~4EveN%SXRYAQ1#ew61NqleZfB5VV~k=#x+sDU$Ta8N}Wez3BM}eL$`E zG|0Q*&ogB=i*Lc$A}>HVW3>|uaC}5+yV(T)^ML#>zz!U>wmOc6G3V+N(8oVh<~YC1{8YA63K9Q5w20tp7>m$?g<)Oa(&3Ua%T-GehMa9BEI>o#=R9hOSZ zbccn7kYFa$neCh8Jryj$@wvP4mQKg3Hpekh%!OjMw^|n8rWeJiF~_lcsD<0{3g3)q z;_7hYlkrN#R~l)bARYow!MIm-i$Cx0!p-8Ny+`LrTQc?X4=e_s6FIChqkK*TVahbf zZ3cO#VZJZMixe&vtg`a(A*XK=tYK9SB*O{biM-D35)xnea`cFS=qp6EY;tJ+f84!! zT#ViSKR)f#z9^zFlrHTV%ClyosoJoFul%OmplBU4R2$Ld|)OH(Lgfw+3q4*&}=^XdQ#8 zS}eipB+r9B7cs(Qv1qnL6gvQDt*Cg!O%AKj!R`_fj3}@MqmxGt6B>i9HihJ;)5Uuz ztcz&A7FvSVA_8@fU00}%I;iiDbc#7e5)x#sKmPBTEEBU6=dPKtas}7P@LzVbQ~Chh zP&{X*gkxdJnS^+;{Pl$y`U387+x4$*WWt!zCy_iyRsBN6oZDEWqmIA5Y*doPe^;?F zud^Q8rHG)MD6(=z zi5P70zD^aHdc!liv09PWi}+j+pTr!anvf2oQcQ`u^iZQ#UbUeA%CT}hD%J}f6So}^ z%;tPmT-}NTTolQRp<;9-?8pRjIN6Ng7)yP(VBwInXqK3j#8IdMEVY-2#@e@#7L=W5 ztw|MgB#Se{oEA1nF-O&0F~`9%8WTl!#DJ1JMkm06l>7;*0EbVz0!`l=Hpe1taEaNo zljE?W&a8nC0`=NDedP+y?Ov)(xuapHOa4KDtVH(y(}1m`O=M22RUXInOU-n^vAdZd= zVukVezUuf4lZ!YzRf%$x(Z2(at}L!KmalhVXM(i5J zXcejlW{dIgT>>XeAX9RiDSjf?R2C9cW%1X_j-8=e31N;$h4ZtDIkR+1@NH2Jrw$d1 ziWR~=q?O0Mi9L7_H&yd0UyD@}raL|&H48^kQ7o4wA1&lIeHHLLmt?e<$5!R_kCWTX zQ;2u$iNoKD@(jQqod?&uaeQtKs$Q&U3l5F#jV~ID*%R>9B+g8kuog{iDUaQb^??`+ zYT{54tr8=%8nP9)2dme3dgOF@{9T$dmH?6siS z%RWmLMKwW=5|Id2Qi4C~&^MR_r)uiT6%=~}$|qqn_0knj-tM@Y)uH>i@!GiKfUeDv z*g#aWnE{g$RAkBKad^_k6L<4OJe6!V#N7~P7B@Z@uaw;QeB4VmU&I}2S7B+bny zse2}MC$F-nni#;2#`Ypm|#P_V^916Q4(hQ z0V?R~@#uB97q^q}g3Rzfh~43`=|*>>He*=8-Ad(3@Q#4c=uB2{cTvevQsN47{jaB= z2=)DFo*j0s59C>5hdH08Oa_E@;)}VC4Lmz6u8UB@c5TNdOu_T+UVot^dzTwG0~z7Q znNat+)ZK!*TTypg>h3_@op9&HIgs)TGNg|W1Xepm1$O$MP07(Z>wCEDu1(!Di8@Mf zhNu$+elc#nLM(O4@eLUN31Z#8o$Res#`dJ0qPX!yajaI9q&dcG>@F%=BS-#*c{msg zQ$-dellq@=&X^4Eqs|xJ`Uc))h-Jo3u?IKBMQgqw6M=CPPD}= zco#(nKoph0BkwLt1e@YTV?J-lfuwMRQUKJKVvaGs&Z1R2p#3KZDvIztn}t2S7_Pk+ z$2p2d*8B|<6mueZq6uL&!Js5RHEw}_fx-A?3PP66>Ky50``-+BpC zY(aoh`Dn{s;D4wQz{?UUHp%NuYkfrD`Mgj7nKVhB^h2a z$skk@cbA|r#r#x~Z?m3+WYTPG`P(skM$*DB+k!ek$sd1-Ld}>c=FG!KXdHY?qQ<*s z!hETO5S$XkreBVSI1_@!1f4#2ZmJ|+@u?9Vr$llNIWlBD{_q6LJKAwblnWH9#%!bV z_2M}7mt|D7UIwji3+WbGCtx7aA5|fY4h=zBv3j@U6BjkkSD6jcFclJ$6drEkLB9gR zB5UUa83++;?T_<_WiFEy>w&W9WN-Yffl=ktMBnjIF=qt|hjI!I zLdA-UPLvOYMR$an#g?OzfEfcc8Wt1BO_6}SizVlA+3no*d}_>#{i^HRp)7dpPO(ZZ z8~*~_iPwFUly3AzG5QN)!qI+;3CBq8j%wo$iRNcUp&-0C(z#y22PB$KHM$KK#hi1cDr6dz~4ADCO4;Vv|`A5cl;&e+#E&XqE z^N;oC%U>AN+V5AcNC}!2hIdf8Y;uO3!ms+Ub%@ai*bucV)R3)ml&U~gjn)QV#^P}8d9v?%Ec<& zzWMLC$;0uA!pTo0YLv$I!B=s8flac&21`leCjG^aKK$tY#m__zpPZAiJ~P3}L|KFy zOsu$J@vDKu7yYYI>{sK@0TcQYJB*fii9`$AOOUzTC6p@WbjwC9X7S31YQ)NVvmTao zGNq3f)8k`>su8>3;*%+D9!0i@plc>gJ()xWCxKq%bBaE3DJvG23P=n(IoBn) zRLXe07G%NV|8=@bf^<2BJ)Ca2|63*Q{0}9@e+m!=>Gw`sucVlG5OqM9gKqgKmg1#7 zqn4h7vC3Kn1zOqD16wt2;VYjKC}t1m8f5`RmD=XlprGP@i9m`Tnr@bpVF? zL{7k@`ZW$p?zsgVN-!6(Nl2t559ACmQt?VN&Wa2}1nhma_H-Vn~ZaiVNG-v|M? zbH*jalDP+4{+SLm=0q|BVaHFyGg;$a%>PUVqExHnB~v5!>oS}o8FJDx{&@t)&XtGD zv|_qf4l}LzTR9iGggN3y*TV;(p<%qJWN*uRh)BxO)>`I3cMG=u;GYG^M}17NQzI8a zrASyJPPn*;#VbOqK|>TaoW6>HCG(mhf2|0V74IOaV{iZyOIej~I5#@Dlog9h30kNu z|0;AcGm}U(884Y=I1^h_yV;BQPf*qbYT=EoK-U3C11#v`nr-rGlsDtRkuVKTg!AAvj&u~hMgV#ya?dYAEHN$IiKGYZEK zk}Uy0H5PfMnv8H|3E5a9*uc@+AG2^O#Jf2?p5hA*cty6zl6Fd0aj8gupYssDZ(z}e ze#PP?)3%c-A1s(9lcG{&zKG1x$C1?rc%!!CWu}m)OOq$f#w%XT9YHg}tb}3=7lpt} z@C8x90PrjM)bcROO)+Qkg`X`5Q$)XvPpM(GU`+jUKto2UE|e0cMxnnpqF)B5!e-PG zO$J;%Bv9EbY%*eZTYO-tc&UIaw!i>6PZFc*JZkX#1X;pcsZlA()vhbzaKNg0(mnid zj`i_U^)q9we;GBixKyE9H89?%68N)6|2bIZX9` zB|A(vqTcDKW^eq-!2(LyUyL4*zVIUoO>vM?sC^s^2D|ir;UKogVvw(?@EZr;u(;G4 zV1k1Y4qT=Sw05h?FEZ`R5zf+!qZ-cU`&iJWn6pz9l}o@hL3TcJQSlx`;ZHg)kaGZk zX%X%JrbYbnx`z7p^9|%D<4CviC*y=ILNSL&QpVhL9GNtx<~mtCL6VitD}Oc;0V9R^ zT*2M`)APN1S2h&(cIX!hG$rQKKNpFFNwPT8Xl!$Glvep0PS?<=H!My8nX#v_C*vuf zdK!zT+td>ymjRkU9UZ=%3aUVY&LkBrvW*-jiw7EY+N$9D9M#q_nh>vnWJT7KTp%cRJ_M_>`50uo z+%S@-Vg8;i+Hs>L2`ZG=yV!dp%G#?IiLZ-GdF}W!a1%ToNx6jEF5Ix3MMA&OWW^26 zNE&}MCOEto4iHu1lT#Z@#I-&9;HY2NQb@YI^>Wz3a{*7DJb4m`w^UrOdgpHB?-4=B4F~Z)4ozp6A3xMIDIU4lq^t9qx9IEY&nx`=7kN^A)n%n+8t#g`{*L`vt?w4Ul^%LzU_FBQZ< zRSBwc=ocO#teIxk!=~E``GR_aN_MA6j^?Z6?Y#xOsV8ctoA;6Q-i26cf%VeXrxYKtcww6FCQM%+hSFM>(( z%gJ5MiQES}koy!{a-V61J8P@j8j8sKQ)I9OMI`1@WP}MtbZ3AZ*d`GS!ZV{C@uaBu z5pU20Gy0J*VvcD*zfdBPi3W<}1Zand;}K7Cnv8@K?$YA4!V-z)lq-!!{TUxOrUpR{ zi4#f2Ji}wJnkFjUk(2O*gVA~kcYM)88L;$Lf+%~{wDHK9Nj%WlbohBn{CJbNd(}q6 z4T~Jcf!w*_9f_*NFCxx2d{w=-ld7}}!=~RGL=*XoYB{RSEl0qmt)9Mg{vRY55l3H5 zN0ks%cG46Y63iNG6U>@y3G=5AUDsP>%lAMS%p%}JelNSJw~DIaz3c`&kw)@Yxjy4B zL{@GfrBPG{DUl&I{vz<;ON~b1mzt#(*iq5DIM)doFCaG@)NNFZV^pP3pG0xIcZs;s zkB|>Ij)M4dCBDe*-}?GFnSci>IrOc$*3Rgsr-_6K{yM;PhS>E@hPGzt^4f6pvn-Sw zYnp{RHb3!-eqBx?43Fk*F+&VXo=jEk7c1thlEg%J!d$vKnuG>#Jx+*|GwKeJMvo&_ zYxFHdW;UmAv{6+EA18W{UgTf$Dilxzhqwv-EbrJK$((Z0?f`lXE1AR-h8 z24lAv&hOmDL&^scGRDcn|)ZL%Dd*e>=m};mh zoS8%o;kXZ~mZ`%Lij1_>J{}0l+&hJ2gf~}PiR-VelmO^7{8{`S6d$GTWn;Nik1#*b zygxZ|e^7L)#)e+`M@*g;au1n)-_pE=AfN)OpDxwf#` zBrgvQhMe^xA9Ev2`b*gn(o|cSixbSc(9pz5G1)!(Z1fFuQmXb|H8~+wq9}3)f2zcv zS*N~PyMDXT7q(P^4PtIpis@j>@rvb@=VAR`gOY4JcM8eZmn!ZQlFEve%kJE`*E_-! zfqO^TQg;XHeula`QFmABo=M#=;x6E5?}%K=CSPd7nHh&BNDI@Y3QFfRbv@VA{-`)k zT>H+AJ~w5~Tk+Z%+D+u&)u=KcTg%5)WUBh;Mdo?Q(5( z0;X2+24`lcZ++|L1DriPGW$e9*?96Nu6l0+RuCKpbd}7p2_=E&+#u zXdn_`0gC~1U^*}kAlFT$VK_Lv=h4UDpK3;)tVeAkl32z$|#taPear0*ct!9R> z{DZ<7K7owjK(Cc+-TeK7JVuYfU;73J`}=sfh4};pGThld{$Y%8pD=HRzmGfoK{>)Q zj1j^P4D<=~5;)Olj)8uGLE(W6RtS?B!U%Q?aSLFE;Yk>|r(2lYO3IC7;vX(DD*hFu zl)nOf9_?3P97En1e*(If_A6kdDJiSa=u*;>G7_@la$@qL3L<26;a{)5H2c!(OQSFD zzBtJj1p>@XQXmVD2*{v|fXw+5V1A8)94GRskOXX@Cn@0(XEhKsw+9v;YHvy}(kS7MKQH1|ooNKmv#X%z#_K2;dmN z1YQAZz;3`1cnnMdvH>>m36KX80BhhrpbMM@0)ThGVBinH1$Yk31g-+>f$u;+l%Su8 zG;Js7PEdPLd(cYIN>F`Jeb5V_7eGTnLqR)0J3wVYWkGqMJkSN83qVUjOF?x&bwE#p zo(A;;^#g4MZ3Wc;)d1ZOx*v2I=rYi!pie=KK#f52K=VM?fvyAn2Ko(D3RDVo3+NWm zd7$$^OF&CNM}dw4Jpp6+yRwZUeOewE=wy`Ve#i=mgMnpyxn?K!ZTrK-)lvf(`{u1x*EA3Az%r z9<(0R7}OZ_8t6694WJu9dqI0ai6$@s7=SCF1lR%-fnb0RSOB8|Z$KSz0t|sQfH*K0 z&;~pKRlot541@tN1WF@;wjx3O)Nq#v1_NS1KR_1H0HlBc08K9 z!oy#$K7RJmKEC$R-`M*v#^2ceFUEgh|Db-Tg?nj}4v7D#ynerP-GjNuxi01MpMFZy!cl zNeZoj?g}tqP6H+WHv%RwH^3dWnC=9i_DXN3^^-Ef^BTYq<}#Wx`Rfz9H!vFJOi)BX zj{_`VZbx{Om+k1*LR1egT(n@AsT zBy@LRILt>uMS;!0Y?zx69t@;oPLDna=3PjC4xZNn(_wyu^sz&N?hA~C`64LcXFM<; z=1zo%_MtBZ`qNBMlzvkBcwP+{!2KT5$2%9D1&oCG3@G7uEMN}vTZG40hQ0#8{tW2@ zNZ$j`QNS#ipCNs0v!(|E<6+JRg;t{{0t;d85z5~VW@VJ0Bb5ItnDyXZg!oB*-GE^* z9|jcxHUXwEzkoZ*&r)C@%sYhg$I=7(G?*)d^7nyx49r=eB)?q166TKxPvq$cKnKu8 zMFjF^!;Gmp>AOPtGhrS9^C?imuNc4#<~ImW4tPArM zP*R@~0Be|W(hDVjQfK<1{5OR14}}?WkS-R=pYRm*Li#wU7{CGMz}$@RME=VF@L4)p zDF1aZ8^K&9l)oR$sMpe$KuLY#0SjRMjPRs9OMn5t$UhwBsc?TFl)o3uqhQVeCFyMe z=E3|P;R!!i0%*6=2Zi$A0JAa7bwc?E!8`%x0#H()wgEOU|M-XYe;x4?`MUxP_&)?n z12zICFgL=T$lnQ2hdD_o|1~fh!dxztzciTwXv`@bWUzbE`? z!+$y`@gEJ$g}DXcNqoxzO_=uz9n3~BR}1Cu2eS^$ zIiRut4_E;67lbF}`FHLAp-}!_@G}bj&w-NkwgB^BZbNv&&%XAbDwKa;`>z+uKL~y% z!2dN+MPM6X19LA;2`knHVApd$31ymwgou)|1l}hlM8wr3OlgB9L`;+<#AxagBBH7i z!)TfkA`BG?Y1$wO5qf`#O*9i^T}eU|;Wr`tKoVYESwf10msFE*BjH_@B*aO0F;xjY z5`LnJgggl^*I(kgAUriTM0POZl*YJ|yzk0l3?zq9pgaw8#267G$JCWPQ7U|#o5K4m zcG7zX-VBi1*6ABO<(Nmyk=>pLC&fKgIGXz`Vo1y5hPc{_JvvsGq_0MvkCM{OeVsJ; z+ICN+oWUO%nZ6dQE_c+K7DTUq^kh(L)AInk>_?p?F_oOfDgONmPx^VT?RNkE_6{@N zX1R!Jt-qv)$4teqpXBKYw;6#(E0lb!noM0Ehph5CT;3!$W8Ne21>a-jEBvx$j(t6u zJ;gsIYj)M0yr(AJ`Db4G*GytBuQz)rU-fM1%<|J`Cf1IePOG!qXjgr^zgyY0?9PkB zv~FHlym$ANhlQ6P-LB8nWnJ2C`fRo2 zs;46PjEa=8N{`#PG3Qqe&Audgtm#^+{-a#};X6`mCU?^m6HiJftEVV5=E?hR(484T z-{bF@B(mJ2xzou>=kAuePt-ahE4MPO9({9i%d&o8mpwg| zWN>odUAk~>pWKT}V*4u2hfSOJ_|3WSia*pwJ{9Nme-^4D>+v$$$aB{$-vIfO&c179 zA1XBc(JQ@kR0d7v{6VSpb9XAXR~(^l@%|_>}Ym4?i@&-29$T-S=5-e_~JcdYk1*_Ifn7g6A2zV(7z=^zd( zKdmBYgux5%MZ3f0?upHl&AZ%Rbohjk5{?B%S8k1#y_&Vd`J#@v?}g;ySb5$)%w%(-OsAj5tMt=IOgL!ou9%jvJ>CK*~ z`SI%2_@XO!C+@spfBeWrZ3%<2D?25t?~hqh=WxxdR%`rP)`i^pZZ}0Wyj^zb1dW|q zAbaspqTCIQdI{%*Hc=>Vd}Gnm7`WNpVA2hHT^;dT{+?!?;p<~hI4>?qHnpM0*WR|w zD=LrYw|yjm7@7dTDA6-!JTV%n6|k&R%eV?ZO)!r zot>hY9LM>3K`UZlpW54(3l-}QU`*mI5AXWy3@U)1HOr21z`$DY=Eqz6wKt0Mj}-+sY`1dBz%b<7C8wkX#h9nG(=6@C8^nN;?8 zW?JdJuLkj)JgKC8YaH^=Ph*}qxgdpOB$J*p{La^G>A2DiB^#Hvl?wiy=J$v7VyyJzsq?X!3Ezt#DCNoU*5T_=j#9w*m+ZpoL* zIGLcC<5#D5U~Jpin0FC=ch6V^R|aXgbd4Wt-q>hR$4ZmBwZX%I?=YO%Vg0HjOY~?_ zx`tO$^u&>Asbg|8ZZ&nM)_tFTucK<+cmBhCzx0jYowN4Nl1|OqU>JQmQ(JS~2Q{fF zlg!5s2@Thiy4V z?GLVLUbMN3mY9^k;h>wwYI-pW3ZrMI*m#MhJ46+Jjd0vl>TWgkmf@xqomwe>oKU#% zELrW82F>A>vz|@QUU&EE8vBR`18f>C7e{@y-K|@_?vds__kQsSx{LCXCnxdqhL+W) zNxtofT5-0BIWI8D!hb@VJ)3W!GCf^NTFci#o36t&R&I(ok$lV|e;Z39>FB7j@mCx2 zOFte;C~I}E`(CKk)?9nFF<-T(?1a2ACw^p9R+8~$?Xuu5wNf7=^XA!W!@n=f_G3Ql zbdI_;RoedjYD0@J=QE^p+f!8z>EAPs5BaXWleGV-zC|K|kD|qv7MP1ZJ1H&IT2v~T z6`3F&)89rS*RG$!HtZ3oirFLI*ybqb**!?werF9`M)#o1%z4XYgO7~VoOh>b@R0Ds zL&pqu9dbr?g2sNgcY})RPpf~*_8EBl;}n(NlrQ~`k36rOWEHBU>O4bDYvK>pwTZd? zt((>kXfU@ntRA;*TH=m7Mwh!}r_Xpl*H|_>cGjZlg)^A8qBETatS|^#e_*P?jVDt? z($yzNUt6Mg;qmT?Z~Q7JJr_~d-~P%^`^2{N5kK_WM%`JaJJQP9U2EN_wBf_|HZ#;Z zw1_TBz8{_NqY6ABad1%G+%v?^oikkGyQ z&q6du>SV!&$v-Gmlka3PnTam%>7~H(XfpXJBQ3(b2m+V?f1LI z>oUjZ`)`>W6;SupFsNnw*FgW+Y`3L5v?C_y)IOlGx7U01;t>b2Qy~XuW z^>OCQtDc@$#D=pHd>XtMrPUS#4yjo#9BRKHf}J$K$D_`sR9bW4jvQyJW6x8pQ}*37 zKi4if@AEO0QLXD^Yi%2~X%u**L0 z)bvF!R3mL4M-|xdr@e5lw`VMieaBjQe#=p($w{p)V&BFrcQy-J5isHG%8eRR8go{C zX?Xwe{EOOSp)Z$Tn9=N4`{VT_uiRG>@@tz6=Z|btWHh~BeDLsFw@%l0O)n>Z~x=&Q!sns2jj9_(gkEbp>tp>=G)*2|GI zquZ62n19%1D&2WRr}Wd;-3edr_u71Rby-upWa^a~1#ZuiX)k9z&HuEjj+c6&zGB#? z=dTt_eO4pqSKY=+uewyz_GnXw;8){9Nt`ceK%jZ@Z>q`($rhqAgMdIKPb!I36q+8Z%#n${Xvz54|Ok# zJ}^l>mlWO;uzmb&ogD*5x9mJH>v-~M2hTkp-wfYCigQua46#I zAKF3LDg7kE_s-AL+rPfNW8cIn+ytqW3%0Ikluz{GJ>2&8kB#w9zs%-swiM@PYZb@E zdG6y}Q*hecoH=A;`IBdx9PaIm_Bd`AGhKba7Wt6Jv1w&5()V0poO~e8I@KL`^mOE! z){F%zW6r6Z2|7EX`0N?=O&?B7Xw^Ty+L3+K)HvtZ%`shR9do81I`uvB$RB$O4wr@A z%ziyk@?yaWlS|zDn{(uz-p?{RuXw>-(ek__lb7i|ygF~Ch1wO#&-S@`2a+ydjIYb* zG-zIZvcmb=yU8g9r2R9!@^g8&rBA&-m#wm7kNdVs?R8V1t@Iml*|7SLw$T@F#oN%= zdp2AR64@eBoqMfn{_`5&kNV;D4U3gLoKlwzwEa5q7+*D2>FcVlGqZ0OuB$(LqQq+s zJ%l|n=)wKq4QF?&sVnP#%QIfyqa0QC6;-yVfu4tn{5w`N9%{jDmA@%8Sb=5zUG~Y z_cgn&LtQ%UH&gdmjGZ{#*=EVX7oUSHH|(T;Dp`NRf@s$p zk`=*eD{=;CHZRRh@0?MuW)<_gsJvlgl#jxM(sh0o;WrK|%9oaSpAQ{VBJO6DmRtKN zC1~#U-pU^A2YIhC^~qxEQI{1)n@C(LZp%D+Bu-9qQ0CK38>+pgC9SE@=^PrkQ|!w~ zBi8nPoH*kNN$;F?j&X3Edr?oSORoN;^^hwMKOBEszvBltcf7gRfc*}l!K2>hS+uXJ zn_zWk;>PZ$j<3x;4x}0Tb(e4|2Y4G?4^fPdD4puklwsSr+@#lG;fNIe=g>G_M*p^{ z{ku#yi~lidR=)PomSLuA9QU59Zs6U`T&{0)Y3aKa<*ytwqip9r9{9G`f0&WGwE31N zuUjVF-kg{i{OI7j(dWDEwy#{=w0XLo({zsXwiC^P`a|j0W90*mPtQKuXma&>Y>&i* zF_r`7FZ^__WA*S!$;t=g*A(ca46fb7Sa7Fv&G-z9!a|Yn6~|bnzM3nNzeG$MYqKXg z)#c*{tydBQ{j6Q1sy`)`yT5L|RJU?bqIA*Jmh82)<}~m8Vfkfm^y=fbE%un`)?GDR z{Gji?tH-ZO)m#_3W)OJsti3c{ZQsI>!M$T198->6mlM`lqIkbnX~)TeGh@w_2O4Uv zKDLp~Dy~ryS?l^E<6+4DJE3=ne>l2iUb1>y`n0p(@2yZalYDQz+JpPyLBhzn&-kWY zo^}xvx+f3WY5L^+Nc(G5`&wIyyDw}#WG3sb&^}Pg$Ldgl-ToO*4Ms&z*}Egz_Q&|~ zdoMeT?5X1)R9WS+HN1c0VA`yzKXR`LgdzTP#y%Ier)> zx!HfN+pI^Y9`K4ErcaGBG~H0;GV(^?1@7v|s`qzq22~ASDs%o&W781Tj!h9K7gYO{ z_RCTTKfU}=(dB8yQ6d|Eq#t;-S4~^iAk84qPBZaDe^zYKswcC?)dh{Syj;1feUrHK z?&jR{>n!Du3>kl3!(vv&9NndX-)?+<+HyR}%Wi0T=DoEKRPSgtnfyljj1grLYRPTp3^*WCu6zQod< zx%!#uc9Ey6BvUFF`E8Gt#;!Ua!A$DhW4VZ*pIxV>zngmub7IX$ciKXK$=&ZXM2@Z7Oz*t@N%7_qW@c@% zN=}O{uORnL&*ivC_veG_)t=~DZmo>$`1Z((X`SWfG(Fqy!I6Ag*rU9OFXq=DGo4wp zyZUJP&49|P&Tn&kT6`x5*7ltBiZg%Wnp-wkTsKr-Z1Ag7GFB^}%SYa^l~^@nl&I;c z0$C-cJ93QJCEnR17(p=?F0&p>%LqclvvQ#Js_uGj%#M($bX1`BHBb)KA)(XcWQoB!EVe64G}Yuk;JUiFT8fr)MAJ_Qk_ zZWp%Zvp9oB1XZLh@_u1(PcD3Sp6ooa;iCO7J4%e4aO;XuLDp5-(K;8McPzi)D_&IH zdm_8+q29RKgS=&R8H4wG7G=Km_&Ad7d*pyZ~`|K^uPc4 z^2lXDnc2sr6}J1!p@1>7mpmjQf44=zglvqL*0@wTD4x+F0j^)zv(tV*Tq{y zbZn5$u8Xn-Q*X#69&(nb*U%Mh!-Or3Hc&&)bdrJlW*uGo8=n5R#Mg&+nk{xd5o=?b zTyncMo?c#*XZf{_AOEtmw)9N4ja+s{l=VT5ZsL{{&4=@gRP5|)wUpL$23NYZneG^$ zQSCT2yIEB;CA(UJ6P>(SBW3A+TDp3s?$@X32BrI&!(Ci@{rxo`nHtyMcUCyKJ6ikj z)>O5ZC$h{L1?k~#ANY;O`5k4iZ`5(LpWMn~y0~PVnroig8sv9x^y=X6KGXF4G8ki> z+hnDr$Ej!<2GpAybQHTtWxWe_Sk>vroR~MZaqDx%OB=&Zxw8;Zf^S>!XCtMkk zUKcSVtIaU9Bcj)rZ&6@+OJluL-PjrJ5jGMn?oo4#Y;?Cgb{Nfn08BkSYD@j~K3vaZ)dnM1s;YgalT3mv0RZ_CT zp1SH3+md_f%5NLLR($$ex--PRdbwXj^I#K)?7F2k(W(6vRGbvmv<7M$20xjpWxAjF z-S0#sCIFU{N{?7rX6PxBlyO8oKJ|tEiF?Dw=6`oRtKE3+qH)>#R27bHtaO(D9SiN# zW%g=szD1djdBF_#o?smD*+APOXRx$Jn7GQ=DGTiLKQ6LJxDdgt3wDia(|g_A@#Dw$ zqHB-Kk|OVwrp@HU8+_fDB$anQ-(k(k6U=EwoRkH_Q_^Lmv%lU^$|#Ln+2&$n-s!Ip zP-}cYtVm&NhqKC@H>O&m*ZqU9*MysH++$EZFHyHy@)#}qR=!4b^eWT%LEg@J%jSgh zQ=I*4Yt?jZhR7L2tsJGHdteq#^ZDfzno1f+&z_gzzI{iwefjgwTm5ggbuMWuI zZSvy`sr;54&4iN&^y>U#FadDaFXCNgu*I1!7mc7s^ReSubq0+aZb_x#_20v~gE?F@ ztK*eMdePB|(MeuoQqx8@-O9-QUYFWk)p2k7L;m-58`J&r_hvbN&q|e^bvoK`!#GXt z%qdc8ABK!IpCqLh9%>QXc+t+U?9*Cvj)8|uR(R>x>V*}J&5GTa0BER=PB@pWGXGM7 zmh2yC!MCIHOu1rOF6M&_{iXEOjBk!sP>AueNtqqxkS^vJ@wL#(y>!zi!&^gBv^rN@ zP&o0&DYfKhuN-I^JvMsI)$ZBgfcwM#bZufhdk8~5_`%O;HTQoF} zpCp-9Tec#qi(^NVG+0;T z$Bz0~n%~e`mT;)>d!2i2bDNfGe&bd76JJAN=cu5 zCRtk4DxMITC1KM)Mxmcwu41{-Hu*gJ5i zcjgT}96n@->)8`V8sBZsRz~v zO?h&|V6u9;h~AQG(Gzz+zA&lM?~T5)$a8JKSKCLVZ#yxnP4CA@-DP*Q+^wyKr;S?2 zXx=+~n0ANS*fkeN>s+ZDI;O|feDo}tRl2J*JI7sEePjHm+xsR=J$yEJUqaz3r`KOX zhb+wqd8WTNeCG(w)pj;IVFNydupjR?i{d_8vthv{oAvVa{*e#ehed1*JGy4}kezGA z)9$V-zWd!je|%;@)Z8sWhF|Lfziw~w%Z~N;4S&1LTW^u5Plw?Y_j4QQ9sz2`ZaSw~ zt}WN?n8&Lhd3s)b$r>(p#jC+5!J@j9VX1a#zykZB3+E@XBW&tCdKPL*ms&aJ?66LG ze$4#lzLa^A?dQx)7Ji<)S^K)_{Yi686rDn6TQ-lK!`nL8;e)rWqrRxu5_bNq#W_{d z_FaWr7fnBvXB(;d!mc3dvGa>*{ACRL`lYOQu}(*~oOfwWn!J3>H?b8#X3i_mP6%k6 zqOq~z%c`6g=O4a*8G5X?dB%n1uYc6~y~_2P)U;M!qHW}S!}m=L#kYqKE`I0Q>BgV% zqN(LwTxIKNgZMW-%ddX#m)qV`UQzO6kN?45N6GZBgOtX7t68hjeemY&uH_l*4qA)F z$0E*#_UM@-KbS93?vys&^{G_n$d`oOUq9RQ-mhKb;#zZM>XIitT!p8zUQVl9^(nvp zLMre1r(qS(rY?9@?I%}LmCkB=)K+upv2NC;GWVn6+*E?l5 zql%x5jVe($u`F7$_}-1(GrnD~+23?^uXlfvkvU>bU3|x_?wTr8aCca%`fRX7pZ=mO?Ih#Mo>MIG z2d9q)c4xG%i99z(Wx?5?Gb(4!7LPdbVUzlC{niOb*^aA^408-UHrwXnhl(5&MTf2q)dKC+JA1o7xR?#ZJtW@x%b=L_bi!O*FI^4-^yoyR2yEt zb#Zjtdb&+~(A5UdYD@skuez4|(YNM#Lw&fulZVn`+ks0``Nt-H{i>9zI{Qr5s`_<> zx4lYEoMng5=iGk~G;;UZ4Z*s~>T1SEbG~g+FFQEsA%E22&~39biy3F=Yvsglo!2@@rl~luQ!i{hXzfyU{!=dNBOWedu z#?Y%w9YC8K)hnpVMESdH3DYOGb{b%2&*@jmqqOJMgi) z(J=ofTg;_zPilD`oS3+I^t*$Pw%c`|-`uo#<#Z>#=_j^HbB5{%Hp|Cer)N(;9&pv9 z@u);k?DYYbV7`s!X-6%&nvADAFcfcN_?u0a((Syp188^QfrZP;-a#k!lE$zdO11aLo+&tK zI8fPqsk?|kcSyR?uOpkzvSqL;ce>4^S+;*mTsoJ;@)cO_mU4ja6O*Q z9hu{VZ?yI_Xp}V+6*6h&Mf$a+Jhpc?0X6&~sh#qC|GeVbumx!@wIOT_RU=FWkKQzG~^-`LxlZH!_#tyDW?6g-T&mmh^z#inucYJmGSi2K$vs%hy6m>APD1hn zZKFvcBh9rzX}fLN#LVD!dYr}W(I>t6>M2e&hPi9H#G~il)IRFjq`J%D(d3I^opM{P z?u|R+|5o$B@@F&hBYQ+Q&n_B%*!_jdjztxdvO+$}#LvGw_LT3NLHnGaOuw@Bt7NQs z@yO$>=Kjfxs|+r!{;ZI=@WJ?u!1qHAuBe+;5cNZ3lj-$ghuj*KlkCd%&ae6)&9%HU zCf%oH;NGRR(=JDJOT?Jn8gY#IN^Q5}<0;wfPx1-Y_jS((yc_(7%k!C6*MAq|%(|gfOC~w_2sV(zLMxF3_Jz&q0>Zv*5Ulh05Je+VY zsBLKK%6j8#8+vIb8w-_ex0f+o(;6lQXSR#ajlQYsu zd!OVRuF36^v)X!3bNPX1VXxuxc~`|$|o zu~$>r*`K5>xpxLG-CH}xC%t7_#N}>z>xBD*UH*8k8*ujB%=K5li_YF$q_Sv7#c=n- zFD8X#eUvnhE$+WKxoRZqc(cLkOP^)t$KM^~yzj|a-&1dhu9p>jehn!E44h1ywnf9&>=N%OUZyGd#Xoyop?PpJm-t-0$!=cvi(nW{7$zT zt;_qShqG<%VI$mSh~vx+KSd=%@ar9a2sBb2lA$b}n~FFV9lwI|PY@C=LIb@bxRM@^j) zY9pqYIWpNXyN_kxdi?5>WdD%{=8IXYW0Q|xDz0k&EHz-%)Okz1!nf=>kyBFr`U_os zw4sHQ_nNqrlexER_+8Qi$4s+a>J!1;n|}FDZA-Vzps~~EW8FdgzEfB3K6&$1Rzt^V z!7{&fy#1&1N}slVlhYhG!)m#I(H) zToD+Rcrc^jLEZZwibE$D+pG-Qur2l6wTJa>y%Y5&=}(?wFx7CH>Fhak&9L|j>%@Pv zo9`A#GiSQfu%H|J5ko*DX!F^DfIrQY?M1U^2GeXj!e|SFR@3G(J!lM_iMU8iG@4+e zA_MyyL&+9Kz4249T3nZbAYse^cPtH`G-(_I%fgyLxKYE=;0F{kRXN|_(}4? zToV?;3_$it9zDF-fqo1Rx4^)lForuUg90J!Fys!UMI@nNJ^^fhcBr6yp(H$t!wd<; zwpV6I2=>Jax1~BQb;hpLpn#QYBH+g|z|D)K?TO8@=BY0)LU{??`tsD50uCGLD?wOL z5X0Xs1cf4dfrYgQED8<@@?eIBGJ<{9F#SV+%Gezl^+Y2<>3>Gnmk*C1e?$=$5zPG4 z@n790{27HuP=LD+YBgzre@6FnpD-m4e>V>%1N(%%gFOGv526STK|V0oiT!{*I3cor|-huLdcG6flKHdQ!7DL#>r*mSx`-AHrToy#9~-81A;q0`vj}PSETH>b}peZ$u#U z*ryLD|9yc;x%>K1(&@NS)gLOvb0s?%JY%lJF0`Q0W2iP_#0bFw3c@B&G!Xnj2T_9j z+jv65+(N=uQn69m`@f4vsPBL2(n$k{M*wMbO} zZwz|;NfQh84r2SGX+qxY5NII=Do(gJI(s(N0*My*voK(tuzy1bNfe+rdP~wJ_w_fF zUicXX59G878f^}EM!YR_w6Y=`^klHm7)Z~7vo46yj0m3i3mg?jjb_|~&`D7VlVYx9 zLEmFPS~%(pQ=r9QgH9mKn~7$OQ3EOi+k-j+LlB3jPpF4m2-;d-4I|NzvdvjE=Vz7q z%Q+YU>`)}l#>p7i`^FH|Pj@#DKQ9c~khGUuKmavPA*I83YvrGAG#ce79BT!!!-AoL z1y(Q+Wz1X?%=92lKLn#6=tiGDdHV-@yDasLNKPr*&u@PqA)L17Jl^soxeCTlymPA3q;zovj z|Es+#509$I_BRp41;>oyi0ib73PRxS_xA0+-2uW9Wr^&LI8Bxg2_)TZIst-PR8&+{ zR0L$yiGu5(6BWf#)TlVPjWXi6kH#nBuDFh)j=tZix?6XejNkj-KW_=&;dbp+r>f35 zbgc0!cY7x_^@k2LbHUMtnxjf?2dD0&Be*E+$y`XD$p{)_6I5;gaqr&AP%P{Z(I&fCR8kOMef_?S0p5?)yH@j>BG03TC0S>gPcC32MbcnUykXPkb#JI+FQrn6=c&+P0Oz_VM1EiXsbbj$d-_D`(5E*IB+ zyxRv4e}N>1>q3Y3h9r~!S)DEo_wmkZU`P2OWzz66d1$D4NSQLcOdUFJNSQXgOdnc3 zq|6vzW)AITQgWr#kS7%I?&Yur(4d_2bxz*W7|z+~sEeYi#Qd=Y zA_-qrjX1wF5!0cX{4u)o4W7r86fT4DXfB9Lph#tNnjN(mE2wKoLZEAMj!>lh2xg`3 z2XNvw%QZ5f{ZJ>kOvR=xO>!3`i&jYKoE(M_ErXXsI?2%Sp7@`muBm}IMv90mHVm~> z2#0Q(x95>Jh(jEy9h^{3A18hY>ogmxhScbiXCaWrG$N1`f^p5s(^?xqhalJB`)RE; z_0D;sVE>5xGaNZG8e<26_3H0?pHcAq?!Ncq-5$Dl2+|R^o!^iW%)zW*QV{&#Ihqef zF1Sbttzs&bBmu^)Ke+FzPaKbzj(r|N;UJ#fGQmE%W&AO+QvSO1_MRW_j?w3FfwTrF zHx@gB@oxHAUokC*2T=Im_0uim_mh<>&`&?!?Wa5LAg(eKPG+>$U6T|J_Q7w5r4(q# zkMFIW^tf?3?NGRIJ1nI@JAQm`?PQ=23eG)+3%A2kymqjs1DX$(mT7Iyq_Ys-J={=T zB;^Ly7SHK^5|DqG5POd61|8XdMhenZdR~f&`Z$~6T#^C(V#w>_g+(?H;ZD|CAc|b$-iq^0ULMwZ z$jeEDjBBKc>{YS$bLz~?50+4h8Nsm$x_(yh-`DSGki7Lv z;zu%^c(l-qch_rge8W*o6`W%?&0iZhtGIfHfUYW_qw~)+1@i4iS5+Wq@4U`YhZXFz zo94(kPJaR`i65xgDb3dp1|oq=SEeZ>0t9pRI_^Nm-He;-`~vxUnguRIPDrPsDH3X!eByuK6${)|HjSOtM7#~M*!c!pz zB9*1lZ=|r_vzYzRFUP~VYo(r-&A5VV0{!Hfd!(lcK zgY)|1&Z#T37aC)Lq6bblg>jaj7gUw0TXs{gZ_~hha&{3=kCO_PR2D&<2j%lsL9{)Q zTAHpa;6AmBfiRj>gCzogR$eT~fgi*Qf z0FKFm5wPlHTN$8(kpKN6=4mD1%g()c*C4vILA{?yJi?X4p9a7{4 z%xnSC6`L0(R!8T#+cGgbBx`!XGGhW;f;T~%qB=?QPkKD&Y@$gx{e!;e_sPMqNkzzx zlGmZ>%$)f18%V-*OZ$}CVoG2<8yuK=WZbu<))0xm7^h$T+;szx$PwGl&xm9nR$*D*l~t`WfH+D>i4DXDbG zv1w+rSX%fR6koso7&xlk`A#=m(8COYiVsgkaQi{V$ldi}hAZa;(Cw<~U0Tih;I={J z-g3-wA}amalGSdz|LWnWx-*Of5`QU^nTxqyp9KCZE^d zFs=vTt?stXQJnMy>*EUgfX7P~_PGWq&fqQJ))Pbx!(D+q&VJ2L_Ud4=BsaK|UrnF} zznxSo^H_tGkoAY*-NA&frz4V@gnbeVoY6<}v>^Wn=WLj7@^HuSbLQCHTW%Sq3~k2l zOENDr8Uh?5{H~8hcWY}wY8-~^oa<=0_&l3vfUDC6;&)euDeIW~Qcmfhy~S+>BhS@B z=9cjB$u$4m$;t0@U@iIhhUq^A6(+_?MlEnN8SJ0J?J*u)DgEcEwp`x8*z z73$CK%LfYfh7X4>_;XMXSH3hhG{|rYetnRqf>XeB-;T_&AlbGk-CWy?3`JbZ&E@k7 zCk9&u8YCFun?vGavRGpF8@LAqX|c25Z%w!`140Wa%>8PFMo@dInJK$>lMQSNZX|5C zH(&wumQ@Jqd);Q-J~~5Xt_bkRkl@p5g#Df~-QigHe73>qFEy`~3nrxPr_B&JE$8Uk z=v=@JwX`^W1tQi1mtXk$VsiZuM{J~x$(-AULN*EL?Q-k#m7cV=oVkT(W`NQ$88BBl zguI{Ezq9P#Z+GCMkMy^To&E3y>iEt3j60^acr88#+KvzY@xSh$J}YCty3_nAbU%u( zOygdhw@^+!_Ui@x#~?kF=qP4(CP5g?^UeRZ?8&Dl>^ydTAJm7xW%uy-t^|JygUV0| z{yxJ82lLod%8TJax=D_HZF8P(SUiZ|QS-xq;*t{lcH^JT%eNPUO*OC%SQE?Yux$7C|IYceh4n8FJ;bWnvj z09UupgX2u1KAncs$u#7v!OBb}NIYT(xpJ~aK-6!u+ku7&n zT1h7Y*s|Xg${Vtz;hSDh^FOhny1A;kZ4A~)R=8!4lUkF_ZI!t5iR=ien&cQbuF<%! zDn`GiH`FX(5d!AZ?+#urar+e9`UVyy##Cg;xoe+3v=>63GgAej0}uj;Xm`ciPWvc77tjSLLEk&*iMlfI zpxT8ucvhgjT>xC-Bvhi!F2sv~F2se^02K&4hBv`30C2Soxdj1oFm zqOD;?SPPhgD^YGjkx&K*l_I~0{KJccE~IylM}EY2kHfsrM;c%opc0S);PNYB8~VDd z1AV*!Z4;o4T~%ni4(atM^IMcxfEPd~@`V8H$k(o-t|-z_e+Sy>Lb+~024fXRAsyol z>1d09`i^`n0Mu4H#xK%1u0S4)J%j#Lu0#Bdzz6DHfpCcG4%7NXS(DZj@*pll@fdd} z>SCe`a1jDjQa{jsM;ZDB5K&K;jXVob7oZDJ2AB&dK_5HEAP)WBH4*tS??NN;0Yq^2 zO3ZI$Mi`2=?s^Kpo&*z@>oo zfQ^7Z1KtMw6Hv0MSU3(41Iz-X0T%(*06GCr0^SCE1o#S2yt-I85D)^C0xZBpz{!C5 zfO7yV0XG320=xwH0I>I(Vqp+K1ylkS0L}zl0k|G;7vN#QUjgp}z6R`bO|ft!pcGIJ z_zfTfI2*76unuq!pbPL9z-xey0DG>*m;iCWY(NHZ3E*15ZGig#j{{x;ybJgO@Dt#d zze9U~VE_{_0Wcd-4>%jJ3UDXjDL^;iQ^20r77K#`Hed!I4Y(L^BcKcLD&TX#zSk8C z#{!~&iGbOFT0k0bF5pVQ?SKaXF96;L^tm2=0)zk~01?0hz)Zjbz?pzc0oMcm2-pmG z3h+AMQ$WAp7YhRb#{tR!GXd3rG@u=@8gM({F~IA9?*RvO6blMqGGGDV62SFG zYy*4-_z|$*4X7J19xww?4QK_N2UrdG1K@tZ6M$~OE;B3Hhz%_skfCm9j0{#Zr1t?lyEbI?B3Lpc< z0j2@!09imgU=?5;;4#3vfW9|jOn`}i1%Pt_s{nTc9tXS*_#V*j=3?P+zz~25m;|T- zECQSlxEgR1U?bppz~2EM0lotSZ>|a6p3@&+G5-a=U|zz$b58f(&^ z!d+%3<8HxIaKGWHxZ^J&%*FjW)wt287B}eC;kLJW+{8B@x6U;RO}G;yLp&3A0-i0j<942NaU0N5;e6anc%iTixBFd;+wGR)mc7ex z%i9Xv26!cI%Ug+C`Bvf9xHY)lZ!K=GyB4?XU5{JbI)od98-;bkdfei7Gj5%`6}JK2 zj@$1x;8wmnaSL20ZV$X0x9M%fEq?dmR=N9e8{h-D-EK2(<$D;nymbkW3XkCip)JA_ zxDRow@FZ>(d>XguJ&W7@o)exIw&51S7liG?i?|K&CEQZ?3T_pA4Y%dJf!qDw#I14N z!rKrT-Vt^P?+QDex5IGoBPpM3BULr@@?XNyL_@qM4I@jbPNra&OK^=gWu@CcYuSqe z%wam=Y91+#yyJ2HU_Z%Vp6F4UsUHKi@v!rn8ZXFS+~n_ILNdoo8i|&so=J3INwnm| z;{}H1x*7?u4fAM7yw1Bh30_e!n#AGWqZ4v4KRY%RC=iTyN{|KFx!IIZQ42k6bGnTm zXaXH^43ceso?y8 zXOX0ODKFXXy<`d`$Y(d0N)ZY6s$y<*UKIB_%=&rQ+Ni05^C!-ii}T{06K75W=~~&T z(9i1|Dx5d+5@fk7m`=yZK!S5cm>hi|_TH#P^G$Q#4}g0P9g$mX`l6;U}O!eK9`4CxoW{Nx|u z2gu3Nt%+2JiP}tqA3<*_C#p#Mi`VDK*`}AIJgoD#oD&%!8&2N!xdpQ<9>%S}G-R5g zbEfx>@d9XYz=4;J*vMP`4r9r%w~D;V5#gtj(ZNe0O=?acue+3<2$aPx_Op|>yo)6N zUS~IkG^t)P84vsbnM&Pktyl{QNzV-{QeN0!I*x6UFBHFL^cJSGc!F4B(R_X8YDi(#phwuOKobXX-=mK6mwpJ_p968 zdRd$Zq~xxcw%znCFFvntUTS{dyo9{IwFP^SvzBvG{JwGB67~%gY0O&9utu*Y0gK=P ziWA09XGgg@L_&w7Vf253yZP+KA>G8zSuNOK_|ie5i5QjhVm^=Ox;LM3VS6zFgmKPH z6(+w&KK3@b8|&>wsPynjfn)-Ei={DMN{#^3Ll)q+UO$L|`iY44137hgo0U}(c+J1)hrY6Ka98;eZVuGo@n)*d91{&1)-|$X#C&Fvj{wt7)!*T+Lot zcIS(W40U{SP|x^_mtK`T=+a?70~5CsQbJCs^p>va6@bKndrgBumuXR9M;`HW!C30}Wy0O4mcGkGpG)B19>J~(c!LT8tsOV5p{GB- z;CRY7rODrjr~ozhK2(eVZZufmFu5*CPP?9QjHnryo3lz96#a?@kpD$Cl^p@XEb6Vg&q9Bs!qTsgL z43Fgo_zkt-5blnrn(XV&OEGR7bH<0WGE3qE%2GYv`!CKQ;jiSOE8Esooray;t%DHY z_#VP(jQ7J$BiA~oisobnXBE`_bJAFyrKR4>(^w?r@Xz{5{d4QcoeSQ)o91@d?UWmz zTLx2t*>%(0GCbCA$BQS#wxojbHc!ppW9f+ri zCm!sNrxytz39uRTj3-M6Tw>Z;X8h;o-y1)?$h`O!2zPW93ooMZ4qiZLc^tMsG~$L| zELM?gCM*;Q{6Ci2Dk@;Nn2c}*{vU_m^!HGo&weCZOJCN*zTPvAH0m2wPtV|=iijfA z+yV0KBSiTf$X++yqXo+asM5K*&dLyA!2$rN-s4In$q+z$oB1VBF zDTE$0ppKy^vk?Cmp=1*MrrO3JX9hi^QIaKy_WEroAptXCtd>%g7a5*H7&GB9g?}N; zSru!C_rDaqNTM{2g|HMts0II13nNgYfPU_WcBeS)P#-DHof`@j9@7X|xhCQt{fz)e zg5?}_q%p!);2hsK^-2;x2-kdeDE|ywv_3wvgx{(QZPBID%&(- zp)?3D6r~#KU=Eqdzr$(|l17MwV*BkA3PoY*$+lELF8Z0ZDZCs?W|K8|`=zCg)f2*B z)Ny`K)>bw*ECk2KYeZgRFnR1^6eTu4k@N*%0Qlb?RF$nrEle*+HV+E5HjHAHF?&!Q zzD<)H6pN1Z>dr0f)gQ>wqxI;>oW4d!dV@ys=tvizvC2`Eqsq%GCXb&z+xhYT;ok8< z1Rr!;I8Zdi$o#9WyBQ4!pZ{2EbusW@c*8SFI>j#*=`$YDN^pBK821Eu% z?v1<`2}PA?W%RV@s_37hd)XuG33kH1Ck`?N+p-|sE^ZZXlb(_OD!nCrF6nZ)JX5}2 zUN7G*Z;`*3`zQw}gOwAN=}NWIqTHd}qij~TD%+GJ)T7nms-c#_>^@dINn4TP>tlDt{uJ99tB$9MX_YZ|H{oD$k@%$eocOZXEq)+=A^t|1E7eIU=?v)+ zslR%-+Nd>ai?s{1HQGvjEk3G#r{1N%p|3UWHa;|p%{KFF^9pl|d5g6=61G9^VBg0# zZN<6b67f9oE%9^lV)bElFYO3zk+xjBN873Gp`V~9^g+f7W2LdixYp<})*H7P8;pVG zFmsdnnE9PqY8?~_MZSsrDmpuwiLQpv5}X9!S0D&CO7BXaNJn7>{UrZgd0)9)dre17~w!go6#Lqt4S znk84u%jHe7p!QMsQv0hV>HxJ!yHtBcSB+Liy~vtxOxQ z!Eu7gK|vf1#Ci;=gViC}8>0FLRWw!8G^1vjS#C}+4-Lba0{l=A9+94qx5=N#{jjU1 zs|odT^%nI+?ImqrUDLQ2{Udz_=-m0nTH`_E zY2!;!yF<;tn1euhB&x zUiqD}UHPZ7w|b;nr(UFPR{ujyY8~2R+5!47Q2(d(zv;g+!bYQUr7_4n33P3h`KbAd z`H49sd`EaYDDt=AgROdNyR{^8Q{)p+x^ts1L|23M^LF1?rf74txmvAOuQh5*w9Ac6 z#@oinpe=@Zxm6t59vuk`PO|6Pi|jM8uWqt8+mG2V+aKCRv3{|`V7np5;Sa<6T9&oR+Gc%Y{S@hA|Jpv)e%l@p4^yAZiiq?Jwc-(y zEOkgD!5ufsFUb3%RYAR7{e^L)ak7yz)`RD5wwBx1*j@H#_Fl0Aft5}w4A*-*^$%uCJH=8SMOG9fZCQW=>ZnH`xEnH$+RIxgBjRuUT!8wf0i zVuNEFV~56XioZzp%`L*&0y-bDN<3a339eY8%uza&4N9l7QMn)duuIvZJgK~)Jfn82 z`)VQWJn*82LBCq{hxP4x#yB6lc0JZ|-u4 zFElrsZ<@afpMd>-Yxs}h`+%)i!{3ERTNRKlW?{r{T1AoLBNs%DiKe0}qBljiM|XgO zd~g3pOlaq8>@e{-aUOX3hnU+U=>X|?sY0rhW=KuaWzwzEJJKHVJmoay8s#+g47FWd zsxDKPt1Hx%>Kf2FqHkN(Vr`)Isn$kVK&GBZH`2}R0^TXT1hd|1B*?K*)1ABcl z_SvfVCeZsLCO-*cSbRe)m7bUWA!(Seqm|c`)#^j)LT#<~qPCYlU0VP0mgHE+Qle$IT&+zH;^KRhseOn5B#=WoOF!)Jw8K+?JmJNw=6 z=iz^akAi$RAaZo%`{=W_6f29J6I&C*s~D_b9r82EPUS0QunLJn`-gUdezLw9)cZB_ z7)WdjBgfj0+hy_V;=;BfoW}$qBn_5^VCRXFDw$GLDwE2k3DQK&)pTh#_TpTrR;rg8 zrHs@fErztyj=i}I9Cd}XQd%Qji=D9^^ZBauzI2UpnD)G7N0vu#v+uW`uwSr+?jrb6 z3c|O_QQ$+rH=ZRalmTATKn{*Atmaj>y7yo=l>aRwZMZ0q!U z^{x7=`eUGL??pb2Ot5#@U)!h0E{Yu!H)u~lDKMZ2EK+(|dK+}&BdJK<4;&>bSICp) z7Wqv1GDx!zg2Vq=eiK~&Gtk$*N`K{OWvF5+Gn6JJ3$A~&vPpSNd0P1b)Z<5G4|N~) zU~tZ{pd$0JZa!3HZN8S#7DBQ-S6ilCuC0Q^vmTt`ZtUqtwWq+Z{tkKVBkgnTd##VY zzkZk=(nWAk;$O4$--3f>^|SP)`f7cHzDfU!{;vL+KHQLuso*FB%_Gc_<|M4`d6@eb zF-zU%=jOj4Uylf%9&Qh>4nF|dX?ytf@H^qp!UL_4HQbUd(~4Q;;C+?WOsg7nz8Mn# zk&$B~!w9z__{QS#3U)z>G(Z|+54S~I1wD`2Wp+8F?umAXy#X_{#olJWVZU#G1qaps u*tf-Ou6F3}>+QxeV>zVFEtoO9Bn6*XpjsRt4i<-qQCj@}|M%aHf&T=akF$^f literal 0 HcmV?d00001 diff --git a/doomsday/external/libpng/win32/libpng15.lib b/doomsday/external/libpng/win32/libpng15.lib new file mode 100644 index 0000000000000000000000000000000000000000..75ce2bc64baa8a43c82bddb3a77fadf1da88b28c GIT binary patch literal 53568 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